Skip to main content Molecule AI is now Enter OS →
Molecule AI
Blog
Architecture

From one agent to a governed AI org

Building a single agent is easy. Running a team of them in production — governed, observable, and able to delegate safely — is not. Molecule AI is the layer that does it. The SDK runtime contract is the source of truth for every engine offered by the platform.

GOVERNANCE & TOPOLOGY
Go · Postgres · Redis

Molecule Control Plane

The org chart IS the routing table. One CanCommunicate() rule enforces who may delegate to whom, memory scope (LOCAL/TEAM/GLOBAL), approval routing, and full observability — at every call.

INTER-AGENT PROTOCOL
JSON-RPC 2.0 · Agent Cards · MCP tools

A2A + MCP

Workspaces discover each other via the registry and delegate peer-to-peer over A2A — the platform is never in the message path. MCP exposes the platform's tools (delegation, memory, approval, sandbox) to every agent.

PER-AGENT RUNTIME (SWAPPABLE)
SDK contract

Workspace runtimes

A managed workspace can select an official or custom adapter; model, system prompt, and tools are supplied at provision time. Self-operated agents use the external registration mode while retaining their adapter's safe RuntimeId.

Claude Code · claude-code Codex · codex Hermes · hermes OpenClaw · openclaw external mode · adapter ID retained
Contract example

One team across every official runtime

One declarative goal enters; a Marketing Lead coordinator delegates to four specialists over A2A. Every specialist below uses an official discovery ID from the SDK registry; custom adapters may use any conforming RuntimeId.

COORDINATOR
Marketing Lead
Claude Code
Trend Researcher

topics, competitor moves, rising trends

Codex
SEO / GEO Agent

search + generative-engine optimization

Hermes
Content Writer

on-brand pages, posts, copy

OpenClaw
Social Media Handler

schedule + publish across surfaces

  1. 1 Declarative goal in
  2. 2 Marketing Lead decomposes
  3. 3 Delegates over A2A / MCP
  4. 4 Managed specialists execute
  5. 5 Scoped memory + canvas report

Frequently asked questions

Quick reference for the architecture concepts on this page. See the glossary for canonical per-concept definitions.

How does Molecule AI route messages between agents?

Molecule AI uses an agent-to-agent (A2A) protocol layered on JSON-RPC 2.0. Workspaces discover each other through the platform registry and exchange messages peer-to-peer over A2A, so the control plane is never in the message path itself. The Model Context Protocol (MCP) sits next to A2A and exposes the platform's tools (delegation, memory, approval, sandbox) to every agent — agents call platform capabilities the same way they call peer agents, so teams don't have to maintain two integration paths (one for tool calls, another for peer delegation). Both synchronous (delegate-and-wait) and asynchronous (fire-and-poll) delegation are supported, so an agent can either wait inline on a small follow-up or kick off a long-running task and come back later. Every message, every tool call, and every approval is logged in the audit trail. The benefit is a single composable surface: one consistent way to send work, one consistent way to see what happened.

What agent runtimes does Molecule AI support?

The SDK registry lists Claude Code, Codex, Hermes, OpenClaw as the official first-party runtimes. RuntimeId remains open to bounded, path-safe custom adapter IDs. External registration describes where an adapter executes; it does not replace that adapter's identity.

How does Molecule AI enforce governance and observability?

Governance and observability are first-class layers of the Molecule control plane, not bolted on after the fact. The platform's audit trail is the integration: every A2A message, every task update, every skill promotion is appended to a JSON Lines log by default, so teams don't have to wire up a separate logging stack to see what their agents did. Tracing covers every LLM call end-to-end with Langfuse + OpenTelemetry, including tokens and cost reported per call. If a runtime adapter misbehaves, the audit trail still records the boundary call, so failures stay diagnosable from outside the agent. The Governance & Topology layer at the top of this page summarizes the public surface; deeper architecture details live in the developer-facing documentation.

Why does Molecule AI put the org chart at the center of how teams build agent systems?

Most multi-agent platforms ask teams to maintain two pictures of their work in parallel: a visual diagram for planning and stakeholder review, and a separate configuration model for what's actually running. The two drift over time, and the drift gets expensive — engineers update one and forget the other, product managers look at a stale picture, new hires can't tell which view is true. Molecule AI is built around the idea that the org chart on the canvas is the working representation of the team. Teams sketch how their agents should collaborate the same way they'd sketch a human org chart: lead at the top, specialists reporting in, peers grouped where they share work. The benefit is design-time speed and a shared mental model — engineers, product managers, and team leads all work from the same canvas as the team grows and reshapes, instead of translating between a whiteboard, a config file, and a runtime view.

Every LLM call is traced end-to-end (Langfuse + OpenTelemetry) with tokens and cost, and every A2A message, task update, and skill promotion is logged. Governance is structural — you can't bypass it by misconfiguring an integration.

← Back to Molecule AI