L2M MCP agents, governed
  • Open source · MIT
  • Self-hosted only
  • No call-home

The place your MCP agents run and are governed.

Build tool-calling agents in a visual studio, run them against your MCP servers, and decide what every tool call may do: policies, approvals, signed audit bundles and a release gate. It all runs on your own infrastructure.

Runs in your browser, no sign-up. Recorded runs; nothing leaves your browser.

Build and run

A studio built around the agent.

Agents are the centre of the canvas, not a node among many. Everything you build is versioned workflow JSON you can diff, review and import.

The Orbit studio

  • Agents are round hubs; model, memory, tools and workers sit on rings as slots.
  • Flows lay out into stages, with a stage strip and one-click Tidy.
  • A run tape shows per-node timing, with LLM time marked.
  • A docked inspector for parameters, input, output and trace.
  • A command palette on ⌘K / Ctrl K. Light and dark themes.
  • Import workflow JSON from other builders: preview the conversion first, then fix what's left from a checklist.
Workflow editor →

Run MCP agents

  • A tool-calling loop: zero, one or many tool calls per step, until the answer or the iteration limit.
  • Supervisor and workers: workers become tools of their Supervisor, each with its own model, tools and memory.
  • Memory per session, and a session tool cache so later turns can reuse full tool output.
  • MCP-native tools over stdio and Streamable HTTP, with compact tool definitions and per-agent tool selection.
  • Agents can stop and ask the user a question mid-run.
  • OpenAI, Anthropic, Gemini, Azure OpenAI, Ollama and OpenAI-compatible models, plus a built-in echo model that needs no key.
The agent loop →
MCP control plane

Every MCP server your agents call, in one place.

One MCP registry for every server your agents call, and an MCP gateway that serves their tools to outside clients. L2M probes each server, tracks its tools and what they cost, and enforces who may call what, for agents and clients alike.

  • Registry and onboarding. Health probes, tool schema snapshots with breaking-change diffs, a playground, and import from MCP client config files.
  • Telemetry and policy. Calls, p95 latency, errors, tokens and cost per tool. Allow and deny rules by project, role, server and tool, plus a "no write tools" switch.
  • Gateway. Serve workflows and registered tools to other MCP clients, with per-client tokens and the same policies.
  • Credentials. OAuth 2.1 for remote servers, or each user's own delegated account.
  • Testing. Record MCP calls into cassettes and replay them; l2m mcp check fails CI on breaking changes or blocked tools.
  • Runtime safety. Stdio servers in sandboxed containers, rate limits, concurrency caps and a circuit breaker.

Guides: Run a self-hosted MCP gateway · Govern MCP tools · Test MCP servers in CI

New to MCP? Read what MCP is · MCP security risks

MCP control plane docs →
The MCP tools page in the L2M studio: a catalogue of five tools from a registered demo server, with filters for destructive, open-world and blocked tools, and columns for calls, errors, p95 latency, cost and policy (read-only or write). The demo has no calls recorded against this server, so the telemetry columns show dashes.
MCP → Tools: one catalogue across every registered server, with each tool’s policy. Telemetry fills in as agents call the tools.
Govern

Decide what agents may do, and prove what they did.

Approvals, an audit trail you can verify offline, and rules for where data may go: governance for AI agents, on your own infrastructure.

Learn: Human in the loop for AI agents

Approval gates

Pause a run on a person. Approval gates, human approvals, write tools an agent wants to call and versions waiting to be published all land in one Approvals inbox.

Approvals →

Signed audit bundles

Every finished run gets a manifest of models, tool calls, prompts and approvals. Export it as an Ed25519-signed bundle with secrets scrubbed, and check it offline with l2m audit verify.

Audit bundles →

Data labels and destinations

Label where each step's data came from and what it contains. Sort every model, server and URL into local, private, approved-vendor or public, and block, redact or ask for approval when sensitive data would go too far.

Data destinations →
The Approvals inbox in the L2M studio: two pending approval-gate requests from a refund workflow, each with an editable reply, the requester, the allowed approver roles, and Reject and Approve buttons.
Approvals: decide paused runs, and edit fields before approving.
Ship safely

CI for agents.

Treat a prompt or tool change like a code change: replay it against known-good runs before it reaches production.

  • Golden runs and sets. Save good runs, group them, and replay a draft or a saved version against them.
  • Scorers. JSON equality and schema, text similarity, tool sequence, status, budget and an LLM judge.
  • Release gate on publish. A version reaches production only after its replay job passes the gate's policy; an override needs a written reason and is audited.
  • Production capture. Sample real runs with personal data masked, and promote the useful ones into a golden set.
  • A CLI for your pipeline. Run replays, write JUnit results and publish from CI.
ci.sh
# replay the draft against a golden set; non-zero exit when it fails
l2m replay run --set faq-golden --draft --junit replay.xml
# publish a version through the release gate
l2m release publish wf-faq --version 4

Replay and the release gate →

Learn: Regression testing AI agents

The Publish to production dialog in the L2M studio: version 4 is blocked by the release gate because 0 of 3 golden cases passed and there are 3 regressions; an admin override needs a written reason.
A release gate blocking v4: 0 of 3 golden cases passed.
Self-hosted foundations

Yours to run. Nothing hosted by us.

L2M is an open-source agent runtime (MIT) that runs only on your infrastructure. There is no hosted edition and no call-home: the product sends no analytics anywhere.

Learn: Self-hosting AI agents: what you run

Auth and access

Session sign-in, API keys, TOTP MFA, and SSO through SAML or LDAP (optional packages). Admin, builder, operator and viewer roles, projects and custom roles.

Auth and RBAC →

Encrypted secrets

AES-256-GCM at rest, master-key rotation through export and import, and external managers: HashiCorp Vault built in; AWS, Google Cloud and Azure with their SDK installed. Configs carry secret references, never values.

Secrets →

Signed webhooks

Bearer or HMAC-SHA256 with a replay window and optional idempotency keys, plus signature checks for Stripe, GitHub, Slack, Telegram and Discord triggers.

Secure webhooks →

Schedules and queue

Cron schedules and a database-backed run queue, rate limiting and security headers, and cost tracking with budget caps.

Observability

Prometheus metrics, OpenTelemetry traces over OTLP, request IDs through the logs, and a tamper-evident audit log.

Observability →

Storage and deploy

SQLite by default; Postgres support in progress. Docker images for amd64 and arm64, Docker Compose and a Helm chart.

Everything is optional. A simple workflow runs with no extra configuration. Approvals, release gates, data labels and destinations, production capture and sandboxing stay off until you turn them on.

Get running

From clone to a working MCP agent.

No model key is needed to start: the MCP Agent Quickstart template uses the built-in echo model and an in-process mock MCP server. Swap in real models and servers when you're ready.

  1. git clone the repository, then pnpm install (Node 24+, pnpm 10+).
  2. Copy .env.example to .env, set SECRET_MASTER_KEY_BASE64 and the bootstrap admin's email and password.
  3. pnpm dev, then sign in at localhost:5173.
  4. Templates → MCP Agent Quickstart → Use template → Run.
Open source · MIT

See it before you install it.

The live demo is the real studio with recorded runs: build an agent, run it, and watch the release gate at work. When you're ready, self-host it.