With smart contracts increasingly dependent on AI, Truebit provides proven integration that you can trust.
A few years ago, “offchain dependency” mostly meant a price feed. Today it increasingly means something much harder to pin down: a call to an AI model, a multi-step workflow spanning several APIs, a judgment call that has to be made by something smarter than a price oracle but still needs to be provable onchain. The old playbook — trust a whitelisted operator, trust a black-box process, trust that nothing went wrong between the API call and the callback — doesn’t hold up once real money and real autonomy are on the line.
When a prediction market needed to scale
Consider one Truebit client, a permissionless, AI-settled prediction market: anyone can create a market, define its outcomes and data sources, and let an AI model determine the winner and trigger payouts automatically. The ambition is a fully open platform, but “fully open” and “settled by a black box” don’t mix. Some markets rely on a whitelisted set of trusted creators who run the settlement model themselves. That’s a reasonable way to bootstrap a platform, but it is not a way to scale one.
To go fully permissionless, settlement had to become automated, verifiable, and trustless all at once, with no human in the loop and no need to take a central operator’s word for what the model actually said.
Truebit Verify closes that gap. Truebit provides verifiable offchain computation: the ability to prove, cryptographically, that a specific computation happened in a specific way — that a particular model was called with a particular prompt and returned a particular result, with a receipt to show for it. In this case, a Truebit Dynamic Oracle watches for a market entering its settlement stage and automatically kicks off the settlement workflow — no manual trigger, no trusted intermediary standing in the loop.
It’s worth being precise about where Truebit fits, because a robust architecture often requires multiple verification paths. Commercial frontier models are non-deterministic. Calling these models a second time with the same prompt generally yields a different answer which means that you can’t prove an inference after the fact by repeating the prompt call. While there’s no winding the clock back, Truebit Verify gives you the capability to cryptographically prove historical API results.
Proving independence, not just correctness
Here’s the detail that makes this more than a technical footnote: the call itself is executed by infrastructure that the platform operator does not control.
Settlement calls to frontier LLMs run inside Truebit’s API Tasks, executed within a Trusted Execution Environment, with every exchange captured in a transcript — the exact prompt sent, the exact response returned, attested to by a system outside the application’s control. That matters because a skeptical trader’s natural question is whether the party with the most at stake in an outcome could have shaped it — nudged a prompt, cherry-picked a response, or quietly retried until the “right” answer came back. Because the execution happens on independent infrastructure and produces a verifiable record of the whole exchange, that question has a concrete answer instead of a reassurance. Settlement isn’t just correct — it’s backed by a receipt nobody had the opportunity to edit.
That’s the difference between an oracle you’re asked to trust and one you’re able to check.
One pattern, reusable everywhere
The prediction market is a sharp example, but the underlying pattern isn’t specific to one use case. Any smart contract that needs to act on an AI judgment, a private API response, or a multi-step offchain workflow runs into the same problem: how do you get a result onchain without asking everyone to simply trust the process that produced it?
The pipeline Truebit uses to solve this is straightforward to describe and general enough to apply almost anywhere:
- A Dynamic Oracle is the onchain trigger. It watches for a condition and kicks off offchain execution without requiring a human, or a trusted server, to be watching.
- Orchestration breaks that execution into an explicit, inspectable workflow rather than one opaque black-box call — fetch this, pass it here, call that model, compare the results.
- API Tasks handle the external dependencies — calls to AI models, private APIs, or other Web2 systems — each one executed and attested to independently, inside a TEE, with a full transcript.
- Function Tasks run the deterministic logic that turns those inputs into a decision — the actual rule being applied, executed across multiple verifier nodes, also transcript-backed.
Every step in that chain produces its own cryptographic receipt. The result isn’t one verdict you’re asked to accept — it’s a chain of individually checkable steps, each with a record of exactly what happened.
How Truebit’s pieces fit together
It’s easy to encounter Truebit through just one of these pieces — maybe you’ve seen the API Tasks documentation for securely calling a private API, or come across Dynamic Oracles as a way to trigger offchain computation from a contract. Those are real, standalone capabilities. But the more interesting story is how they compose.
Dynamic Oracles are the front door — the onchain event that starts things moving. Orchestration, built on tools like n8n, is the connective tissue that turns a single trigger into a multi-step workflow instead of a monolithic call. API Tasks are where the outside world — AI models, private data, other services — enters the picture, each interaction independently verified. Function Tasks are where judgment actually gets applied, deterministically and auditably. And underneath all of it, Truebit’s Audit Layer and transcript system tie every step together into one durable, portable record: what was called, what it returned, what logic was applied, and when.
That’s the shift worth internalizing: Truebit isn’t a single verification primitive bolted onto a contract. It’s an integration and orchestration layer that happens to make every hop along the way provable.
Why this Is the pragmatic choice
The industry is already converging on the idea that agentic applications need a standardized way to prove their offchain work — Ethereum’s ERC-8004 standard, for instance, defines exactly this kind of validation concept for AI agents operating onchain. That’s a useful signal: the problem Truebit solves today is the same problem the broader ecosystem is now writing standards around.
But standards describe the shape of the problem, they don’t do the work. The alternative to a platform like Truebit is rolling your own: standing up offchain servers, writing your own attestation logic, hoping your audit trail holds up if anyone asks hard questions later. That path is exactly where the failure modes tend to show up — opaque computation nobody can inspect after the fact, integration friction that slows every new dependency to a crawl, and audit trails that don’t exist until someone needs them and discovers they were never built.
AI-settled platforms don’t need just a theoretical framework; they need permissionless settlement they can actually ship. Truebit’s Dynamic Oracle, orchestration, API Tasks, and transcripts end to end are what lets a project take a manually-gated process and make it fully automatic without giving up trustlessness in the process. That’s the pragmatic test for any verification layer: not whether it’s elegant, but whether it lets you ship the thing you couldn’t ship before.
Try it
If your smart contract has an offchain dependency you’re currently trusting rather than verifying — an AI call, a private API, a multi-step workflow — that’s the exact problem this pipeline was built for.
