SuperAPI AI Directory
Partner with us中文AI newsFavorites
All toolsAI agentsOpenAaaS

OpenAaaS

Adapter to the OpenAaaS scientific agent network: submit tasks such as literature analysis or materials database queries to remote research agents.

Open website

About this tool

OpenAaaS (Open Us to the Agentic World) is an Agent-to-Agent orchestration network (Agent Orchestration Network) for AI for Science. It defines AaaS as Agent as a Service, but Service here does not refer to the centralized hosting and subscription of traditional SaaS; rather, it refers to the publishing, discovery, delegation, and composition of capabilities: each node publishes its own Agent capabilities as discoverable units in the network, and after primary agents outside the network discover these capabilities, they can delegate tasks to the nodes and integrate the results.

  1. Purpose and Core Philosophy The core goal of OpenAaaS is "intelligence flows, data stays put"—let Agents go to the data, rather than handing the data to the Agents. Each node in the network runs an Agent instance with a complete toolchain; data resides in place where it is generated, and Agent capabilities flow through the network to the data to complete analysis, computation, and collaboration. These nodes constitute shared capability infrastructure; outside the network, primary agents such as pi, Claude Code, Cursor, or self-developed Agents each discover and compose these capability nodes through the OpenAaaS protocol.

  2. Protocol and Deployment Characteristics Unlike the point-to-point direct connection model of the A2A protocol released by Google and now hosted by the Linux Foundation, A2A requires each invoked Agent to declare an addressable HTTP endpoint in its Agent Card, and asynchronous scenarios also require bidirectional network reachability to receive webhook callbacks; in scientific research laboratory environments without public IPs and subject to strict outbound firewalls and NAT constraints, the invoked party is unavailable. OpenAaaS adopts a one-way outbound HTTP short-polling model; nodes only need to actively access a public server to join the network, without requiring a public IP or opening inbound ports. Its technical design and implementation details are described in arXiv:2605.13618.

  3. Main Capabilities

  4. Agent orchestration, nodes are Agents: what OpenAaaS orchestrates is not scripts, functions, or fixed APIs, but complete Agent instances running on remote nodes. The Docker container on each node runs a complete Agent with local tools, models, and data, capable of autonomous decision-making, autonomous execution, and, when needed, continuingDelegate to sub-agents. For example, Claude Code can discover a data analysis agent running on a lab server and delegate tasks to it; when that node agent processes local data, it can further invoke sub-agents within the node to perform cleaning, modeling, or visualization. Any agent (Claude Code, pi mono, etc.) can join the network, discover, delegate to, and compose agents on other nodes.

  5. In-place data processing: raw data always stays where it was generated, and remote agents work directly alongside the data. Different labs, servers, or instruments can collaborate around the same complex task: each node only processes its own local data, and the network only transmits task descriptions and results (KB~MB level), without touching the raw data (TB level). No unified data format is required; JSON/CSV/Excel/MATLAB/HDF5/vendor binary formats can all be processed in place. Existing scripts, models, database queries, instrument interfaces, or internal tools can be packaged into a complete agent instance's Docker image, registered on the network for other agents to discover and delegate to. What a remote agent sees is not a callable function, but a complete agent capable of autonomous decision-making and using its local toolchain to complete tasks.

  6. Zero-configuration network onboarding and self-describing discovery: nodes join the network with zero configuration; open-aaas-server run automatically generates config.toml and SQLite on first startup. Self-describing network interfaces + progressive capability discovery allow agents to discover and use the capabilities of other agent nodes without plugins.

  7. Near-data computation, low-barrier deployment: Rust single binary + embedded SQLite, zero-dependency deployment, copy and use. Docker-isolated execution, with an independent sandbox for each task. A node can join the network with outbound-only connectivity, requiring no public IP, no open ports, and no SSH, designed specifically for lab firewall and NAT environments.

IV. Currently Available Services and Updates

  • August 2026: AutoGluonAgent tabular machine learning agent launched on the public server, an automated machine learning service for structured tabular data that automatically identifies the target column and completes classification/regression modeling without manual modeling.
  • August 2026: IDM-Alpha materials science literature research assistant backend upgraded, greatly improving the answer accuracy of materials science literature question answering.
  • August 2026: AFLOW materials database query agent launched on the public server, allowing natural language queries to the AFLOW materials database without needing to know the query syntax. The currently available services can be queried in real time via pyopenaaas or the OpenAaaS API.

V. How to Use

  1. Connect to the network: any of the following methods can let an agent join the OpenAaaS network, discover remote agents, and delegate tasks to them. The public server address is https://api.open-aaas.com。
  2. Jupyter Notebook (Binder): Click the Binder badge to run binder/quickstart.ipynb in your browser without installing any software.
  3. Desktop client: A cross-platform desktop application based on Tauri, supporting macOS and Windows, suitable for non-technical users to manage multiple servers, drag and drop files to upload, and view task progress in real time. You can download the .dmg or .msi installer directly from GitHub Releases. On macOS, the first time you open it, you need to go to System Settings → Privacy & Security → Security and click "Open Anyway". See client-app/README.md for details.
  4. Python SDK: In OpenAaaS, submit_task means having an Agent submit a delegation request to another complete Agent instance on a remote node, rather than calling a remote function. See pyopenaaas/README.md for details.
  5. MCP adapter: openaaas-mcp-adapter has been published to PyPI. MCP-supporting clients (Claude Desktop, Cursor, Cline, etc.) can connect with just one configuration. toolTimeoutMs sets the maximum waiting time (in milliseconds) for MCP tool calls, suitable for long-task polling scenarios; this parameter is parsed by the MCP client, and whether it actually takes effect depends on the specific client implementation. Some clients or Agent tools themselves may still have independent timeout limits, causing this parameter not to take effect. Codex users can add the adapter via the CLI. If long-task polling support is needed, configure it in ~/.codex/config.toml (or the trusted project's .codex/config.toml); Codex's tool_timeout_sec is in seconds, and when calling poll_task it is recommended to set timeout_seconds to a value smaller than that and reserve time for network requests. After configuration, restart the client to call all capabilities in the conversation. See openaaas-mcp-adapter/README.md for details.
  6. pi extension: A TypeScript extension for pi users. After installation, you can use instructions such as "Help me set OpenAaaS's server address to https://api.open-aaas.com，然后向合适的远程 Agent node delegates a data analysis task", and the client Agent automatically completes registration, node discovery, task delegation, and result retrieval.
  7. Plugin-free access: If the Agent does not have the OpenAaaS plugin, directly access https://api.open-aaas.com。无需认证，返回完整 API documentation and usage instructions. After the Agent reads them, it can automatically complete registration, node discovery, and task delegation.

VI. Download and Deployment No need to install Rust; download and run (GitHub Releases): Server / Agent Core provides Linux x64 (musl static linking), Linux arm64 (musl static linking), macOS arm64, Windows x64; the desktop client provides macOS and Windows. The Linux version uses musl static linking and does not depend on the system glibc, so it can run directly on any Linux distribution. On first startup, config.toml and the SQLite database are automatically generated. For Agent Core deployment, see agent-core/README.md.

VII. Project and License Links to the official website, paper, server documentation, agent-core documentation, usage guide, MCP adapter, PI extension, Python SDK, desktop client, etc. are all provided in the repository. The paper is arXiv:2605.13618 (https://arxiv.org/abs/2605.13618）。项目采用 MIT License © IDM Explorer Lab. Contributions are welcome; please read CONTRIBUTING.md. Some design blogs and user stories are also mentioned in the repository.

Related tools

Browse category