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.
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.
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.
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.
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.
topics, competitor moves, rising trends
search + generative-engine optimization
on-brand pages, posts, copy
schedule + publish across surfaces
- 1 Declarative goal in
- 2 Marketing Lead decomposes
- 3 Delegates over A2A / MCP
- 4 Managed specialists execute
- 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