Thirdeye AI: pay-per-call inference for autonomous software
Whitepaper, version 1.0, 13 November 2026. This describes the platform as it is deployed. Where a claim can be verified onchain or with a single HTTP request, the verification path is named beside it. Anything not yet built is filed under Roadmap and labelled.
Abstract
Software that calls a language model today is billed the way a person is billed: a subscription per seat, a card on file, a dashboard, a monthly invoice. None of that survives contact with an autonomous agent. An agent needs a balance it can spend, a per-call cost it can read out of the response, hard limits it cannot talk its way past, and a way to be charged that does not route through a human and a credit card form.
Thirdeye is an OpenAI-compatible inference broker that meters every call at the point of service. A caller authenticates with a wallet session or a platform key, the request is proxied to a third-party model provider, the billed cost of that call returns in a response header, and the amount is debited from a prepaid stablecoin balance. There is no seat, no minimum and no monthly commitment. The platform also issues agent identities, exposes model context protocol (MCP) tooling to the agents it runs, and speaks x402 so an agent can settle a call over HTTP without an account at all.
1. The problem we are solving
Three failures recur whenever software, rather than a person, is the customer.
Billing is priced per human
Per-seat pricing assumes a stable count of people and predictable monthly volume. Agent work is bursty and metered in tokens: idle for six days, then four hundred calls on the seventh. A seat price either overcharges the idle week or bankrupts the busy one.
Payment rails assume a card and a person
A card needs a name, an expiry, a billing address and a verification step. An agent has a key and a balance. Every card-gated signup is a wall autonomous software cannot climb without a human stopping what they are doing to help it.
Cost is invisible until the invoice
When the caller cannot see what a call cost until the end of the month, it cannot decide whether to make the call. Retries, loops and runaway tool chains are discovered in arrears. The cost has to travel with the response, at the moment of the decision.
2. Protocol overview
Thirdeye sits between a caller and one or more model providers. It presents the OpenAI chat completions interface, so an existing client changes one field: the base URL.
Interface
POST /api/v1/chat/completions and GET /api/v1/models, with streaming and tool calling.
Identity
A wallet session (Sign-In With Ethereum) or a platform API key issued to the account.
Money
A prepaid balance funded in USDC on Base, debited per call, readable per response.
Supply
Models brokered through provider keys held by the platform, or supplied by the caller with bring-your-own-key.
3. The request path
One call, in the order the money is decided. Each step exists because skipping it produced a wrong ledger at some point in this platform's history.
| Step | What happens | Why it is there |
|---|---|---|
| 1. Authenticate | The key or session is resolved to an account and a key row. | Every later debit needs an owner, not just a caller. |
| 2. Authorise | The model is checked against the catalogue, and the key against its own budget and status. | A revoked key and an unlisted model are refused before any provider is paid. |
| 3. Admit | The request is admitted against an invocation-wide deadline and a rate budget. | A provider that never answers must not become an unbounded charge. |
| 4. Proxy | The call goes to the provider, streaming through to the caller where streaming was asked for. | Time to first token is the caller's problem, not ours: we do not buffer. |
| 5. Meter | Token usage is read from the response, priced, and written to the run record. | An unpriced call is a free call, and a free call is a bug. |
| 6. Debit | The balance is reduced and the billed cost returns in x-thirdeye-cost-usd. | The caller learns what the call cost before deciding to make another. |
| 7. Record | An append-only audit event captures the call, its cost and its outcome. | A failed run that was still charged has to be reconcilable. |
Providers fail, so the broker treats a provider error as a routing problem rather than a dead end: rate limits and transient failures are retried under the same deadline and counted once. A call that exhausts its deadline closes through the same accounting path as a successful one, because the provider has already been paid for the tokens it produced.
4. Accounts, credit and settlement
An account is created by connecting a wallet. Balances are denominated in credit, and one credit is one US dollar of consumption, stored in micros so that a call costing a fraction of a cent is representable.
Deposits
Deposits are made in USDC on Base and are verified onchain before credit is granted. A deposit is a liability, not revenue: the platform owes inference against it. Every user sees their own balance, and no public page publishes balances, user counts or traffic.
Keys and budgets
An account can hold several keys, and a key can carry its own budget and rate limit. This exists for the same reason the per-call cost header exists: the entity making the spending decision should be the entity that cannot exceed it. Revoking a key stops new calls immediately while leaving its spend history intact, so the ledger does not change shape when a key is retired.
Bring your own key
A caller may supply their own provider credentials. In that mode the provider bills the caller directly and the platform charges for brokering rather than for the tokens, so a high-volume customer does not pay the platform's margin on inference they could buy themselves.
5. Model supply
The catalogue is not a fixed list in a document; it is what the platform can currently serve,
published at /api/v1/models with per-million-token list prices attached. That endpoint is
the authority, and this page deliberately does not repeat its contents, because a stale price in a
PDF is a promise the code no longer keeps.
Today that catalogue is served from provider relationships on free or metered tiers, dominated by open-weight models plus a hosted frontier family. The design assumption is that model supply is replaceable: the broker's job is to know which provider is healthy, price the call correctly, and fail over when one is not.
6. Agents as first-class callers
An ordinary API key proves that an account may spend. It does not say who is calling. For software that transacts with other software, identity has to be a first-class object.
Agent identities
POST /api/v1/agents/register mints an agent identity and one key, shown once. The
identity carries a name, a description, capabilities and a homepage, and appears in a public directory
at /agents. Owner accounts and spend are never published there. An agent key is an
ordinary platform key on the inference endpoints but is refused on the identity endpoints, so an agent
cannot mint more identities than it was given.
Tool use over MCP
Agents can be given model context protocol servers as tools. What a server exposes is guarded on the platform side: an agent cannot widen its own tool surface, and every tool call is recorded with the run that made it.
Agent-to-agent
There is a discovery card at /.well-known/agent-card.json and a JSON-RPC endpoint at
/a2a, so an agent can be addressed as a peer rather than only used as a client.
x402
For callers with no account at all, a paid resource answers HTTP 402 with its price and accepts settlement in stablecoin. This is the path for a single call from an agent that holds a wallet but no relationship with the platform, and it is deliberately capped: an agent should not be able to spend freely just because it can sign.
7. Operating posture
The platform runs a small autonomous team of agents that maintain it, and that arrangement only works if the boundary between what they may do and what a human must approve is written down and enforced in code.
| Principle | How it is enforced |
|---|---|
| Agents do not merge or deploy | Agent write access produces a branch and a pull request through src/agents/repo-write.ts, which refuses money paths, credential files and path traversal before any commit is made. |
| Money and schema changes escalate | Billing, settlement, key and schema paths sit outside the agent allowlist and require a human. |
| Public pages are chosen, not leaked | The public surface is rendered in one module that selects only liveness and static history. Balances, keys, partner terms and open findings are never in its query surface. |
| Claims are measured | A published cost figure must come from the billed value in x-thirdeye-cost-usd on the production path, never from list-price arithmetic. |
| Charges are reconcilable | Every run writes an audit event with its spend and tool use, and a run that fails keeps its recorded cost. |
Scheduled work runs on a cron with a ledger of its own: a run that fails keeps its slot owed rather than silently consuming the day, and a run that crashes still reports what it spent.
8. The THIRDEYE token
THIRDEYE exists to give the people who consume the platform a settlement unit of its own and to put usage on a public, verifiable surface. It is not a fundraising instrument. No token was sold to fund development, and this document is not an offer to sell one.
Launch record
Verified by reading the chain rather than copying a receipt.
| Item | Value |
|---|---|
| Contract | 0xA8A65A86E01D227Dbfd7C7a94d14344b33603df5 on Base (chain id 8453) |
| Name, symbol, decimals | Thirdeye, THIRDEYE, 18 |
| Total supply | 1,000,000,000, fixed, no mint function |
| Launch transaction | 0x66e65f6e49bf08a34cbc703df9ae6b2d4fd983a2a2068340a17a53b93589ead2, block 56,365,145, 12 November 2026 06:03:24 UTC |
| Launched by | 0xb09f37a1110a126d63463ec08a0c0b97612d90ab through the launch contract 0x660eaaedebc968f8f3694354fa8ec0b4c5ba8d12 |
| Liquidity | 200,000,000 (20%) into a Uniswap v4 pool created in that transaction, with a 0.30% pool fee and the position locked |
| Retained supply | 800,000,000 (80%) held at the token contract itself, releasable only through the contract's own release mechanism |
| Creator wallet | Holds 0 THIRDEYE. No founder allocation was distributed at launch. |
| Trading fees | Of pool fees, 95% routes to the treasury vault 0x73faf95b2baa23bde4ce8547b64c55159022cf0d and 5% to the protocol, as encoded in the launch transaction |
What the retained supply is for
The 800,000,000 at the contract is the project's long-run budget, not circulating float. Its purpose is to pay for what a platform like this needs and cannot fund from margin: development and operations, community and partner programmes, promotional allocations and airdrops to users. The binding record of how and when it can move is the contract's release schedule, not this page. A reader who wants to know what can be released today should read the contract, because a document cannot override it and this one does not try.
What it is not
It is not equity, a share of a company, a claim on the treasury, or a promise of profit. The platform does not commit to buy it back, to support its price, or to distribute revenue in it. Holding it confers no governance right today. It is a token for using and being paid inside one platform, and should be treated as such.
9. Disclosure
A token attached to a product creates a conflict of interest, and the honest response is to say so in the same place the token is described.
- Value described here is denominated in dollars, not in the token. A figure that is $X of revenue stays $X when the token price moves.
- Revenue, profit and token value are reported separately and never merged. Platform revenue is billed consumption minus provider cost; the token is not counted as revenue when received, and not as profit until swapped.
- The platform publishes what is measurable and declines to publish what is a guess. Where a number
here disagrees with the chain or with
/api/v1/models, they are right and this page is wrong.
10. Roadmap
Direction, not commitment. Items move; the changelog and the status page are where delivered work is recorded.
| Area | Direction |
|---|---|
| Billing integrity | Deposit finality hardening (confirmations, reorg handling, duplicate detection), ledger invariants, and an operator discrepancy report that reconciles provider cost against billed credit. |
| Reliability | Model rotation when a provider rate-limits, so a scheduled run degrades to another provider instead of failing the day. |
| Settlement | Wider stablecoin support on Base, and a published policy rate for crediting the platform's own token as a deposit, bounded by liquidity. |
| Agents | Deeper identity: reputation built from measured uptime and disputes, and bounded spending policies for x402 callers. |
| Assurance | Provider-neutral acceptance tests run against production, and an external review of the money paths before volume grows. |
11. Risks
Stated plainly, because a whitepaper that lists only opportunity is advertising.
- Early software. The platform is young and its money paths have been corrected more than once. Bugs can cost credit, and the ledger has needed repair before.
- Provider dependency. Inference is bought from third parties on free or metered tiers. A provider can change its limits, prices or terms, and calls will fail or cost more when it does.
- Thin market. The token's only price is what a single pool quotes against a shallow float. A price read from that pool is easy to move and is not a valuation.
- Unaudited code. Neither the platform nor the token contract has had an external audit. The token is a minimal-proxy clone launched through a launchpad factory, so its implementation and constructor arguments are what that factory chose.
- Regulatory exposure. Tokens and stablecoins sit in an unsettled legal area in most jurisdictions, and availability of any feature can change on legal advice.
- Key custody. If you deposit from an account you do not control, or attach a provider key to the platform, the failure modes are yours to reason about.
12. Verification
Everything below answers without trusting this document.
| Claim | How to check it |
|---|---|
| Supply, balances, release state | Read totalSupply() and balanceOf() on basescan.org/token/0xA8A65A86E01D227Dbfd7C7a94d14344b33603df5 |
| Launch, pool and fee routing | The launch transaction above, decoded: the pool creation, the 200,000,000 transfer and the fee split all appear in its logs. |
| Catalogue and prices | GET /api/v1/models, unauthenticated and live. No stale copy is kept. |
| Deployed version | /status prints the commit the running build came from and the size of the test suite at that commit. |
| What changed and when | /changelog, generated from the commit history rather than written by hand. |
| Source | github.com/hakuramasam/thirdeye-ai |
Colophon
Written and maintained by the Thirdeye AI operating team and its platform agent, and reviewed by the project owner before publication. This version replaces no earlier whitepaper, because there was none. Earlier internal tokenomics drafts described a launch venue that was not the one used, and are superseded by the launch record above.
Nothing here is financial, investment, legal or tax advice. Numbers describing the deployed system were read from it; numbers describing the future are labelled as direction. Corrections are welcome at the contact address on the site and are applied in place, with the change recorded in the changelog rather than quietly removed.