Agent 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.
Self-hosted, running in minutes: docker compose up - bundles Postgres 16 and Redis 7. Full setup guide →
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 isn't what they can do - it's what 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: every step is typed, gated where you decide, and recorded.
Control
Decide what agents can access and where humans approve. Typed schema seams validate the shape of every handoff, and per-node capability scopes limit which connectors, tools, and context each agent can reach - so a scoped agent can't pass unchecked output downstream or pull credentials it wasn't granted. Approval gates sit in the merge path, not after it.
Prove
Know what ran, what it did, what produced each output, and who approved it. Every governance event lands in a hash-chained, append-only audit log in your own Modulo instance, alongside the full captured output of every agent run. Audit prep for SOC 2, ISO 42001, and the EU AI Act becomes a query, not a project.
Own
Run the whole system on your infrastructure, with your agents, your models, and your data. No telemetry, air-gap capable, prompts never leave your network. Bring your own agents - Modulo governs them, it doesn't supply or replace them.
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 each seam so every 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. Autonomy rises for change classes that earn it with evidence, and rolls back safely when they don't.
Self-hosted with Docker Compose - clone, docker compose up, and stand up your first governed pipeline in an afternoon. Read the getting-started guide →
Scale your SDLC by compute time, not engineer time
Engineers define processes, logic, and governance at the organization level, rather than on a workstation or on one 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, not separately inside every developer's setup and every repo.
Built for the workflows your team already runs
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 underneath 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.
What governed agent delivery looks like
Screenshots from a live instance - the same product you self-host. Every run, gate, and decision recorded as work happens.
One governed view
Pipelines, runs, eval pass rates, and spend across your organization - live in one place, not reconstructed from five tools.
Compose the pipeline visually
Agents, tools, gates, and humans as nodes in an explicit execution graph - typed seams between steps, every node auditable.
Every run, fully recorded
Typed inputs and outputs, per-node checks, an OpenTelemetry trace ID, and the full captured output of every agent run.
Evidence on demand
A hash-chained, append-only audit trail with chain verification and one-click exports - audit prep for SOC 2, ISO 42001, and the EU AI Act becomes a query, not a project.
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.
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, 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.
How Modulo compares
Factory.ai, Tembo, and Dify each overlap with part of what Modulo does. Here is how the four compare on self-hosting, governance, and pricing shape - see the Modulo vs Factory.ai and full platform comparison for the sourcing behind each row.
| Dimension | Modulo | Factory.ai | Tembo | Dify |
|---|---|---|---|---|
| Self-hosted | Only mode, every tier | Enterprise-only, custom sales | Yes - MIT, self-hosted control plane | Community edition self-hosted |
| Governance (SSO, RBAC, audit) | Included in the one paid tier | Business/Enterprise only, custom price | Audit and identity stay local; SSO/RBAC not publicly detailed | Enterprise tier only |
| Pricing model | Flat annual, no per-seat | Per-seat, usage-metered | Not publicly priced beyond the Pro/Max tiers | Cloud per-workspace; Enterprise custom-priced |
| Source availability | Source-available (BUSL) | Closed-source | Open-source (MIT) | Open-source core |
| SDLC-specific evidence/eval library | Yes - evidence-based, progressive autonomy | Not documented | Not documented | Not documented |
GitHub is not in this table because it is a platform Modulo integrates with, not a direct competitor on agent governance.
Everything you need to govern agentic delivery
One governed layer for the agents, tools, and human gates already in your SDLC - typed, approval-gated, and self-hosted.
Build
Visual graph builder
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.
Prompt and schema versioning
Every prompt and schema change creates a new version. Restore any previous version, and the audit log records which version produced each output.
Connector & community library
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
Human-in-the-loop governance
Define exactly where human review is required. Agents flag checkpoints, and reviewers claim, inspect, approve, or reject with full run context.
Role-based access control
Team-scoped permissions with admin, operator, and runner roles. Isolate pipelines, agents, and connectors by team with full audit visibility.
Model backend abstraction
Anthropic, OpenAI, or local models behind a common interface. Health checks, automatic rotation, per-node model selection.
Verify
Immutable audit trail
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 SOC 2, ISO 42001, and the EU AI Act, and replay any run for debugging.
Evaluation system
Define Large Language Model (LLM)-judge, regex, and block evaluations as automated quality gates. Conditionally route to human review when evaluations flag concerns.
OpenTelemetry observability
Native OpenTelemetry Protocol (OTLP) export for traces, metrics, and logs. Monitor pipeline execution, agent latency, and connector health in your existing observability stack.
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.