Integration Guide

{
  "mcpServers": {
    "agentic-contract": {
      "command": "agentic-contract-mcp",
      "args": ["serve"]
    }
  }
}

1. Agent wants to perform an action (e.g., "deploy to production")
2. Call policy_check with the action description
3. Response:
   - "allow"    -> proceed with the action
   - "deny"     -> stop, optionally call violation_report
   - "require_approval" -> call approval_request, wait for approval_decide
   - "audit_only" -> proceed, the action is logged

1. Call risk_limit_check with the label and proposed amount
2. If within limits: proceed, then call risk_limit_set to update usage
3. If would exceed: call violation_report with severity "critical"

1. At setup: call obligation_add with deadline and assignee
2. Periodically: call obligation_check to detect overdue items
3. On completion: call obligation_add to mark fulfilled
4. On overdue: call violation_report

AGENTIC_TOKEN="your-secret-token" agentic-contract-mcp serve

{
  "content": [
    {
      "type": "text",
      "text": "Error: Policy not found: invalid-id"
    }
  ],
  "isError": true
}

[dependencies]
agentic-contract = "0.1"

use agentic_contract::{
    ContractEngine, Policy, PolicyScope, PolicyAction,
    RiskLimit, LimitType, ViolationSeverity,
};

// Create or open engine
let mut engine = ContractEngine::new();

// Add a policy
let policy = Policy::new(
    "No production deploys without approval",
    PolicyScope::Global,
    PolicyAction::RequireApproval
);
engine.add_policy(policy);

// Check before acting
let result = engine.check_policy("deploy to production", None);
match result {
    PolicyAction::Deny => {
        engine.report_violation(
            "Attempted denied action",
            ViolationSeverity::Warning,
            "my-agent"
        );
    }
    PolicyAction::RequireApproval => {
        // Enter approval workflow
    }
    _ => {
        // Proceed with action
    }
}

// Save to disk
engine.save()?;

let limit = RiskLimit::new("API budget", LimitType::Budget, 100.0);
let limit_id = engine.add_risk_limit(limit);

// Before each API call
if engine.check_risk_limit("API budget", 0.05).is_some() {
    engine.report_violation(
        "API budget would be exceeded",
        ViolationSeverity::Critical,
        "my-agent"
    );
} else {
    engine.increment_risk_limit(limit_id, 0.05)?;
    // Make the API call
}

// Open existing or create new
let mut engine = ContractEngine::open("~/.agentic/contract.acon")
    .unwrap_or_else(|_| ContractEngine::new());

// ... modify engine ...

engine.save()?;

pip install agentic-contract

from agentic_contract import ContractEngine

engine = ContractEngine()

# Policy enforcement
engine.add_policy("No deploys on Friday", scope="global", action="deny")
result = engine.check_policy("deploy to production")
if result == "deny":
    print("Action blocked by policy")

# Risk limits
engine.set_risk_limit("API calls", max=1000, type="rate")
limit = engine.check_risk_limit("API calls", amount=1)
print(f"Remaining: {limit['remaining']}")

# Obligations
engine.add_obligation(
    "Weekly report",
    description="Submit compliance summary",
    assignee="my-agent",
    deadline="2026-03-07T17:00:00Z"
)

# Statistics
stats = engine.stats()
print(f"Policies: {stats['policies']}, Violations: {stats['violations']}")

import anthropic
from agentic_contract import ContractEngine

client = anthropic.Anthropic()
engine = ContractEngine()

# Add governance constraints
engine.add_policy("No data deletion", scope="global", action="deny")
engine.set_risk_limit("API spend", max=50.0, type="budget")

# Before each tool use, check policy
def guarded_tool_call(tool_name, args):
    result = engine.check_policy(f"{tool_name}: {args}")
    if result == "deny":
        return {"error": "Action denied by policy"}
    return execute_tool(tool_name, args)

import openai
from agentic_contract import ContractEngine

client = openai.OpenAI()
engine = ContractEngine()

engine.add_policy("Read-only mode", scope="session", action="deny")
engine.set_risk_limit("Token usage", max=100000, type="count")

from agentic_contract import ContractEngine

engine = ContractEngine()

class ContractGuard:
    """LangChain callback that checks policies before tool execution."""

    def __init__(self, engine):
        self.engine = engine

    def on_tool_start(self, tool_name, tool_input):
        result = self.engine.check_policy(f"{tool_name}: {tool_input}")
        if result == "deny":
            raise ValueError(f"Blocked by policy: {tool_name}")

#include "agentic_contract.h"

AconHandle* handle = acon_open("/path/to/contract.acon");
if (!handle) {
    int err = acon_last_error();
    // Handle error
}

int result = acon_policy_add(handle, "No deploys", "global", "deny");
acon_save(handle);
acon_close(handle);

approval_decide -> receipt signed by identity -> trust grant verification

violation_report -> memory_add(type="decision", content="Budget exceeded")

# CLI
acon --path /custom/path.acon stats

# Environment variable
ACON_PATH=/custom/path.acon agentic-contract-mcp serve

# Python
engine = ContractEngine(path="/custom/path.acon")