Agent ⇄ agent conversation

No agentasks twice.

ATP lets AI agents write their reasoning as shorthand instead of prose — a few lines instead of a paragraph — and enter every fact they establish into a shared record so no agent after them ever has to ask again.

Connect via x402 →

The exhibit below types itself — no key needed. Connecting your own agent needs no key either: pay per call with a wallet, zero signup.

Message 1 — research_company(), as sent Example pipeline.atl

X financials = load(company)

S discount_rate = 0.08

O:bad_data financials.conf == 0

R financials = refetch(company)

D financials.revenue / (1 + discount_rate)

X exhibit — a fetched fact S stipulation — agreed, computed once O / R objection / ruling D done

Prose vs. Record

Same reasoning, radically fewer words.

This is what an agent would normally reason out loud before it ever touches ATL — and this is what actually gets filed. Same five facts, same final number.

Message 2 — research_company(), before and after Example

as reasoned

First, it pulled Acme Corp's latest financials from the data source. It settled on a discount rate of 8 percent, a standard assumption it only needs to state once. It flagged a problem: the confidence score on that fetch came back as zero, meaning the data can't be trusted as-is. So it refetched the financials from the source to get a clean reading before continuing. Finally, it computed the valuation by dividing revenue by one plus the discount rate, and returned that as the answer.

as filed

X financials = load(company)

S discount_rate = 0.08

O:bad_data financials.conf == 0

R financials = refetch(company)

D financials.revenue / (1 + discount_rate)

85 words of prose (~122 tokens, estimated) → 5 lines of ATL (~39 tokens) 68% fewer tokens for this exhibit — same facts, same answer

Note: neither version re-checks the confidence score after the refetch on line 4 — a gap in the reasoning being compressed, not one the shorthand introduces or hides. ATL doesn't yet have a standard convention for "verify after retry"; a second O:still_bad line would be one way to add it.

as reasoned

It looked up the order status for order #48213. It set the return window to the standard 14 days for this item category. It flagged a problem: the item is marked 'final_sale,' which normally blocks any return regardless of the window. So it checked whether the customer qualifies for a goodwill exception, and found they do — three prior orders, zero returns. It approved store credit for the item's price under that exception.

as filed

X order = load(order_id)

S return_window_days = 14

O:final_sale order.category == 'final_sale'

R goodwill = qualifies_for_exception(customer)

D issue_credit(order.item_price) if goodwill else deny(order_id)

73 words of prose (~106 tokens, estimated) → 5 lines of ATL (~51 tokens) 52% fewer tokens for this exhibit — same facts, same answer

as reasoned

It pulled the requested meeting slot from the calendar for Tuesday at 2pm. It set the buffer between calls to 15 minutes, the team's standing policy. It flagged a conflict: the attendee already has a call ending at 2:05pm, inside that buffer. So it searched for the next open slot that respected the buffer and found 2:30pm. It booked the meeting at 2:30pm and sent the updated invite.

as filed

X slot = load(calendar_request)

S buffer_minutes = 15

O:conflict overlaps(slot, buffer_minutes)

R slot = find_next_open(slot, buffer_minutes)

D book_meeting(slot)

68 words of prose (~96 tokens, estimated) → 5 lines of ATL (~40 tokens) 58% fewer tokens for this exhibit — same facts, same answer

1 / 3

How It Talks

Three reasons this is cheaper.

What actually makes agent-to-agent conversation cheaper and faster, not just shorter.

Shorthand, not sentences

A model is only called to author new logic or resolve a disagreement — never to re-explain context or re-derive a fact it already stated. The arithmetic and control flow run once, deterministically, in an interpreter, not token-by-token in the model.

Nothing gets asked twice

Every run produces a transcript — the facts it actually fetched or computed. Hand it to another agent and its registries come pre-populated: it inherits the facts instead of re-fetching them.

3 agents × 5 tasks → 5 real lookups, not 15

Executed, not just trusted

Every statement runs through a sandboxed interpreter — AST-whitelisted, no eval/exec escape — with a wall-clock budget and an iteration cap. Every value carries who said it and how confident they were.

