Paper · 2406.07089 · 2024
RS-Agent: Automating Remote Sensing Tasks through Intelligent Agent
arXiv · PDF · Open in the Atlas
Code that ran
4 of 5 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (0 of them constructed an object rather than computing a result; 0 honoured the contract we drafted, 0 violated it and 0 have no contract verdict; 4 failures of our instrument; 1 no recorded run), measured 2026-11-22; repository links from the Papers with Code archive attributed under CC BY-SA, no affiliation; bodies inline only under a permissive licence as GitHub detects it. Not a reproduction of the paper's results.
- 0 ran with no instrument failure
0 honoured the contract we drafted, 0 violated it, 0 have no contract verdict
- 4 ran where Syntology's instrument failed
failures of Syntology's instrument, not of the code: 4 where our contract draft was wrong, 0 where the contract check could not run
- 1 have no recorded run
- 0 of those that ran constructed an object rather than computing a result
an executed sample whose run returned an instance of its own class (fixture_out_type equals the entry name): the run built an object and did not compute a result
- 0 are pointer only: the body is not served under this paper's link
"Ran" means the function executed on a synthesized input and returned a value. It is not a reproduction of the paper's results. This record, dated, as JSON: /api/ran/2406.07089.json · badge: /api/ran/2406.07089.svg
Each repository's role is a label: a classifier's output recorded on the link, or, where no role is recorded, what the Papers with Code archive marked. The line under it names its basis. Neither says who wrote the code.
| Repository | Role | Ran |
|---|
| intellisensing/rs-agent |
canonical (classifier label) classifier basis: census |
4 ran · 1 no recorded run |
| Function | Status | Where it lives |
|---|
| extract_first_tool |
Ran ran; our contract draft was wrong, not the code |
intellisensing/rs-agent/benchmarks/planning/score.py code served (permissive licence) · get_code("746af84399f80aba") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned str. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import re
from typing import Any
# Define a simple action class with a 'tool' attribute
class Action:
def __init__(self, tool: str):
self.tool = tool
# Test case 1: intermediate_steps with tuple containing action object with tool attribute
action1 = Action("search_tool")
intermediate_steps_1 = [(action1, "observation")]
# Test case 2: intermediate_steps with tuple containing dict with 'tool' key
action_dict = {"tool": "calculator", "input": "2+2"}
intermediate_steps_2 = [(action_dict, "observation")]
# Test case 3: intermediate_steps with action that has tool in repr
class ActionWithRepr:
def __repr__(self):
return "AgentAction(tool='weather_tool', tool_input='NYC')"
action3 = ActionWithRepr()
intermediate_steps_3 = [(action3, "observation")]
# Test case 4: empty intermediate_steps
intermediate_steps_4 = []
# Test case 5: action with tool in JSON-like repr
class ActionJSONRepr:
def __repr__(self):
return '{"tool": "database_tool", "input": "SELECT *"}'
action5 = ActionJSONRepr()
intermediate_steps_5 = [(action5, "observation")]
# Primary test case: using the first one with clear tool attribute
ARGS = {
"intermediate_steps": intermediate_steps_1
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| load_config |
Ran ran; our contract draft was wrong, not the code |
intellisensing/rs-agent/rs_agent/config.py code served (permissive licence) · get_code("1ec7ac3eddfe5bff") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import os
import tempfile
from pathlib import Path
import yaml
# Create a temporary directory and config file for testing
temp_dir = tempfile.TemporaryDirectory()
temp_path = Path(temp_dir.name)
# Create a minimal YAML config file
config_data = {
'embedding': {
'model': 'default-model',
'device': 'cpu'
},
'llm': {
'api_key': 'test-key'
}
}
config_file = temp_path / 'default.yaml'
with open(config_file, 'w', encoding='utf-8') as f:
yaml.dump(config_data, f)
# Create a .env file in the temp directory
env_file = temp_path / '.env'
with open(env_file, 'w', encoding='utf-8') as f:
f.write('EMBEDDING_MODEL=custom-model\n')
f.write('EMBEDDING_DEVICE=cpu\n')
f.write('OPENAI_API_KEY=test-api-key\n')
f.write('OPENAI_API_BASE=https://api.openai.com/v1\n')
# Mock the module-level PACKAGE_ROOT and PROJECT_ROOT
import sys
from types import ModuleType
# Create a mock module to patch the globals
mock_module = sys.modules.get('__main__')
if mock_module:
mock_module.PACKAGE_ROOT = temp_path
mock_module.PROJECT_ROOT = temp_path
# Set environment for load_dotenv
os.environ['EMBEDDING_MODEL'] = 'custom-model'
os.environ['EMBEDDING_DEVICE'] = 'cpu'
os.environ['OPENAI_API_KEY'] = 'test-api-key'
os.environ['OPENAI_API_BASE'] = 'https://api.openai.com/v1'
# Define ARGS with the config_path parameter
ARGS = {
'config_path': str(config_file)
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- dotenv, yaml — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| normalize_task_type |
Ran ran; our contract draft was wrong, not the code |
intellisensing/rs-agent/benchmarks/planning/score.py code served (permissive licence) · get_code("0456685d7dc9d641") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned str. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import re
def normalize_task_type(task_type: str) -> str:
"""Normalize task type labels from JSON or LLM output."""
match = re.search('\\[([^\\]]+)\\]', task_type)
if match:
normalized = match.group(1).strip().strip('\'"')
else:
normalized = task_type.strip().strip('\'"')
aliases = {'Object Counting': 'Object_Counting', 'Object Detection': 'Object_Detection', 'Land Use Segmentation': 'Landuse_Segmentation', 'Image Captioning': 'Image_Caption', 'Scene Classification': 'Scene_Classification', 'Instance Segmentation': 'Instance_Segmentation', 'Edge Detection': 'Edge_Detection'}
return aliases.get(normalized, normalized)
ARGS = {
'task_type': '[Object Detection]'
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| resolve_path |
Ran ran; our contract draft was wrong, not the code |
intellisensing/rs-agent/rs_agent/config.py code served (permissive licence) · get_code("c022f7fe5e2beab3") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned PosixPath. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
from pathlib import Path
import tempfile
import os
# Create a temporary directory structure to simulate a project
temp_dir = tempfile.mkdtemp()
package_dir = os.path.join(temp_dir, "package")
os.makedirs(package_dir, exist_ok=True)
# Simulate PROJECT_ROOT and PACKAGE_ROOT
PROJECT_ROOT = Path(temp_dir)
PACKAGE_ROOT = Path(package_dir)
# Test with both relative and absolute paths
relative_path = "some/relative/path.txt"
absolute_path = Path(temp_dir) / "absolute" / "path.txt"
ARGS = {
"path": relative_path
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type PosixPath — a PosixPath output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a PosixPath output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| extract_all_tools |
Not yet run unverified (harvested, no recorded run) |
intellisensing/rs-agent/benchmarks/planning/score.py code served (permissive licence) · get_code("082fb94fcb4b1d9f") How it ran |
Also present in other papers' code
Of 5 samples lifted from this paper's linked repositories, 5 carry a function identity and 0 do not. Of the 5 distinct functions with an identity, 0 are also present in other papers whose code we hold (0 with at least one paper dated earlier, 0 the same month, 0 later) and 5 are only here among the 52,977 papers whose code Syntology holds (as of 2026-09-26).
Only here means: among the 52,977 papers whose code Syntology holds (51,887 with lifted samples, 1,090 through their assemblies only), as of 2026-09-26, no other paper's lifted samples or current assembly bricks contain an identical function body after normalisation.
Presence, not direction: an identical function body in two papers' repositories does not say who wrote it, which came from which, or that either paper's method rests on it. Matching is exact after normalisation, so a renamed or edited function is not matched. Dates are when papers appeared, not when code was written. Only .py files the harvester lifted are covered; notebooks are not read. A new-style arXiv id YYMM.NNNN dates a paper to the month 20YY-MM; otherwise Paper.year dates it to the year; otherwise it is undated. Dates are when the paper appeared, not when the code was written. Read 2026-11-22.
Repositories linked to this paper
Some links come from the archived Papers with Code dataset (CC BY-SA 4.0): attribution and licence.
Abstract
Recent advances in Multimodal Large Language Models (MLLMs) have shown promise for remote sensing tasks such as visual question answering and scene understanding. However, existing models remain limited to basic instruction-following and struggle with real-world scenarios that require multi-source data integration, fine-grained spatial reasoning, and domain expertise. To address this gap, we propose RS-Agent, a domain-adapted intelligent agent that connects user intent with professional remote sensing workflows through structured task planning and tool orchestration. RS-Agent consists of four components aligned with typical remote sensing workflows: a Central Controller for intent understanding and process planning, a dynamic toolkit for tool execution, a Solution Space for task-specific expert guidance, and a Knowledge Space for domain knowledge support. We further introduce Task-Aware Retrieval, which improves planning by identifying task types and retrieving expert-defined solutions, and DualRAG, a weighted dual-path retrieval-augmented generation method that enhances the relevance and completeness of retrieved knowledge. RS-Agent natively supports multiple imaging modalities, including optical and SAR imagery, and can automatically organize dedicated SAR processing tools into executable workflows. Experiments on 9 datasets and 18 remote sensing tasks show that RS-Agent significantly outperforms state-of-the-art MLLMs, achieving over 95% task planning accuracy and strong results in scene classification, object counting, and remote sensing visual question answering. These results demonstrate the value of combining LLM reasoning with remote sensing expertise for intelligent geospatial analysis.
For agents
The same record, over MCP at https://syntology.ai/mcp:
get_harvested_code_for_paper("2406.07089")
get_code_for_paper("2406.07089")
have("2406.07089")
The run record, dated, one paper per request, free:
curl https://syntology.ai/api/ran/2406.07089.json
A badge for a README (the split and the date, never a ratio):
[](https://syntology.ai/paper/2406.07089)
Connect an agent — have() is free.