Skip to content
Back to search

tenuo

Task-scoped authorization for AI agents. Cryptographic warrants constrain tools and arguments, prevent privilege escalation at every delegation hop, and produce signed evidence of what was allowed or denied.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/tenuo-ai/tenuo with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/tenuo-ai/tenuo'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/tenuo-ai--tenuo/badge.svg)](/listings/tenuo-ai--tenuo)

HTML

<a href="/listings/tenuo-ai--tenuo"><img src="/api/listings/tenuo-ai--tenuo/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

# Using uv (recommended)
uv pip install tenuo

# Or standard pip
pip install tenuo

# TypeScript SDK (beta, Node 20+)
npm i @tenuo/core@beta

# Rust SDK
cargo add tenuo --features sdk

See [`tenuo-ts/README.md`](tenuo-ts/README.md) for TypeScript. Rust is [below](#rust).

AI coding agents

Install Tenuo's implementation skill so a supported coding agent can place authorization at the effect boundary, use the SDK version in your project, and generate both allow and deny-before-effect tests:

npx skills add tenuo-ai/tenuo --skill tenuo-agent-authorization

The skill distinguishes an in-process guardrail from an independently enforced boundary and reports the guarantee and remaining bypasses explicitly. It does not ask the agent to reimplement Tenuo's cryptography or protocol.

To try Tenuo without installing an SDK:

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 485 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. <p align="center">
  2. <img src="docs/images/tenuo-logo.svg" alt="tenuo" width="200">
  3. </p>
  4. <p align="center">
  5. <strong>Task-scoped authorization for AI agents.</strong>
  6. </p>
  7. <p align="center">
  8. <a href="https://github.com/tenuo-ai/tenuo/actions/workflows/ci.yml"><img src="https://github.com/tenuo-ai/tenuo/actions/workflows/ci.yml/badge.svg" alt="CI"></a>
  9. <a href="https://crates.io/crates/tenuo"><img src="https://img.shields.io/crates/v/tenuo.svg" alt="Crates.io"></a>
  10. <a href="https://pypi.org/project/tenuo/"><img src="https://img.shields.io/pypi/v/tenuo.svg" alt="PyPI"></a>
  11. <a href="https://hub.docker.com/r/tenuo/authorizer"><img src="https://img.shields.io/docker/v/tenuo/authorizer?label=docker&sort=semver" alt="Docker"></a>
  12. <a href="https://tenuo.ai"><img src="https://img.shields.io/badge/docs-tenuo.ai-blue" alt="Docs"></a>
  13. <a href="LICENSE"><img src="https://img.shields.io/badge/license-Apache--2.0-blue.svg" alt="License"></a>
  14. <a href="https://deepwiki.com/tenuo-ai/tenuo"><img src="https://img.shields.io/badge/Ask-DeepWiki-blue.svg" alt="Ask DeepWiki"></a>
  15. </p>
  16. Tenuo lets you define what an agent may do for a task, carry that authority across services and agent handoffs, and enforce it where actions execute. Each handoff can only narrow the authority granted.
  17. That authority travels as a **warrant**: a signed grant specifying allowed tools, argument constraints, and an expiry.
  18. - **Across frameworks and runtimes.** Delegate between agents and services using different languages and frameworks.
  19. - **Across organizations and trust domains.** Grant limited authority to others and independently verify the authority you receive.
  20. - **Online or air-gapped.** Verify locally without contacting a central authorization service, using provisioned trust keys and local revocation state.
  21. Open source. Works alongside your existing identity and policy systems.
  22. ## Install
  23. ```bash
  24. # Python
  25. pip install tenuo
  26. # TypeScript (beta, Node 20+)
  27. npm install @tenuo/core@beta
  28. # Rust
  29. cargo add tenuo --features sdk
  30. ```
  31. To try Tenuo without installing an SDK:
  32. <a href="https://colab.research.google.com/github/tenuo-ai/tenuo/blob/main/notebooks/tenuo_demo.ipynb"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"></a>
  33. <a href="https://tenuo.ai/explorer/"><img src="https://img.shields.io/badge/Explorer-decode_warrants-1a1a1a" alt="Explorer"></a>
  34. <a href="https://tenuo.ai/demo.html"><img src="https://img.shields.io/badge/Docker_Demo-delegation_chain-333333" alt="Docker Demo"></a>
  35. <a href="https://niyikiza.com/posts/tenuo-launch/"><img src="https://img.shields.io/badge/Blog-Why_Tenuo%3F-ff6b6b" alt="Blog"></a>
  36. <a id="quick-start-from-one-tool-to-delegated-work"></a>
  37. ## Quick Start
  38. Give an agent permission to request up to ten replicas. Calls outside that limit are blocked before the function executes. These examples simulate the action by returning a message.
  39. ### Python
  40. Save as `quickstart.py` and run `python quickstart.py`.
  41. ```python
  42. from tenuo import Capability, Range, SigningKey, configure, guard, mint_sync
  43. from tenuo.exceptions import AuthorizationDenied
  44. # Local development setup.
  45. configure(issuer_key=SigningKey.generate(), dev_mode=True, audit_log=False)
  46. @guard(tool="scale")
  47. def scale(replicas: int) -> str:
  48. return f"Requested {replicas} replicas"
  49. with mint_sync(Capability("scale", replicas=Range.max_value(10)), ttl=60):
  50. print(scale(3))
  51. try:
  52. scale(20)
  53. except AuthorizationDenied:
  54. print("Blocked before the function ran")
  55. ```
  56. ### TypeScript · Beta
  57. Save as `quickstart.mts` and run `npx tsx quickstart.mts`.
  58. ```typescript
  59. import { AuthorizationDeniedError, createTenuo, range } from "@tenuo/core";
  60. // Local development setup: this process holds the issuance key.
  61. const tenuo = createTenuo({
  62. root: createTenuo.issuerKeyFromBytes(createTenuo.generateIssuerKey()),
  63. });
  64. const scale = tenuo.tool(
  65. {
  66. execute: async ({ replicas }: { replicas: number }) =>
  67. `Requested ${replicas} replicas`,
  68. },
  69. { capability: "scale", allow: { replicas: range({ max: 10 }) } },
  70. );
  71. const session = tenuo.session({ tools: [scale], ttlSeconds: 60 });
  72. await tenuo.withSession(session, async () => {
  73. console.log(await scale.execute({ replicas: 3 }));
  74. try {
  75. await scale.execute({ replicas: 20 });
  76. } catch (error) {
  77. if (!(error instanceof AuthorizationDeniedError) ||
  78. error.code !== "TENUO_CONSTRAINT_VIOLATION") throw error;
  79. console.log("Blocked before the function ran");
  80. }
  81. });
  82. ```
  83. Both examples produce:
  84. ```text
  85. Requested 3 replicas
  86. Blocked before the function ran
  87. ```
  88. These examples keep issuance and enforcement in one process for development. Python's `dev_mode=True` also relaxes trust-root and audit-log checks. To enforce limits against an untrusted agent, keep issuance keys outside its reach and verify at a tool service or gateway it cannot bypass. The [MCP walkthrough](./docs/mcp.md) shows that setup with a server that holds only the issuer's public key. The [Production Guide](./docs/production-guide.md) covers enforcement modes, rollout, and key management.
  89. Leaving the scoped block ends its local authorization context; it does not revoke a signed warrant. Keep warrant lifetimes short.
  90. **Continue with:** [Python guide](./docs/quickstart.md) · [TypeScript guide](./tenuo-ts/README.md) · [Rust guide](#rust) · [MCP walkthrough](./docs/mcp.md)
  91. For the TypeScript guide's development examples, set `NODE_ENV=development`.
  92. ## Delegate Across Boundaries
  93. A task can move between agents, frameworks, and services while retaining its authorization limits.
  94. ```text
  95. Issuer Orchestrator Worker
  96. Grants authority → Narrows for a subtask → Presents warrant
  97. ↓
  98. Receiving service
  99. Verifies before acting
  100. ```
  101. For example, a Python orchestrator can delegate a narrower warrant to a TypeScript worker calling a Rust service. The receiving service verifies the chain against its configured trusted roots, then checks the caller's proof of possession and the requested action against the warrant.
  102. A delegated warrant can only narrow its parent.
  103. **Examples:** [Python delegation example](#python-delegation-example) · [TypeScript delegation guide](./tenuo-ts/README.md#delegate-to-another-agent)
  104. <a id="python-delegation-example"></a>
  105. <details>
  106. <summary>Python delegation example</summary>
  107. ```python
  108. from tenuo import Range, SigningKey, Warrant
  109. from tenuo.exceptions import MonotonicityError
  110. issuer = SigningKey.generate()
  111. orchestrator = SigningKey.generate()
  112. worker = SigningKey.generate()
  113. root = (Warrant.mint_builder()
  114. .capability("scale", replicas=Range.max_value(10))
  115. .holder(orchestrator.public_key)
  116. .ttl(300)
  117. .mint(issuer))
  118. # The orchestrator hands the worker a lower limit and a shorter lifetime.
  119. worker_warrant = (root.grant_builder()
  120. .capability("scale", replicas=Range.max_value(5))
  121. .holder(worker.public_key)
  122. .ttl(60)
  123. .grant(orchestrator))
  124. try:
  125. (root.grant_builder()
  126. .capability("scale", replicas=Range.max_value(50))
  127. .holder(worker.public_key)
  128. .ttl(60)
  129. .grant(orchestrator))
  130. except MonotonicityError:
  131. print("Rejected: a child cannot raise the limit")
  132. ```
  133. </details>
  134. Sensitive actions can also require a [signed human approval](./docs/approvals.md).
  135. **Explore:** [Python MCP delegation demo](./tenuo-python/examples/mcp/mcp_delegation_demo.py) · [Security model](./docs/security.md) · [Supported integrations](#integrate-at-the-boundary-you-control)
  136. ## Integrate at the Boundary You Control
  137. Tenuo uses the same warrant format and attenuation rules everywhere. Pick the enforcement point that fits. Authority crosses these boundaries without translation.
  138. | Enforcement point | Use it when | Integrations | Start here |
  139. |-------------------|-------------|--------------|------------|
  140. | **Inside the agent runtime** | You own the application and want the shortest path to enforcement | Python functions, OpenAI, LangChain, LangGraph, Google ADK, CrewAI, AutoGen, Hermes Agent, Rust `Guard` | [`@guard`](./docs/quickstart.md), [OpenAI](./docs/openai.md), [Hermes](./docs/hermes.md), [Rust](#rust), [framework guides](#documentation) |
  141. | **At the MCP tool server** | Agents call tools across a process or vendor boundary | FastMCP, official MCP SDK, custom MCP servers | [MCP guide](./docs/mcp.md) |
  142. | **At an API or service edge** | Multiple agent runtimes share the same downstream services | FastAPI, authorizer sidecar, gateway, Kubernetes | [FastAPI](./docs/fastapi.md), [Kubernetes](./docs/kubernetes.md) |
  143. | **Inside a durable workflow** | Authority must survive retries, queues, and long-running execution | Temporal | [Temporal guide](./docs/temporal-reference.md) |
  144. | **At an agent handoff** | One agent delegates part of a task to another agent | A2A, MCP warrant stacks | [A2A guide](./docs/a2a.md), [delegation demo](./tenuo-python/examples/mcp/mcp_delegation_demo.py) |
  145. These are deployment choices for one authorization system. A warrant can be verified anywhere its issuer is trusted, and every delegated warrant must remain within its parent.
  146. ---
  147. ## Security Boundaries
  148. Tenuo checks the warrant and the actual tool arguments before an action executes. Enforcement must run at a boundary the agent cannot modify or bypass; an in-process guard alone does not isolate an untrusted agent.
  149. Tenuo complements your identity system and policy controls. Use a container or VM when you need process isolation. For disconnected deployments, provision trusted keys and revocation state in advance; offline verification cannot discover revocations it has not received.
  150. See the [security model](./docs/security.md) for guarantees and limitations.
  151. ## Deploying to Production
  152. The self-hosted core and sidecar are Apache-2.0 and run entirely in your infrastructure, with no external calls at verification time.
  153. **Self-hosted checklist:**
  154. - Store signing keys in a secrets manager (Vault, AWS Secrets Manager, GCP Secret Manager). Keep them out of environment variables
  155. - Configure `trusted_roots` with your control plane's public keys
  156. - Ensure `dry_run` is disabled and warrants are required in all enforcement points
  157. - Enable audit callbacks and metrics for observability
  158. See the [Production Guide](./docs/production-guide.md) for enforcement modes, gradual rollout, and key management, and the [Security Model](https://tenuo.ai/security) for the full threat model.
  159. ### Tenuo Cloud (Optional)
  160. [Tenuo Cloud](https://cloud.tenuo.ai/) is an optional managed control plane for issuance, key rotation, hosted revocation distribution, observability, and multi-tenant isolation. Verification stays local. Self-hosted Tenuo already verifies warrants and signed revocation lists (SRLs) in your own infrastructure.
  161. ---
  162. ## Docker & Kubernetes
  163. **Try the Demo**:
  164. ```bash
  165. docker compose up
  166. ```
  167. This runs the [orchestrator -> worker -> authorizer](https://tenuo.ai/demo.html) stack: issuance, delegation, and verification.
  168. **Official Images** on [Docker Hub](https://hub.docker.com/u/tenuo):
  169. ```bash
  170. docker pull tenuo/authorizer:0.3.7 # Sidecar for warrant verification
  171. docker pull tenuo/control:0.3.7 # Control plane (demo/reference)
  172. ```
  173. **Helm Chart**:
  174. ```bash
  175. helm install tenuo-authorizer ./charts/tenuo-authorizer \
  176. --set config.trustedRoots[0]="YOUR_CONTROL_PLANE_PUBLIC_KEY"
  177. ```
  178. See [Helm chart README](./charts/tenuo-authorizer) and [Kubernetes guide](https://tenuo.ai/kubernetes).
  179. ---
  180. ## Documentation
  181. | Resource | Description |
  182. |----------|-------------|
  183. | **[AI Agent Delegation Security Lab](./labs/agent-delegation/README.md)** | A hands-on lab: six agents, one rogue, five core levels plus two optional bosses |
  184. | **[Quickstart](https://tenuo.ai/quickstart)** | Get running in 5 minutes |
  185. | **[Concepts](https://tenuo.ai/concepts)** | How warrants and attenuation work |
  186. | **[Constraints](https://tenuo.ai/constraints)** | All 11 constraint types explained |
  187. | **[Security](https://tenuo.ai/security)** | Threat model and guarantees |
  188. | **[OpenAI](https://tenuo.ai/openai)** | Direct API protection with streaming |
  189. | **[Google ADK](https://tenuo.ai/google-adk)** | ADK agent tool protection |
  190. | **[AutoGen](https://tenuo.ai/autogen)** | AgentChat tool protection |
  191. | **[Hermes Agent](https://tenuo.ai/hermes)** | Official Hermes plugin for signed, expiring tool authorization |
  192. | **[A2A](https://tenuo.ai/a2a)** | Inter-agent delegation |
  193. | **[FastAPI](https://tenuo.ai/fastapi)** | Protect FastAPI routes |
  194. | **[LangChain](https://tenuo.ai/langchain)** | Tool protection |
  195. | **[LangGraph](https://tenuo.ai/langgraph)** | Multi-agent graph security |
  196. | **[CrewAI](https://tenuo.ai/crewai)** | Multi-agent crew protection |
  197. | **[Temporal](https://tenuo.ai/temporal)** | Durable workflow authorization |
  198. | **[MCP](https://tenuo.ai/mcp)** | Model Context Protocol client + server verification |
  199. ### AI Coding Agents
  200. Install Tenuo's implementation skill so a supported coding agent can place
  201. authorization at the effect boundary, use the SDK version in your project, and
  202. generate both allow and deny-before-effect tests:
  203. ```bash
  204. npx skills add tenuo-ai/tenuo --skill tenuo-agent-authorization
  205. ```
  206. The skill distinguishes an in-process guardrail from an independently enforced
  207. boundary and reports the guarantee and remaining bypasses explicitly. It does
  208. not ask the agent to reimplement Tenuo's cryptography or protocol.
  209. ## Try It: The AI Agent Delegation Security Lab
  210. A travel assistant made of six AI agents is booking a spring-break trip. One of them has been told to do something it shouldn't. Secure the system so the trip still happens and the rogue agent gets nowhere.
  211. ```bash
  212. git clone https://github.com/tenuo-ai/tenuo
  213. cd tenuo/labs/agent-delegation
  214. npm install
  215. npm run lab
  216. ```
  217. Five main levels plus two optional bosses, no agent-framework experience needed. Book the trip, stop the rogue agent, and learn why each handoff should carry only the authority its task needs. Runs offline with free retries and no API key. The guide is at [tenuo.ai/lab](https://tenuo.ai/lab/); the code is in [`labs/agent-delegation`](./labs/agent-delegation/README.md).
  218. ---
  219. ## Requirements
  220. | Component | Supported |
  221. |-----------|-----------|
  222. | **Python** | 3.9 - 3.14 |
  223. | **Node.js** | **Beta**. Node 20+ (`npm i @tenuo/core@beta`) |
  224. | **OS** | Linux, macOS, Windows |
  225. | **Python installation** | Prebuilt wheels for Linux (x86_64 and aarch64), macOS (arm64), and Windows (x64). Other platforms build from source and need Rust |
  226. ### Optional Dependencies
  227. With uv, use `uv pip install` in place of `pip install`.
  228. ```bash
  229. pip install tenuo # Core only
  230. pip install "tenuo[openai]" # + OpenAI Agents SDK
  231. pip install "tenuo[google_adk]" # + Google ADK
  232. pip install "tenuo[a2a]" # + A2A (inter-agent delegation)
  233. pip install "tenuo[fastapi]" # + FastAPI integration
  234. pip install "tenuo[langchain]" # + LangChain (langchain-core ≥0.2)
  235. pip install "tenuo[langgraph]" # + LangGraph (includes LangChain)
  236. pip install "tenuo[crewai]" # + CrewAI
  237. pip install "tenuo[temporal]" # + Temporal workflows
  238. pip install "tenuo[autogen]" # + AutoGen AgentChat (Python ≥3.10)
  239. pip install "tenuo[mcp]" # + official MCP SDK, client & server verification (Python ≥3.10)
  240. pip install "tenuo[fastmcp]" # + FastMCP (TenuoMiddleware / FastMCP servers)
  241. pip install "tenuo[cloud]" # + Tenuo Cloud SDK (proprietary control-plane client)
  242. ```
  243. ---
  244. ## Rust
  245. The core crate is the protocol. The `sdk` feature is the enforcement surface: a guard that checks a call before it runs, an authority that binds a warrant chain to a signing key, cryptographic delegation, an observe mode, and MCP and HTTP transports.
  246. ```toml
  247. [dependencies]
  248. tenuo = { version = "0.3.7", features = ["sdk"] }
  249. ```
  250. ```rust
  251. use std::time::Duration;
  252. use tenuo::sdk::prelude::*;
  253. use tenuo::{args, constraints};
  254. let root = SigningKey::generate(); // in production this lives in your control plane
  255. let holder = SigningKey::generate();
  256. let warrant = Warrant::builder()
  257. .capability("read_file", constraints! { "path" => Pattern::new("/data/*")? })
  258. .holder(holder.public_key())
  259. .ttl(Duration::from_secs(300))
  260. .build(&root)?;
  261. let runtime = Runtime::builder()
  262. .holder(holder)
  263. .trusted_root(root.public_key())
  264. .revocation(RevocationMode::TtlOnly { max_lifetime: Duration::from_secs(600) })
  265. .build()?;
  266. let session = runtime.session_from_warrant(warrant)?;
  267. let allowed = Call::owned("read_file", args! { "path" => "/data/report.csv" })?;
  268. let out = session.guard(&allowed, |_| Ok::<_, std::io::Error>("read"))?;
  269. assert_eq!(out.into_inner(), "read");
  270. let refused = Call::owned("read_file", args! { "path" => "/etc/shadow" })?;
  271. assert!(session.check(&refused).is_err());
  272. ```
  273. The closure runs only after an allow. A call outside the constraint is denied before it runs, same as Python `@guard`. A guard with no trust root or no revocation policy does not compile.
  274. Features, all off by default: `sdk`, `mcp-transport`, `http-transport`, `async`, `receipts`, `otel`, `test-utils`. The default build adds no extra crates.
  275. Use Rust for authorizer sidecars, gateways, MCP servers built on `rmcp`, and any service that needs enforcement without a Python runtime.
  276. - API docs: [docs.rs/tenuo](https://docs.rs/tenuo)
  277. - Security model: [tenuo.ai/security](https://tenuo.ai/security)
  278. - Constraints reference: [tenuo.ai/constraints](https://tenuo.ai/constraints)
  279. ---
  280. ## How It Works
  281. Tenuo is capability-based authorization. A warrant is a capability: a signed grant that lists the tools an agent may call, the argument values it may pass, the key that may use it, and when it expires. The warrant travels with the request. The verifier uses the trusted issuer key and locally available revocation state.
  282. **Holder-bound.** Every warrant names a public key. Every call carries a signature from that key over the warrant, the tool, the exact arguments, and a short time window. A copied warrant is useless without the key.
  283. **Verified offline.** The warrant carries its own authority and signature. Checking it needs no lookup and no network. Checks run in under 50 μs, and enforcement keeps working when the control plane is down.
  284. **Attenuates monotonically.** Delegation mints a child warrant signed by the parent's holder. The verifier walks the whole chain from a trusted root to the leaf. Each link may drop tools, tighten constraints, or shorten expiry. No delegated warrant can exceed its parent. Tenuo calls this **Subtractive Delegation**.
  285. **Holds under prompt injection.** The check never asks the model. It runs at the tool boundary, on the real arguments, after the model has chosen what to call. A hijacked agent can only make the calls its warrant already allowed.
  286. ```
  287. ┌──────────────────┐ ┌──────────────────┐ ┌──────────────────┐
  288. │ Control Plane │ │ Orchestrator │ │ Worker │
  289. │ │ │ │ │ │
  290. │ Issues root │────▶│ Attenuates │────▶│ Executes with │
  291. │ warrant │ │ for task │ │ proof │
  292. └──────────────────┘ └──────────────────┘ └──────────────────┘
  293. Full scope --> Narrower --> Narrowest
  294. ```
  295. 1. **Control plane** issues a root warrant with broad capabilities
  296. 2. **Orchestrator** attenuates it for a specific task; scope can only shrink
  297. 3. **Worker** proves possession of the bound key and executes
  298. See [Concepts](https://tenuo.ai/concepts) for the model and [Related Work](./docs/related-work.md) for how this compares to Biscuit, Macaroons, UCAN, and [CaMeL](https://arxiv.org/abs/2503.18813).
  299. ---
  300. ## Why Tenuo?
  301. IAM answers who you are. Tenuo answers what this workload may do for this task, right now. Agents stay free to plan and pick tools. The warrant still applies after they choose.
  302. | Existing limitation | Tenuo |
  303. |---------------------|-------|
  304. | IAM typically grants authority by identity or role | Warrants limit authority to the current task |
  305. | Conventional agent handoffs do not carry the original authorization context | Authority travels with the work and can only narrow |
  306. | Plain bearer tokens can be copied or replayed | Every warrant is bound to the key using it |
  307. | Central policy checks introduce a runtime dependency | Signed authority is verified locally at execution |
  308. | Generic string matching can disagree with downstream systems | [Semantic constraints](https://tenuo.ai/constraints) interpret arguments as the target does ([why this matters](https://niyikiza.com/posts/cve-2025-66032/)) |
  309. Signed authorization receipts are opt-in when you need to show why a call was allowed or denied.
  310. ---
  311. ## Prior Art
  312. Tenuo builds on capability token ideas described in [CaMeL](https://arxiv.org/abs/2503.18813) (Debenedetti et al., 2025). Inspired by [Macaroons](https://research.google/pubs/pub41892/), [Biscuit](https://www.biscuitsec.org/), and [UCAN](https://ucan.xyz/).
  313. The token format and delegation protocol are specified in [Attenuating Authorization Tokens for Agentic Delegation Chains](https://datatracker.ietf.org/doc/draft-niyikiza-oauth-attenuating-agent-tokens/), an active individual Internet-Draft in the IETF OAuth Working Group. The core attenuation rules are formally verified with [Alloy](docs/formal_verification/aat_constraints.als) (capability and argument-key monotonicity) and [Z3](docs/formal_verification/z3_bounds.py) (constraint-type subsumption bounds).
  314. See [Related Work](https://tenuo.ai/related-work) for detailed comparison.
  315. ---
  316. ## Featured In
  317. - [TLDR InfoSec](https://tldr.tech/infosec/2026-01-13) - "The Map is not the Territory: The Agent-Tool Trust Boundary"
  318. - [TLDR InfoSec](https://tldr.tech/infosec/2025-12-15) - "Capabilities Are the Only Way to Secure Agent Delegation"
  319. - [Awesome Object Capabilities](https://github.com/dckc/awesome-ocap) - Curated list of capability-based security resources
  320. - [Awesome LangChain](https://github.com/kyrolabs/awesome-langchain)
  321. - [Awesome LLM Agent Security](https://github.com/wearetyomsmnv/Awesome-LLM-agent-Security)
  322. - [Awesome LLMSecOps](https://github.com/wearetyomsmnv/Awesome-LLMSecOps)
  323. ---
  324. ## Etymology
  325. **Tenuo** (/tɛn-ju-oʊ/ • *Ten-YOO-oh*)
  326. From Latin *tenuare*: "to make thin; to attenuate."
  327. Authority starts broad at the root and is **attenuated** as it flows down the delegation chain.
  328. ---
  329. ## Contributing
  330. Tenuo is Apache-2.0 and built in the open. The core is Rust, with Python and TypeScript SDKs on top. Good places to start:
  331. - **Framework integrations.** Adapters live in `tenuo-python/tenuo/`. The [integration guide](tenuo-python/docs/integration-guide.md) covers the required API patterns and invariant tests. [OpenAI](tenuo-python/tenuo/openai.py) and [Google ADK](tenuo-python/tenuo/google_adk/guard.py) are good templates.
  332. - **Constraint types.** There are 11 today. A new one has to parse input the same way the target system does.
  333. - **The Rust SDK.** New in 0.2.4. Adapters for Rust agent frameworks are open ground.
  334. - **The TypeScript SDK.** It is in beta and needs real-world use.
  335. - **Docs and examples.** If a guide confused you, that is a bug worth filing.
  336. See [CONTRIBUTING.md](CONTRIBUTING.md) for setup, tests, and the PR process.
  337. **Security issues**: Email security@tenuo.ai with PGP ([key](./SECURITY_PUBKEY.asc)). Please do not open public issues for these.
  338. ---
  339. ## License
  340. Apache-2.0. See [LICENSE](LICENSE) for details.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.