Governed AI agents for engineering organizations

Tribunus gives teams a local-first agent control plane with capability boundaries, approval gates, execution receipts, and auditable inference paths.

Request technical briefing Read the trust model

The enterprise problem

AI coding agents are being introduced into production environments before teams have a serious model for authority, auditability, data movement, plugin trust, or recovery. Most agent platforms optimize for speed. Tribunus optimizes for control.

Control plane, not chat wrapper

Tribunus is built around sessions, tools, approvals, state, receipts, and runtime boundaries.

Session state machine — typed transitions, recovery states, event-sourced history
Tool runtime — ~200 built-in tools with capability scoping and approval gates
Project awareness — agents understand workspace structure and dependencies
Execution receipts — every agent action produces a verifiable receipt
Multi-agent orchestration — ACP protocol with isolation boundaries

Security model

Five explicit boundaries govern every execution path:

Local execution boundary — agent runtime runs on developer hardware; no cloud dependency for core operations
Model/provider boundary — each provider connection configurable with explicit endpoint and capability scope
Plugin capability boundary — plugins declare required capabilities; runtime enforces the grant
Project workspace boundary — agents operate within scoped directories with configurable allow/deny lists
Approval levels — mutating operations require per-action or per-session approval

Status: local execution and workspace boundaries implemented. Plugin enforcement experimental. Provider enforcement in progress.

Deployment modes

Individual developer preview

Single-user local installation. Full control plane with local models or remote provider connections.

Team-managed local deployment

Centrally defined configuration, approved provider list, workspace templates.

Near-term roadmap

Private model gateway

Remote models routed through a company-controlled gateway with audit logging.

Design phase

Self-hosted / federated

Tribunus cells coordinating across machines with distributed state and federated inference.

Research phase

Data handling

Tribunus is designed so local workflows can keep project data local. Remote-provider usage depends on the configured boundary.

Project source code processed locally by default
Remote API calls go only to configured providers with user-controlled endpoints
Execution receipts contain operation metadata, not project content
Telemetry is opt-in, limited to aggregate usage statistics
Plugins run in-process with declared capability scopes

Audit and evidence

Every agent action, backend decision, and failure state produces a structured receipt.

Receipts capture tool calls, model responses, approval decisions, and error states
Session history is event-sourced and replayable
Evidence corpus on Hugging Face provides independent verifiability

Maturity and roadmap

Capability	Status
Desktop app (macOS, Linux)	Developer preview
Plugin SDK	Experimental
Compute Image pipeline	In CI
Apple Silicon backend	In progress
NVIDIA CUDA backend	In progress
AMD / Intel / Tenstorrent	Planned
Team-managed deployment	Designed
Federated inference	Research

Who this is for

Good fit

Engineering orgs evaluating AI coding agents
Platform teams building internal AI tools
Regulated software teams needing auditability
AI labs needing local reproducibility

Not ready for

Fully managed SaaS agent platform today
Polished enterprise procurement immediately
Expecting all backends production-ready

Request a technical briefing

Interested in deploying Tribunus in your organization? We offer briefings for engineering teams and security organizations.

Contact enterprise@tribunus.dev