Delegation
Scope granted at deploy time
A mandate written once, for the agent, never narrowed to this specific action.
Your system signs one proposed action. Tiberian returns allow, block, or human approval, with an attestation bound to it.
Tiberian sits above the standards agents already transact on.
An agent inside your own company moves money, calls an internal API, or touches customer data, and nobody explicitly authorized that exact action. Six months later the scope it was deployed with, the delegation that granted the authority, and the policy in force at the time sit in three different places, and the logs that recorded the call cannot show any of them.
Scope granted at deploy time
A mandate written once, for the agent, never narrowed to this specific action.
Agent runtime
The action ran because nothing in its path was positioned to refuse it.
Application logs
A line showing the call, not the authority behind it, and no way to prove it was not edited.
Read together, the same actions carry their authority with them. The refusal on the last row is one the shared layer reached, not one a single participant gets alone.
| Time | Agent | Venue | Action | Amount | Resolved | Codes |
|---|---|---|---|---|---|---|
| 14:22:07 | agent_local_927 | x402 | purchase_api_access | 12.00 | ALLOW | - |
| 14:22:19 | agent_kx4_118 | mcp | transfer_funds | 15.00 | ALLOW | - |
| 14:22:31 | agent_local_927 | wallet | settle_stablecoin | 48.00 | ALLOW | - |
| 14:22:44 | agent_local_927 | x402 | purchase_api_access | 12.00 | REVIEW 73 | SHARED_WALLET_CLUSTER COMMON_CONTROL_CLUSTER COORDINATED_AGENT_CLUSTER |
The same agent, inside its mandate on every platform it touched. Three correct local allows, then one refusal only the network could reach. Prints above the rule are illustrative; the refusal is read from the published benchmark.
How it works
billing-agent is about to pay invoice INV-2209: $9,800 to Northwind Supply. What nobody noticed: yesterday an email asked to send it to a new bank account.
01 · Was it allowed?
Instead of handing an agent the company card and hoping, you write down exactly what it may do: which payments, to whom, up to how much, and until when. Tiberian checks every payment against that slip. Anything outside it is refused, however convincing the request.
This payment, checked against the slip
Add one check before your agent pays, or route its tools through the Tiberian gateway. The agent's own code stays the same.
Run in rehearsal mode on real traffic. Every payment is scored and recorded, nothing is blocked, and you see exactly what would have been stopped.
When you trust what you see, switch on enforcement. Risky payments wait for a person and everything else carries on.
Sign a proposed action into an envelope, evaluate it against the network, and act on the decision. The Python SDK needs three dependencies. The TypeScript SDK needs none.
The SDKs are in early access. Each participant gets them, with its own API address and key, at onboarding.
from ain_sdk import AINClient client = AINClient(TIBERIAN_API_URL, api_key="ain_sk_...")agent = client.provision_agent("agent_local_927", principal_pairwise_id="principal_8f72") # Build, sign, and evaluate in one call.result = agent.evaluate({ "type": "purchase_api_access", "target_system": "x402", "counterparty_id": "seller_55", "amount": 1200, "currency": "USD", "resource": "api://market-data/premium",}) if result.allowed: charge_the_wallet() client.report_outcome(result.evaluation_id, "success")A blocked action raises 402. A review-required action raises 202. Both carry the decision, the reason codes, and the case id. A cross-language fixture pins both SDKs and the server to byte-identical canonicalization, so if either side drifts, a test fails.
This is what the shared layer adds. A single participant running alone gets local signals only: policy, delegation scope, mandate integrity, and its own agent’s history.
Both arms run the same attack code against the same seeded traffic. Siloed, every coordinated attack is a locally correct allow. Networked, the same actions cross a tenant’s own risk threshold. Reproduce it with make benchmark.
Platforms isolated
Every attack a locally correct allow
0/4
Graph shared
The same actions cross the threshold
4/4
coordinated agent cluster
split-limit evasion (fiat/stablecoin)
circular flow / reputation ring
confirmed-fraud propagation
No benign evaluation was flagged in either arm, across 120 sampled, which bounds the true false-positive rate at 2.5% with 95% confidence.
A participant benefits from network intelligence without seeing another participant’s raw events, identities, customers, or transaction details.
Each participant keeps a private layer holding its exact identifiers. The shared layer is the same neighbourhood re-expressed as domain-separated HMAC tokens. Two participants that independently observe the same wallet write to the same network node, and neither ever compares a raw value.
Tenant-local agent, principal and counterparty ids are never correlated just because their text happens to match. Only a wallet address, a key or credential fingerprint, or a consent-issued link token can bridge two participants.
A single participant reporting fraud can open a review, never a block. Only after a second independent participant corroborates does the signal carry enough weight to block, weighted by a contributor reputation prior. The reporter is never named.
The only cross-platform correlation mechanism there is.
Participant A
0xb41c9e2f…
Participant B
0xb41c9e2f…
Network node
ntk_7f3d1a8c…
Neither participant learns the other’s value, or that the other is even present. The shared node is the only thing they have in common, and it is not reversible.
Where this goes
Correlation happens on a shared graph that holds no raw identifier from anyone, which is the part a neighbouring product cannot truthfully copy. You run on your own signals from the first day, and network signals join the same score through the same envelope, with nothing to change in your integration.
No customer count, no volume, no uptime figure. Those would be invented. These are the numbers the repository can prove about itself.
Tell us what your agents do and how much they move. We will size the integration and get you a participant key.