The missing layer

MCP and A2A standardized how agents talk. Models are converging. Neither solves the harder problem: discovering agents on any protocol, composing them into one run, and checking what each step actually did.

Today that layer is hand-built glue code inside every serious stack. No shared identity, no common record, no way to prove a run happened the way someone claims it did.

Metaorcha is that layer, open and inspectable. Neutral ground: agents stay external services that you own and run. The harness plans, routes, verifies, and renders. It does not embody any single agent.

See it work

Type a goal. Metaorcha discovers agents, composes MCP, A2A, and computer-use in one run, and renders a CanvasKit dashboard instead of a chat reply.

Every call passes a 7-step execution pipeline: input validation, payment guard, preflight, protocol dispatch, output normalization, checklist update, settlement. Each step gets a verdict, and any run downloads as a JSON evidence package: per-step agent, protocol, verdict, cost, timing.

Output is not a chat bubble. Agents return a declarative CanvasKit manifest and the runtime renders metric cards, charts, tables, and alert feeds as a live dashboard. Structured output persists, and structured output can be checked.

Hero goal (3 protocols, one run): "Show me my portfolio performance, use your web scraper agent to summarize https://en.wikipedia.org/wiki/Nvidia, and screenshot the Alpaca dashboard" → finance MCP + web-scraper A2A + mock computer-use. Verified live, 5/5 runs, best wall clock 13s.

Try it: clone and run ./scripts/run-all.sh, or bring up the sandbox stack locally with make -f deploy/sandbox/Makefile up. Demo portfolio data is illustrative, no brokerage connection required. (A hosted public sandbox is not currently up — see the roadmap.)

Prove it yourself: ./scripts/poc-e2e.sh registers a paid agent via the emerge SDK, runs a multi-protocol goal, and asserts verification, retry, and settlement end to end.

Terms

Register an agent in 4 lines

Metaorcha ships the orcha-sdk package (import name emerge). orcha-sdk init scaffolds an agent, orcha-sdk run serves it and registers it with the runtime. No clone required: uvx orcha-sdk init my-agent.

import emerge

@emerge.agent(name="My Agent", description="What I do")
def handle(task: str) -> str:
    return f"handled: {task}"

orcha-sdk run     # serve locally and register with the runtime

Quickstart

Just building an agent? Zero clone, no infrastructure:

uvx orcha-sdk init my-agent && cd my-agent && uvx orcha-sdk run

That serves a live A2A agent on :8900 — /health, /.well-known/agent.json,
and JSON-RPC message/send all answer immediately. Registration needs a
registry; without one running, run says so and keeps serving. Start the
runtime below to register, or use orcha-sdk run --no-register.

Running the full runtime (registry, planner, orchestrator, dashboard):

git clone https://github.com/solvent-labs-org/metaorcha && cd metaorcha
./scripts/run-all.sh        # infra + all services + seed agents

Per-service details live in the docs.

Bring any OpenAI-compatible LLM key (Gemini and Groq free tiers work) or run models locally through Ollama. Payments run in mock mode by default: no wallet, no closed-service dependency.

Architecture

Goal in, verified run out:

Goal
 └─► Registry ──► Planning & Discovery ──► SuperAgent
                                               │
                         ┌─────────────────────┼─────────────────────┐
                         ▼                     ▼                     ▼
                   MCP handler           A2A handler          COMPUTER_USE handler

(protocol.type: "acp" is still accepted in emerge.yaml and routes through
the A2A handler, a compatibility alias rather than a fourth independently-bridged
protocol. The emerge.yaml schema and its governance rules live in
docs/spec/.)

Contribute

→ CONTRIBUTING.md · Write a bridge · Open a RFC

What's next

Sandbox hardening + UIUX (v0.2.0), full trajectory in the roadmap.