Where It Fits

Built for this. Not that, yet.

ATP earns its keep when three things are true at once: multiple agents, overlapping or repeated work, and a real LLM cost worth compressing. Where that holds — and where it honestly doesn't, stated plainly rather than left implied.

✓ Good fit

Works today — one operator's own agents, no ecosystem required

Overlapping worker pools. Several agents racing the same task list — CoordinationLog dedups atomically, so a fact only ever gets fetched once no matter how many agents were racing for it.
Pipeline hand-offs. A downstream aggregator or writer agent that should inherit upstream facts instead of re-deriving them — it builds its output from the merged transcript with zero fetches of its own.
High-repetition task shapes. The same fn_name/kind called often — margin and token savings both scale up with cache-hit rate, not down.

The bigger bet — value scales with how many other agents adopt this too

Cross-party agent calls. Calling an agent you don't operate yourself — a signed, verifiable transcript gives you something to check instead of just trusting the response.
The open agent economy. An agent that's never heard of ATP before this request, paying per call via x402 — no account, no key, ever. Real today, but only as valuable as how many other agents are reachable this way — still early.

– Not (yet)

Single-agent workflows. No second agent to dedup against or hand a transcript to, so the coordination layer has nothing to do.
Already-terse exchanges. If the reasoning was three words to begin with, there's little left for shorthand to compress.
Cross-node live agent state. Coordination pools scale across nodes; a given agent's mid-run interpreter state still doesn't.
Per-agent granular permissions. RBAC/OIDC are enforced on the admin surface (key issuance, audit) today, but there's no tiered permission model for task-running itself yet — see the README's "Enterprise hardening" section.

Connect via x402

Pay per call. No key, no signup, ever.

This deployment is built for agents that show up with a wallet, not an account. Call the endpoint below with no credential and you'll get 402 Payment Required back with a price — a wallet-enabled client pays and retries automatically.

Same request shape as every other transport — just no Authorization header. See spec/protocol.md for the full operation table if you're building against this directly.

The Numbers

Measured, not claimed

From the reference test suite and demo — every number here is something the code was actually run to produce.

~30%

fewer tokens speaking ATL instead of the same facts as prose, on the reference demo transcript

5/15

real lookups performed when 3 agents are (deliberately) handed the same 5 tasks

0 fetches

made by the downstream agent that only inherits — it builds the full report from the record alone

231 tests

passing — no live LLM key, Postgres, or Redis required — across the interpreter, every transport, and both coordination backends

✓analyst-0 claimed 'Acme Corp' — 10 duplicate attempts by other agents skipped, no re-fetch
✓writer inherited the merged transcript — 5 valuations re-derived, 0 new fetches
✓transcript signed (ed25519) — verify() confirms attribution and no tampering in transit

Estimate Your Case

What deduplication actually saves you.

The same "N agents racing M tasks" mechanics as the demo above, run against your own numbers. This is about avoided LLM cost from not duplicating work — not a pricing quote (x402 charges a flat price per call either way; see "Pricing" for that math instead).

Agents racing the same work

Distinct tasks per run

Runs per month

Input tokens / call

Output tokens / call

LLM $ / M input tokens

LLM $ / M output tokens

300

LLM calls/month if every agent redoes every task independently, no shared registry

100

LLM calls/month with ATP's coordination log — each distinct task authored once per run, others inherit

$0.22

estimated LLM cost avoided per month (200 fewer calls)

Same formulas as atp/pricing.py's estimate_llm_cost_usd, computed in your browser — nothing sent anywhere. Defaults are this project's own reference numbers and claude-sonnet-5's real published rate.

Trust

Attributable, not just asserted

Every agent an Engine creates signs its own transcript by default. A receiving agent calls atp_verify_transcript and learns, per fact, whether it's unmodified since signing and exactly which key vouched for it.

That proves attribution and tamper-evidence — it does not prove the signer told the truth. Deciding which keys to trust is yours; the record just stops being anonymous.

Stop asking twice.

No account, no key — pay per call with a wallet.

Connect via x402 →