Every agent payment, authorized before it settles.

Your system signs one proposed action. Tiberian returns allow, block, or human approval, with an attestation bound to it.

The Tiberian operator console, showing decision health, the human review queue, event volume, decision mix and network coverage for one participant.

Tiberian sits above the standards agents already transact on.

  • Tool call interceptor
  • x402Evaluated before settlement
  • Trusted agent payload
  • Shared payment token
  • AP2Mandate contract

The agent acted. Nobody can say what it was allowed to do.

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.

  • Delegation

    Scope granted at deploy time

    A mandate written once, for the agent, never narrowed to this specific action.

    ALLOWResolved alone
  • Execution

    Agent runtime

    The action ran because nothing in its path was positioned to refuse it.

    ALLOWResolved alone
  • After the fact

    Application logs

    A line showing the call, not the authority behind it, and no way to prove it was not edited.

    ALLOWResolved alone

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.

A sequence of agent actions and how the network resolved each one.
TimeAgentVenueActionAmountResolvedCodes

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

Allowed. Stoppable. Provable.

Follow one payment

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?

Every agent carries a signed permission slip.

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.

  • Limits per payment, per month, and per supplier
  • Permission passed from one agent to another can only shrink, never grow
  • A forged, expired or revoked slip is refused automatically, every time
Permission slipSigned by Head of Finance
Agent
billing-agent
Acting for
Finance team
May do
Pay supplier invoices
Suppliers
Approved list only
Per payment
Up to $10,000
Valid until
31 Dec 2026

This payment, checked against the slip

  • Paying an invoice is on the slip
  • $9,800 is under the $10,000 limit
  • Northwind Supply is an approved supplier
  • $24,600 of the $40,000 monthly budget used, room for this payment
It is allowed. But allowed is not the same as safe, so it goes on to the checkpoint.
  1. Plug in

    Add one check before your agent pays, or route its tools through the Tiberian gateway. The agent's own code stays the same.

  2. Rehearse

    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.

  3. Go live

    When you trust what you see, switch on enforcement. Risky payments wait for a person and everything else carries on.

Every integration does the same three things.

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.

Identical attacks. The only variable is whether platforms share the graph.

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

    missedREVIEW 73
  • split-limit evasion (fiat/stablecoin)

    missedBLOCK 87
  • circular flow / reputation ring

    missedREVIEW 69
  • confirmed-fraud propagation

    missedBLOCK 91

No benign evaluation was flagged in either arm, across 120 sampled, which bounds the true false-positive rate at 2.5% with 95% confidence.

Correlation without a single shared identifier.

A participant benefits from network intelligence without seeing another participant’s raw events, identities, customers, or transaction details.

Nothing crosses a tenant line in the clear

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.

Matching names prove nothing

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.

One report is an allegation

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.

Two participants, one node, no shared identifier

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

The signal only exists between platforms.

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.

Shipped and measured, not described.

No customer count, no volume, no uptime figure. Those would be invented. These are the numbers the repository can prove about itself.

1,012
Python tests passing
53
TypeScript SDK tests
55
Tables under forced row-level security

The network gets sharper every time a platform joins.

Tell us what your agents do and how much they move. We will size the integration and get you a participant key.