Claude Integration

pip install "agentrust-py[claude]"

export AGENTRUST_GATEWAY_URL=https://console.agent-trust.tech
export AGENTRUST_KEY=at_live_...
export AGENTRUST_AGENT_ID=support-agent

+ import os
+ from agentrust_sdk.adapters.claude_agents import governed_tools

- tools = [beta_tool(add), beta_tool(multiply)]
+ tools = [beta_tool(fn) for fn in governed_tools(
+     [add, multiply], agent_id=os.environ["AGENTRUST_AGENT_ID"]
+ )]

Blocked by AgentTrust: Tool-trust hard gate: tool_trust: 'issue_refund' amount 5000.0 exceeds declared max_amount 100 (envelope …)

from anthropic import Anthropic
from agentrust_sdk.adapters.claude_agents import ClaudeAgentGuard

guard = ClaudeAgentGuard(agent_id="support-agent")
client = guard.wrap_client(Anthropic())      # AsyncAnthropic: guard.wrap_async_client(...)

pip install "agentrust-py[claude,embedded]"

from agentrust_sdk.embedded import embed_gateway

gateway = embed_gateway()
gateway.register_manifest("support-agent", {
    "declared_tools": [
        {"name": "lookup_order"},
        {"name": "issue_refund", "max_amount": 100},
    ],
})

mkdir agentrust-quickstart && cd agentrust-quickstart
python -m venv .venv && source .venv/bin/activate     # on Windows: .venv\Scripts\activate
pip install "agentrust-py[claude,embedded]"

"""
claude_quickstart.py — a Claude agent whose tool calls AgentTrust checks.

The agent is a calculator: Claude (Anthropic Messages API) with add, multiply
and divide tools, asked to do two sums. The loop is the usual one: send the
messages, run each tool Claude asks for, send the results back.

AgentTrust is one line (marked "AgentTrust" below): the tools are wrapped with
governed_tools before they are turned into Claude tools. Every call is checked
before it runs, and its result after. A tool the agent may not use is refused
before its code runs; Claude is told why as the tool result and the run still
finishes. The agent may use add and multiply, not divide.

RUN IT (in the folder that holds this file)
    pip install "agentrust-py[claude,embedded]"
    export ANTHROPIC_API_KEY=...                          # or use --scripted, which needs no key

    python claude_quickstart.py --without-agentrust       # AgentTrust off: every tool runs
    python claude_quickstart.py --local                   # a gateway starts inside this program; no account
    python claude_quickstart.py --console                 # your AgentTrust console keeps every decision
    python claude_quickstart.py --scripted                # replay a fixed conversation instead of calling a model

  --console needs three settings, from the agent you create in the console:
      export AGENTRUST_GATEWAY_URL=https://console.agent-trust.tech
      export AGENTRUST_KEY=at_live_...
      export AGENTRUST_AGENT_ID=...

ANOTHER MODEL
    CLAUDE_QUICKSTART_MODEL=claude-opus-5-5 (export ANTHROPIC_API_KEY).
    Any Claude model that supports tool use works.
"""
from __future__ import annotations

import argparse
import os
import sys
import tempfile
from types import SimpleNamespace

from anthropic import Anthropic, beta_tool

from agentrust_sdk.adapters.claude_agents import governed_tools

AGENT_ID = os.environ.get("AGENTRUST_AGENT_ID", "calculator-agent")
MODEL = os.environ.get("CLAUDE_QUICKSTART_MODEL", "claude-sonnet-5-5")

# The tools this agent may call. With --local they are set here; with --console
# you declare the same list on the agent in the console. divide is left out on purpose.
MANIFEST = {"declared_tools": [{"name": "add"}, {"name": "multiply"}]}

SYSTEM = (
    "You do the arithmetic you are asked for, using your tools, one tool call at a time. "
    "If a tool is refused, say the operation could not be done."
)

def multiply(a: int, b: int) -> int:
    """Multiply `a` and `b`."""
    return a * b

def add(a: int, b: int) -> int:
    """Add `a` and `b`."""
    return a + b

def divide(a: int, b: int) -> float:
    """Divide `a` by `b`."""
    return a / b

# AgentTrust: every call to these tools is checked before it runs and after it
# returns. Turn the wrapped functions into Claude tools, not the plain ones.
tools = [beta_tool(fn) for fn in governed_tools([add, multiply, divide], agent_id=AGENT_ID)]

REQUESTS = ["Add 3 and 4.", "Divide 10 by 2."]

def ask(request: str, client, max_turns: int = 6) -> str:
    """The agent loop: run the tools Claude asks for until it answers in text."""
    by_name = {tool.name: tool for tool in tools}
    messages = [{"role": "user", "content": request}]
    for _ in range(max_turns):
        reply = client.messages.create(
            model=MODEL, max_tokens=1024, system=SYSTEM, messages=messages,
            tools=[tool.to_dict() for tool in tools],
        )
        messages.append({"role": "assistant", "content": reply.content})
        calls = [block for block in reply.content if block.type == "tool_use"]
        if not calls:
            return "".join(block.text for block in reply.content if block.type == "text")
        results = []
        for call in calls:
            # A refused call returns the refusal text here, and Claude reads it next turn.
            output = by_name[call.name].call(call.input)
            print(f"  tool {call.name}({', '.join(f'{k}={v}' for k, v in call.input.items())}) -> {output}")
            results.append({"type": "tool_result", "tool_use_id": call.id, "content": str(output)})
        messages.append({"role": "user", "content": results})
    return "(stopped: too many turns)"

