AgenticContract
Every AI agent is ungoverned.
Claude can exceed your API budget. GPT can bypass approval gates. Your copilot can violate compliance rules without anyone noticing. Every action happens without oversight.
Potencialize seu agente
Instalação do publicador. Não é um endpoint do PlugMCP.
Host a copy with our keys and logs.
Ainda não há uma versão empacotada no registro. Siga o README do repositório.
URL remota ou um comando na sua máquina? Como as duas instalações diferem
Rodar no PlugMCP
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
AbrirDo publicador
Claude can exceed your API budget. GPT can bypass approval gates. Your copilot can violate compliance rules without anyone noticing. Every action happens without oversight.
Policy engine for AI agents — enforceable rules, risk limits, approval gates, obligation tracking, and violation detection. One .acon file. Rust core + MCP server.
The current fixes don't work. Manual policy checks are forgotten. Rate limits live in application code that agents can't inspect. Approval workflows require external services. Compliance obligations get tracked in spreadsheets. Violations go undetected until it's too late.
AgenticContract models policies, risk limits, approvals, conditions, obligations, and violations in a single binary .acon file. Not "add a config file." Your agent has a governance engine -- behavior constraints, budget enforcement, approval gates, and breach tracking -- all structured, all queryable in microseconds.
from agentic_contract import ContractEngine
engine = ContractEngine("agent.acon")
# Your agent is governed
engine.policy_add("No production deploys on Friday", scope="global", action="deny")
engine.risk_limit_set("API spend", max_value=100.0, limit_type="budget")
# Session 47 -- months later, same governance:
result = engine.policy_check("deploy") # Check before acting
status = engine.risk_limit_check("API spend", 5) # Check budget headroom
report = engine.stats() # Full governance overview
Operational reliability commands (CLI):
acon policy list # All active policies
acon limit list # Current limit usage
acon obligation check # Overdue obligations
acon violation list --severity critical # Critical breaches
acon stats # Full summary
Once connected, the LLM can enforce policies, track budgets, manage approvals, monitor obligations, and investigate violations -- all backed by the same .acon binary file.
All measurements on Apple M-series, single-threaded, cold cache. The .acon format uses fixed-size records and BLAKE3 checksums -- no JSON parsing, no query planning overhead.
Governance is a graph, not a checklist. When you trace why an action was denied, you follow a chain: violation ← policy breach ← risk limit exceeded ← approval never granted. That's graph navigation. Simple allow/deny rules can never reconstruct the reasoning.
One file. Truly portable. Your entire governance state is a single .acon file. Copy it. Back it up. Version control it. No cloud service, no API keys, no vendor lock-in.
Any LLM, any time. Start with Claude today. Switch to GPT tomorrow. Move to a local model next year. Same contract file. The governance rules travel with the agent, not with the provider.
Self-healing. When policies conflict or world conditions change, the self-healing contract system proposes amendments. The old policy, the new policy, and the amendment chain are all preserved for audit.
Six entity types. Not just policies. Policies, risk limits, approval workflows, conditions, obligations, and violations -- each with typed lifecycle management. Four policy actions (Allow/Deny/RequireApproval/AuditOnly), four risk limit types (Rate/Threshold/Budget/Count), four violation severities (Info/Warning/Critical/Fatal).
One-liner (desktop profile):
curl -fsSL https://agentralabs.tech/install/contract | bash
Install profiles:
# Desktop (configures Claude Desktop, Cursor, Windsurf)
curl -fsSL https://agentralabs.tech/install/contract/desktop | bash
# Terminal-only (no desktop config writes)
curl -fsSL https://agentralabs.tech/install/contract/terminal | bash
# Remote/server hosts
curl -fsSL https://agentralabs.tech/install/contract/server | bash
# npm
npm install @agenticamem/contract
# pip
pip install agentic-contract
# cargo
cargo install agentic-contract-cli agentic-contract-mcp
Standalone guarantee: AgenticContract works independently. No other Agentra component is required.
# Add a deny policy
acon policy add "No production deploys on Friday" --scope global --action deny
# Set a budget limit
acon limit set "API spend" --max 100.0 --type budget
# Add an obligation with a deadline
acon obligation add "Submit compliance report" \
--description "Weekly compliance summary" \
--deadline "2026-03-07T17:00:00Z"
# Check current governance state
acon stats
from agentic_contract import ContractEngine
engine = ContractEngine("agent.acon")
engine.policy_add("Rate limit API calls", scope="global", action="deny")
engine.risk_limit_set("API calls per minute", max_value=60, limit_type="rate")
print(engine.policy_check("call external API")) # Check before acting
User: "Deploy the staging build to production"
Claude: Let me check the governance policies first.
→ policy_check("deploy to production")
→ Result: RequireApproval
This action requires approval. Let me create an approval request.
→ approval_request(rule_id, "Deploy staging to production", "claude-agent")
→ Waiting for human approval...
Any MCP-compatible client gets instant access to runtime governance. The agentic-contract-mcp crate exposes the full ContractEngine over the Model Context Protocol (JSON-RPC 2.0 over stdio).
cargo install agentic-contract-mcp
Add to ~/Library/Application Support/Claude/claude_desktop_config.json:
{
"mcpServers": {
"agentic-contract": {
"command": "agentic-contract-mcp",
"args": ["serve"]
}
}
}
Zero-config: defaults to
~/.agentic/contract.acon. Override with"args": ["--path", "/path/to/contract.acon", "serve"].
Add to .vscode/settings.json:
{
"mcp.servers": {
"agentic-contract": {
"command": "agentic-contract-mcp",
"args": ["serve"]
}
}
}
For cloud/server deployments, set an authentication token:
export AGENTIC_TOKEN="$(openssl rand -hex 32)"
agentic-contract-mcp serve
1. policy_check("deploy to production")
2. If denied → stop, report violation
3. If require_approval → approval_request(...)
4. If allowed → proceed
1. risk_limit_set("API spend", max=100, type="budget")
2. Before each call: risk_limit_check("API spend", 0.05)
3. If exceeded → violation_report(...)
1. obligation_add("Submit weekly report", deadline="2026-03-07T17:00:00Z")
2. Periodically: obligation_check()
3. On overdue → violation_report(...)
AgenticContract stores all governance data as typed entities in a custom binary format. Entities represent governance primitives (policies, risk limits, approvals, conditions, obligations, violations). The engine evaluates policies, tracks limits, and records breaches at runtime.
The core runtime is written in Rust for performance and safety. All state lives in a portable .acon binary file -- no external databases, no managed services. The MCP server exposes the full engine over JSON-RPC stdio.
The governance model in detail:
Entities are governance primitives -- six types:
Policy actions -- four types: allow · deny · require_approval · audit_only
Risk limit types -- four types: rate · threshold · budget · count
Violation severities -- four levels: info · warning · critical · fatal
+-------------------------------------+
| HEADER 64 bytes | Magic(ACON) . version . flags . entity counts . timestamps
+-------------------------------------+
| POLICY TABLE fixed-size rows | id . label . scope . action . active . conditions . tags
+-------------------------------------+
| RISK LIMIT TABLE fixed-size rows | id . label . type . current . max . window
+-------------------------------------+
| APPROVAL TABLE fixed-size rows | rules . requests . decisions
+-------------------------------------+
| CONDITION TABLE fixed-size rows | id . label . type . expression
+-------------------------------------+
| OBLIGATION TABLE fixed-size rows | id . label . status . deadline . assignee
+-------------------------------------+
| VIOLATION TABLE fixed-size rows | id . description . severity . actor . timestamp
+-------------------------------------+
| CHECKSUM BLAKE3 | Integrity verification
+-------------------------------------+
The binary format uses b"ACON" magic bytes, fixed-size records for O(1) entity access, and BLAKE3 checksums for integrity. No JSON parsing overhead. No external services. Instant access.
.acon binary file on your filesystem.One research paper:
This is a Cargo workspace monorepo containing the core library, MCP server, CLI, and FFI bindings.
agentic-contract/
├── Cargo.toml # Workspace root
├── crates/
│ ├── agentic-contract/ # Core library (policy engine, file format, advanced capabilities)
│ ├── agentic-contract-mcp/ # MCP server (22 core + 16 advanced tools)
│ ├── agentic-contract-cli/ # CLI binary: acon (policy/limit/approval/obligation/violation)
│ └── agentic-contract-ffi/ # FFI bindings (C header + shared library)
├── python/ # Python SDK (PyPI: agentic-contract)
├── npm/wasm/ # WebAssembly bindings
├── paper/ # Research paper (Paper I: policy engine)
├── scripts/ # Install, CI, and guardrail scripts
├── docs/ # Documentation (public pages, ecosystem kit)
└── .github/workflows/ # CI/CD (build, test, release, guardrails)
# All workspace tests (unit + integration + stress)
cargo test --workspace
# Core engine tests only
cargo test -p agentic-contract
# MCP server stress tests
cargo test -p agentic-contract-mcp --test phase1_mcp_stress
# CLI integration tests
cargo test -p agentic-contract-cli --test cli_integration
# Guardrails
bash scripts/check-canonical-sister.sh
.acon file -- no cloud, no telemetry, no network callsAGENTIC_TOKEN environment variableSee CONTRIBUTING.md for development setup and guidelines. All contributions require:
cargo fmt --all -- --checkcargo clippy --workspace --all-targets -- -D warningscargo test --workspacebash scripts/check-canonical-sister.shMIT -- see LICENSE.
Policy engine for AI agents — enforceable rules, risk limits, approval gates, obligation tracking, and violation detection. One .acon file. Rust core + MCP server.
Ferramentas
Ainda não há lista de ferramentas. Servidores remotos recebem uma após a primeira verificação de saúde.
Perguntas frequentes
Copie nesta página a configuração stdio para Cursor, Claude Desktop, Claude Code ou VS Code. Ela usa a instalação do publicador, não um proxy do PlugMCP.
Este registro não lista nenhuma variável de ambiente obrigatória.
Agentic Contract roda localmente via stdio.
Última verificação: 2026-10-27. Policy engine for AI agents — enforceable rules, risk limits, approval gates, obligation tracking, and violation detection. One .acon file. Rust core + MCP server.