Agentic Delivery Governance platform
In AlphaLet autonomous agents take on more of your SDLC without losing control.
Decide what agents can do, where humans need to approve, and what can run autonomously. Modulo enforces those boundaries and records every decision along the way.
Works with Claude Code, Cursor, Copilot, and your own agents.
Agent capability is moving faster than your ability to trust it.
Agents can already write code, change configuration, review pull requests, and cut releases. The limiting factor is how much your organization is prepared to let them do without a human watching every step.
Unreviewed change
An agent edits code or config and it ships. No gate stood between the output and production, and no one chose to let it through.
No provenance
You can't say which prompt, model, or agent produced a change, or who signed off. The trail is spread across GitHub, Notion, CI, and chat.
Audit as fire drill
SOC 2, ISO 42001, and EU AI Act evidence gets reconstructed by hand, per audit, from logs that were never meant to prove accountability.
Autonomy without evidence
You want agents to do more, but you have no measured basis to decide which changes are safe to automate and which still need a human.
Decide where autonomy ends and human judgment begins
Modulo is the layer that makes that decision enforceable. It sits in the path between your agents and your tools: steps are typed where you declare a schema, gated where you decide, and recorded.
Control
Typed schema seams validate the handoffs you declare, per-node capability scopes limit what each agent can reach, and approval gates sit in the merge path - not after it.
Prove
Every governance event lands in a hash-chained, append-only audit log in your own Modulo instance, alongside the captured output of every agent run.
Own
Run it on your infrastructure, with your agents and models. Bring your own agents - Modulo governs them, it does not supply or replace them.
Self-hosted only, no telemetry, air-gap capable, hash-chained audit log in your own instance, RBAC and HITL gates. Compliance frameworks: SOC 2, ISO 42001, EU AI Act.
Start from the process you trust today
You don't need autonomous agents to adopt Modulo. Wire it around the SDLC your team runs today, humans in every seat, and it gates and records the handoffs you already make by hand. Hand one step to an autonomous agent when you're ready, then the next, with the gates and audit trail already in place.
Stage 1
Human workflow
Every handoff made by hand
Stage 2
Agent-assisted
Agents draft, humans execute
Stage 3
Human-gated agents
Agents execute, humans approve
Stage 4
Autonomous where proven
Evals earn autonomy, evidence keeps it
Modulo sits on top of the entire progression - the same gates, permissions, and audit trail at every stage.
The Modulo library ships example pipelines for the moves teams make most. Each one is a full workflow - schemas, prompts, gates, and evals included - that you copy into your instance and shape to how your team already works. Three to start from:
- PRD to reviewed tickets - Turn a product brief into an implementation plan and a set of scoped, estimated tickets - with a human sign-off gate before anything lands in your tracker.
- Issue to tested pull request - An agent picks up an issue, writes the change, runs the tests, and opens a PR. Schema checks and an approval gate stand between its output and your main branch.
- PR review and remediation - Every agent-authored PR gets a governed review pass: evals flag risk, a reviewer approves or rejects with full context, and the decision is recorded.
How Modulo governs a pipeline
- 1
Define
Lay out the pipeline as a graph of agent, tool, gate, and human nodes. Bind typed input/output schemas to a seam so that handoff is validated before work moves.
- 2
Gate
Place deterministic checks and human approvals exactly where risk lives. Risky steps pause with full run context attached; a reviewer claims, inspects, and approves or rejects.
- 3
Audit
Every run writes an immutable record - inputs, outputs, prompt and model versions, evals passed, approvals given - timestamped and queryable after the fact.
- 4
Improve
Evals score the outputs you choose to measure. You set how much autonomy each pipeline gets, and budgets, circuit breakers, and an org-wide pause keep it bounded.
Self-hosted with Docker Compose - clone, docker compose up -d, and start governing your first pipeline. The first run builds the images; after that, it starts in seconds. Read the getting-started guide →
Engineers define processes, logic, and governance at the organization level, above any single workstation or repository. Modulo runs as one self-hosted deployment in your cloud, so what they define is a governed surface every team and agent works within. That is why delivery scales by compute time, not engineer time. Adding agents, gates, or teams is configuration in one place, and problems are solved once, at the organization level, for every developer's setup and every repo.
Is Modulo right for my team?
Modulo is self-hosted software that sits between your agents and your tools - typed handoffs, approval gates where risk lives, and an audit trail recorded as work happens. It is one more system to host and operate, and it only earns that spot if your team needs it. Here is how to tell.
A good fit if you:
- Want autonomous agents in your SDLC but need control over spend, agent permissions, and a human gate on what ships.
- Want the handoffs your team already makes by hand - reviews, approvals, sign-offs - recorded and enforced in Modulo before you hand any of them to an agent.
- Want governance that survives toolchain changes - swap models, agent tools, or git hosts without rewriting your pipelines or losing the record.
- Prefer tools you host yourself over granting another vendor access to your source and agent traffic.
If that describes you, the getting-started guide below takes you from clone to your first governed pipeline.
Probably not a fit if you:
- Face no audit, compliance, or customer requirement to prove what your agents did - and no internal need to gate or limit what they do.
- Don't run your own infrastructure and would rather not host another platform.
- Already get equivalent governance and audit controls from your existing toolchain - GitHub Enterprise, GitLab Ultimate (GitLab's own governed software factory governs inside GitLab), or an in-house setup - and are satisfied with them.
In that case, your git host's built-in protection rules are probably enough for now. Revisit when an audit, an incident, or a wider agent rollout changes what you need.
Before you start: Modulo is source-available under the Business Source License (BUSL) - not OSI-approved open source. It is pre-release alpha software where breaking changes may occur. The Team tier (SSO, RBAC, audit exports, spend limits) is in development. Pre-GA founding price is $6,000/yr; list price from v1.0 is $12,000/yr.
Frequently Asked Questions
What is agent governance?
How does Modulo differ from CI/CD tools like GitHub Actions?
How does Modulo differ from general automation tools like n8n?
How does Modulo differ from LLM app builders like Dify?
Can I drive Modulo from an MCP client such as Claude Desktop or Cursor?
How do I control agent spend?
What happens when an agent fails or produces bad output?
Can I produce audit evidence for SOC 2, ISO 42001, or the EU AI Act?
Does Modulo support SSO, SCIM, and role-based access control?
For the full list, see /docs/faq and self-hosted agent governance.
Going deeper
Humans in the loop, where you put them
Risky steps pause for review. A reviewer claims a gate, inspects with full run context, and approves or rejects - and the decision is recorded.
Evidence on demand
A hash-chained, append-only audit trail with chain verification and one-click exports - audit prep for compliance frameworks becomes a single query.
Compose the pipeline visually
Agents, tools, gates, and humans as nodes in an explicit execution graph - typed seams between steps, every node auditable.
Build
Compose individual AI agents into governed delivery graphs using a drag-and-drop canvas. Each node is a separate, auditable, approval-gated step - the building block of your audit trail.
Every prompt and schema change creates a new version. Restore any previous version, and the audit log records which version produced each output.
GitHub, GitLab, Notion, filesystem, or custom HTTP connectors, each sandboxed and swappable without rewriting pipelines - plus pre-built pipeline blueprints, agents, and connectors from the community to copy, adapt, and combine.
Control
Define exactly where human review is required. Agents flag checkpoints, and reviewers claim, inspect, approve, or reject with full run context.
Team-scoped permissions with admin, operator, and runner roles. Isolate pipelines, agents, and connectors by team with full audit visibility.
Anthropic, OpenAI, or local models behind a common interface. Health checks, automatic rotation, per-node model selection.
Verify
Every governance event - run start, agent dispatch, human decision, gate outcome - is logged in a hash-chained, append-only audit trail, alongside the full captured output of every agent run. Prove who approved what for compliance frameworks, and replay any run for debugging.
Define Large Language Model (LLM)-judge, regex, and block evaluations as automated quality gates. Conditionally route to human review when evaluations flag concerns.
Native OpenTelemetry Protocol (OTLP) export for traces, metrics, and logs. Monitor pipeline execution, agent latency, and connector health in your existing observability stack.
Compared with Factory.ai, n8n, and Dify: Modulo is self-hosted in every tier, governance included in the one paid tier, flat annual with no per-seat. See the full platform comparison for the sourcing behind each claim.
Govern the agents you already run
Self-hosted, source-available, and running in an afternoon. Clone it, wire it around one pipeline, and add gates as you go.