# --scripted: replay a fixed conversation, so the quickstart runs with no model and no key.
# A replay does not read tool results, so its last line is the same with AgentTrust on or off;
# what differs is what each tool returned.
# Each reply is either a tool call (name, arguments) or the final text.
SCRIPT = [
    ("add", {"a": 3, "b": 4}), "3 + 4 = 7.",
    ("divide", {"a": 10, "b": 2}), "That is everything you asked for.",
]

class ScriptedClient:
    """Stands in for Anthropic(): messages.create returns the next scripted reply."""

    def __init__(self, replies=SCRIPT) -> None:
        self._replies = list(replies)
        self.messages = SimpleNamespace(create=self._create)

    def _create(self, **kwargs):
        reply = self._replies.pop(0)
        if isinstance(reply, str):
            block = SimpleNamespace(type="text", text=reply)
        else:
            name, args = reply
            block = SimpleNamespace(type="tool_use", id=f"toolu_{len(self._replies)}", name=name, input=args)
        return SimpleNamespace(content=[block], stop_reason="end_turn")

def ask_agent(where: str, scripted: bool) -> bool:
    """Ask the agent to add, then to divide. False if the model can't be reached."""
    print(f"AgentTrust: {where} · agent {AGENT_ID} · model {'scripted' if scripted else MODEL}")
    client = ScriptedClient() if scripted else Anthropic()
    try:
        for request in REQUESTS:
            print(f"\n=== {request} ===")
            print(f"\nResult: {ask(request, client)}")
    except Exception as exc:  # noqa: BLE001 - any provider error ends the run
        print(f"\nThe model call failed ({MODEL}): {exc}\n"
              "Check ANTHROPIC_API_KEY is set, or run with --scripted.", file=sys.stderr)
        return False
    return True

# --without-agentrust: every tool runs. For comparison.
def run_without_agentrust(scripted: bool) -> int:
    os.environ["AGENTRUST_ENABLED"] = "false"   # the SDK's off switch: wrapped tools pass every call through
    return 0 if ask_agent("off (every tool runs)", scripted) else 1

# --local: a gateway runs inside this program; no account needed.
def run_local(scripted: bool) -> int:
    from agentrust_sdk.embedded import embed_gateway

    # SQLite in a temp dir, gone after the run. embed_gateway sets
    # AGENTRUST_GATEWAY_URL and AGENTRUST_KEY, which governed_tools reads.
    gateway = embed_gateway(db_path=os.path.join(tempfile.mkdtemp(), "gateway.db"))
    gateway.register_manifest(AGENT_ID, MANIFEST)
    try:
        ok = ask_agent(f"local gateway {gateway.url} (no account, nothing kept)", scripted)
    finally:
        gateway.stop()
    return 0 if ok else 1

# --console: the SDK sends every check to your console, which keeps the decisions.
def run_with_console(scripted: bool) -> int:
    missing = [v for v in ("AGENTRUST_GATEWAY_URL", "AGENTRUST_KEY", "AGENTRUST_AGENT_ID") if not os.environ.get(v)]
    if missing:
        print(f"Set {', '.join(missing)} (from the agent you created in the console), or use --local.",
              file=sys.stderr)
        return 2
    console = os.environ["AGENTRUST_GATEWAY_URL"]
    ok = ask_agent(f"console {console}", scripted)
    print(f"\nOpen Events in the console ({console}) and filter by agent ID {AGENT_ID}.")
    return 0 if ok else 1

def main(argv: list[str] | None = None) -> int:
    parser = argparse.ArgumentParser(description="The Claude calculator agent, governed by AgentTrust.")
    where = parser.add_mutually_exclusive_group()
    where.add_argument("--local", action="store_true", help="run a gateway inside this program, no account (the default)")
    where.add_argument("--console", action="store_true", help="send every check to your AgentTrust console")
    where.add_argument("--without-agentrust", action="store_true", help="for comparison: AgentTrust off, every tool runs")
    parser.add_argument("--scripted", action="store_true", help="replay a fixed conversation: no model, no API key")
    args = parser.parse_args(argv)
    if args.without_agentrust:
        return run_without_agentrust(args.scripted)
    return run_with_console(args.scripted) if args.console else run_local(args.scripted)

if __name__ == "__main__":
    sys.exit(main())

python claude_quickstart.py --help

python claude_quickstart.py --without-agentrust --scripted

AgentTrust: off (every tool runs) · agent calculator-agent · model scripted

=== Add 3 and 4. ===
  tool add(a=3, b=4) -> 7

Result: 3 + 4 = 7.

=== Divide 10 by 2. ===
  tool divide(a=10, b=2) -> 5.0

Result: That is everything you asked for.

+ from agentrust_sdk.adapters.claude_agents import governed_tools

- tools = [beta_tool(fn) for fn in [add, multiply, divide]]
+ tools = [beta_tool(fn) for fn in governed_tools([add, multiply, divide], agent_id=AGENT_ID)]

python claude_quickstart.py --local --scripted

AgentTrust: local gateway http://127.0.0.1:8765 (no account, nothing kept) · agent calculator-agent · model scripted

=== Add 3 and 4. ===
  tool add(a=3, b=4) -> 7

Result: 3 + 4 = 7.

=== Divide 10 by 2. ===
  tool divide(a=10, b=2) -> Blocked by AgentTrust: Tool-trust hard gate: action 'divide' is not in this agent's declared_tools (envelope dec75b50-beb1-4603-a8e7-cd8bdad96951)

Result: That is everything you asked for.

export AGENTRUST_GATEWAY_URL=https://console.agent-trust.tech   # your console's address
export AGENTRUST_KEY=at_live_...                                # the API key
export AGENTRUST_AGENT_ID=claude-quickstart                     # the Agent ID

python claude_quickstart.py --console --scripted