Examples

Three runnable programs in examples/ exercise the full protocol end to end — one traces the spec's own three-agent reference flow (§32), one shows the same authority chain enforced inside a LangChain tool-calling loop, and one governs a real deepagents agent graph.

Three-agent reference flow

examples/three_agent_demo.py runs Principal → Requester → Research Agent → Evaluator → Settlement Adapter, entirely with signed VACT-P objects — no network calls, no mocked cryptography.

make demo

Audit reconstruction

At the end, the Principal reconstructs the full chain without ever seeing the raw source documents or private model reasoning:

Mandate
  → Delegation
    → Offer and Quote
      → Task Contract
        → Policy Decision
          → Execution Receipt
            → Evaluation Receipt
              → Settlement Receipt

The demo then asserts the receipt hash-chain is intact — execution_receipt.prev_receipt_digest == digest(policy_receipt), and so on through settlement. Tamper with a single byte of any object and verification fails closed.

LangChain "Deep Agent" integration

examples/langchain_deep_agent.py wraps two LangChain tools — read_secure_vaultand publish_summary_report — with VACT-P authority checks. Each tool call carries the signed envelope and is validated before it runs:

@tool
def read_secure_vault(document_id: str, envelope_json: str) -> str:
    """Reads a document from the secure vault. Requires a valid VACT-P authority chain."""
    envelope = json.loads(envelope_json)
    chain = envelope.get("authority_chain", [])

    effective = verify_chain(chain, RESOLVER)
    decision = authorize(effective, action="document.read", resource=document_id)
    decision.enforce()  # raises + fails closed if not allowed

    return vault_data.get(document_id, "ERROR: Document not found.")

The demo then drives an agent through three calls:

• Reads urn:doc:financial-secrets — allowed, in scope of the Delegation.
• Publishes a summary report — allowed, in scope of the Delegation.
• Attempts to read urn:doc:hr-secrets — denied, outside the delegated resource set, fails closed with PERMISSION DENIED.

Run it (falls back to a self-contained simulation mode if langchain-core isn't installed):

make demo-langchain

Governing a real deepagents agent

examples/deepagents_governed_agent.py goes one step further: it builds an actualdeepagentscreate_deep_agent() graph — planning via a todo list, a mock filesystem, sub-agent spawning — the same LangGraph-based shape of agent that coding assistants are built on, and governs its tools with VACT-P instead of hand-rolling the tool-calling loop.

Effective authority is resolved once, out-of-band, from a signed Mandate → Delegation chain, then bound to the run through a contextvar. The model's tool schema only ever exposes ordinary arguments like document_id and report_id — it has no channel through which to see, present, or forge authority material:

def vact_governed(action: str, resource_param: str):
    """Enforce a VACT-P authorization decision before the tool body runs."""
    def decorator(func):
        @wraps(func)
        def guarded(**kwargs):
            authority = _authority.get()          # bound out-of-band, not by the model
            resource = kwargs.get(resource_param, "*")
            decision = authorize(authority, action=action, resource=resource)
            if not decision.allowed:
                return f"PERMISSION DENIED [{decision.reason_code}]: {decision.detail}"
            return func(**kwargs)
        return guarded
    return decorator

@vact_governed("document.read", resource_param="document_id")
def read_secure_vault(document_id: str) -> str:
    """Read a document from the secure vault by its resource identifier."""
    return VAULT.get(document_id, "ERROR: document not found.")

agent = create_deep_agent(tools=[read_secure_vault, publish_summary_report], ...)

Run it against a real model, or let it fall back to a self-contained governance simulation:

pip install deepagents langchain-anthropic
export ANTHROPIC_API_KEY=sk-...
make demo-deepagents