Govern what your agents can do.

from tenuo import (configure, guard, mint_sync,
                   Capability, Subpath, SigningKey)

configure(issuer_key=SigningKey.generate(), dev_mode=True)

@guard(tool="read_file")
def read_file(path: str) -> str:
    return open(path).read()

with mint_sync(Capability("read_file", path=Subpath("/data"))):
    read_file("/data/q3.pdf")   # allowed
    read_file("/etc/passwd")   # AuthorizationDenied

import { createTenuo, under } from "@tenuo/core";

const tenuo = createTenuo({ root: createTenuo.devRoot() });

const readFile = tenuo.tool(fileTool, {
  capability: "read_file",
  allow: { path: under("/data") },
});

const session = tenuo.session({ tools: [readFile] });

await readFile.execute(
  { path: "/data/q3.pdf" },
  { session },
);

from tenuo import guard

@guard(tool="read_file")
def read_file(file_path: str) -> str:
    with open(file_path) as f:
        return f.read()

with warrant.bind(key):
    read_file("/tmp/test.txt")   # authorized
    read_file("/etc/passwd")     # blocked

# the warrant travels in state, the key never does
state  = {"warrant": str(warrant), "messages": [...]}
config = {"configurable": {"tenuo_key_id": "worker"}}

graph.invoke(state, config=config)

# TenuoToolNode resolves the key at execution time.
# It never reaches the checkpoint database.

import openai
from tenuo.openai import GuardBuilder, Pattern, Subpath

client = (GuardBuilder(openai.OpenAI())
    .allow("search_web")
    .allow("read_file", path=Subpath("/data"))
    .allow("send_email", to=Pattern("*@company.com"))
    .deny("delete_file")
    .build())

# use the client normally; out-of-scope calls are blocked

from tenuo.crewai import GuardBuilder, Subpath

guard = (GuardBuilder()
    .allow("read_file", path=Subpath("/data"))
    .build())

guard.register()  # every CrewAI tool call now passes through the guard

from google.adk.agents import Agent
from tenuo.google_adk import GuardBuilder
from tenuo.constraints import Subpath, UrlSafe

guard = (GuardBuilder()
    .allow("read_file", path=Subpath("/data"))
    .allow("web_search", url=UrlSafe(allow_domains=["*.google.com"]))
    .build())

agent = Agent(name="assistant",
              tools=guard.filter_tools([read_file, web_search]),
              before_tool_callback=guard.before_tool)

hermes plugins enable hermes-tenuo

uvx hermes-tenuo mint --ttl 1h \
  --allow read_file:path=/data \
  --allow web_search

# Hermes checks agent-loop tool calls before their handlers run.
hermes

from fastmcp import FastMCP
from tenuo.mcp import MCPVerifier, TenuoMiddleware

verifier = MCPVerifier(authorizer=authorizer,
                       require_warrant=True)
mcp = FastMCP("demo", middleware=[TenuoMiddleware(verifier)])

@mcp.tool()
async def read_file(path: str) -> str:
    return open(path).read()

from tenuo.a2a import A2AServerBuilder

server = (A2AServerBuilder()
    .name("Worker")
    .url("https://worker.example.com")
    .key(my_signing_key)
    .accept_warrants_from(orchestrator_key)
    .build())

@server.skill("echo")
async def echo(msg: str) -> str:
    return f"Echo: {msg}"

from fastapi import Depends, FastAPI
from tenuo.fastapi import TenuoGuard, configure_tenuo

app = FastAPI()
configure_tenuo(app, trusted_issuers=[issuer_pubkey])

@app.get("/users/{user_id}")
async def get_user(user_id: str, ctx=Depends(TenuoGuard("get_user"))):
    return {"user_id": user_id}  # runs only with a valid warrant

# pod spec: the authorizer runs next to your agent
# and verifies warrants offline, with no network call
containers:
- name: agent
  image: your-agent:latest
- name: tenuo-authorizer
  image: tenuo/authorizer:0.3.1
  args: ["serve", "--config", "/etc/tenuo/gateway.yaml"]
  ports: [{ containerPort: 9090 }]
  env:
  - name: TENUO_TRUSTED_KEYS
    value: "<control-plane-public-key-hex>"