Ritual in 2026: The Chain Built for Agents That Act Alone

Most blockchains that talk about artificial intelligence bolt it on from the outside. An oracle fetches a model’s answer, a token points at a rented GPU somewhere, and a governance forum argues about whether any of it is decentralized. Ritual is trying something more literal. Its pitch, printed on its own testnet announcement, is that the chain was “built specifically for AI agents” and is “Not ‘AI-adjacent.’ Actually AI-native” (Ritual Foundation on X). The slogan sounds like marketing. Under the hood it describes a genuinely unusual design: a Layer-1 where a smart contract can call a language model as a native operation, schedule its own future execution without a helper bot, hold its own keys, pay its own bills, and keep running until the money runs out.

As of September 2026 that design lives entirely on a public testnet. There is no mainnet date, and there is no tradeable RITUAL token, a fact worth stating up front because a speculative farming economy has grown up around one that does not exist. What Ritual does have is a working chain, a coherent thesis about what an agent-native blockchain should offer, and a set of choices that read like a direct answer to the question every autonomous-agent project keeps dodging: where, exactly, is the agent supposed to live? This piece walks through the architecture with agents as the organizing lens, then asks the harder questions, whether an agent really needs its own chain, what a future token would face from the SEC, and how much of the current excitement is real.

Ritual’s bet: a chain where agents are first-class citizens

Start with how an on-chain AI agent normally works today. It is an off-chain program, usually Python, running on a server you rent. It holds a private key in an environment variable, keeps its memory in a database, waits on a cron job or a keeper service to wake it, calls a model API over the internet, and then pokes the blockchain through an RPC endpoint to sign a transaction. The chain never sees the model, the memory, the schedule, or the reasoning. It sees a signed payload and nothing else. Everything that makes the agent an agent lives somewhere the chain cannot verify or enforce.

Ritual inverts that arrangement. Inference, scheduling, persistent memory, key management, and payment are meant to be chain-level primitives rather than external services. On Ritual, agents call language models, classical machine-learning models, and generative models as native operations, with prompts and responses handled inside secure enclaves and results settling on-chain in the same transaction, according to the project’s developer documentation. The claim is not that Ritual runs the best models; it is that the chain itself understands what an agent needs to do and gives it the plumbing. Whether that plumbing justifies a whole new Layer-1 is the argument this article keeps returning to, but the ambition is clear enough: make the agent a citizen of the chain, not a stranger phoning in from outside.

Put concretely, first-class means the chain has opinions about agents. It has a transaction type for the way an agent authenticates, a system contract for the way an agent schedules itself, precompiles for the way an agent thinks, and account types for the way an agent persists. On a general-purpose chain, all of those are things you build on top, badly or well, and they differ from one project to the next. On Ritual they are meant to be standardized primitives, which in principle makes agents composable: one agent can call another, read its state, or pay it, because they share the same substrate. That composability is the upside the whole design is chasing.

From a $25 million seed to a public testnet

Ritual was founded in 2023 in New York by Niraj Pant and Akilesh Potti, who had spent roughly three years together at the crypto fund Polychain Capital. Pant came from the investing side, with early exposure to projects like EigenLayer and Solana; Potti is a machine-learning researcher who had worked as a quant at Palantir. The company announced a $25 million seed round on 8 November 2023, led by the crypto venture firm Archetype, with Accomplice and Robot Ventures among the backers, as first reported by CoinDesk. The Block later reported total funding north of $30 million.

Ritual’s founding argument was about concentration. “The consolidation of AI among a small group of powerful companies poses a significant threat to the future of technology,” Pant said at the time, framing the project as a way “to end the ecosystem’s reliance on the few.” The first product was Infernet, a decentralized oracle network and lightweight software kit that let existing EVM contracts on Ethereum, Base, and Arbitrum call AI models without moving anywhere. In November 2024 the team went further, launching the Ritual Chain testnet and establishing the Ritual Foundation. Potti told The Block that the testnet “enables entirely new user behavior that wasn’t possible in any other system today for interacting with AI,” and cast the chain as a foundation for prover networks and other services, not just a model host. By 2026 that had matured into a public testnet, chain ID 1979, with block times around 350 milliseconds and a growing set of agent-specific features.

Ritual did not build in isolation. Through 2024 it lined up the pieces a compute-heavy chain needs: a data-availability arrangement with Celestia, a coprocessor tie-up with Arbitrum, GPU supply through the decentralized provider io.net, and an integration with EigenLayer so restaked operators could serve inference and proving work. A separate collaboration with Nillion targeted blind inference, where both the user’s input and the model’s weights stay encrypted during a computation. None of these turned Ritual into a finished product, but together they sketched the shape of the network the team was aiming for: a chain that orchestrates outside compute rather than trying to own all of it.

“AI-native, not AI-adjacent”: what the slogan means

The line is doing more work than a normal tagline. Ritual’s claim is that the handful of things an autonomous agent needs are all built into the chain as primitives, rather than stitched together from off-chain tools. Read charitably, the design gives an agent seven capabilities that the chain itself provides:

• Think: call language, vision, and classical models through dedicated precompiles instead of an external API.
• Act: send transactions and call other contracts, the ordinary EVM surface.
• Remember: keep state and long-term memory on-chain, backed by data-availability references.
• Prove: attach a verification method so others can trust the computation ran correctly.
• Keep secrets: hold API keys and private inputs encrypted, revealed only inside a secure enclave.
• Pay: fund itself from its own wallet and settle for compute and services on-chain.
• Authenticate: sign with passkeys and standard credentials, understood by the chain natively.

The contrast Ritual is drawing is with the off-chain script model, where six of those seven capabilities live on a server the chain cannot see. Whether every one of these is better as a chain primitive is debatable, and some read more like convenience than necessity. But taken together they explain the positioning: the project is not selling GPUs or a model marketplace, it is selling an execution environment where an agent can exist and operate without a human babysitting a process.

Inside EVM++: precompiles, sidecars, and two paths through one state

The technical foundation is what Ritual calls EVM++, a backwards-compatible extension of the Ethereum Virtual Machine. Ordinary Solidity contracts work as they would anywhere, and developers use familiar tools. On top of that, EVM++ adds expressive compute precompiles (special addresses that expose heavy operations like model inference, ZK proving, HTTP calls, and more), plus sidecars, which are execution environments that run demanding work outside the main execution client. The documented sidecar categories cover classical machine learning and language-model inference, zero-knowledge proving and verification, trusted-execution-environment code, and chain abstraction. Native scheduling, enshrined oracles, and account abstraction round out the additions. The public testnet exposes more than a dozen precompiles across these functions.

The most important design idea is what Ritual calls Superposition: two execution paths over one shared state. Cheap deterministic work runs the replicated way, where every validator re-executes the operation and must agree, exactly as normal blockchains do. Heavy or non-deterministic work, above all language-model inference, runs the delegated way, off-chain inside a trusted execution environment, with the response cryptographically bound to the request so the chain can accept it without re-running it. This split is the whole trick behind an on-chain inference call that does not choke the network. It also puts Ritual squarely inside a debate the wider sector is having about how decentralized GPU inference actually works in practice, a topic HOGE Wire has covered in detail in Decentralized Inference in 2026: What Happens Under the Hood. Ritual’s answer is to keep the settlement and verification on-chain while the raw compute happens beside it.

Two related mechanisms sit underneath. Because the work an agent asks for ranges from a trivial arithmetic check to a heavyweight language-model call, Ritual prices execution through a two-sided fee market it calls Resonance, matching demand for compute against nodes with very different hardware rather than charging a single flat gas rate. A consensus layer it calls Symphony lets a subset of nodes execute an operation once and emit succinct evidence that others can check, instead of forcing the entire validator set to redo expensive work. The design goal throughout is to let heterogeneous, costly compute live on a chain without every node paying for every calculation, which is the constraint that has kept serious AI off general-purpose blockchains until now.

Persistent vs Sovereign agents: two ways to live on-chain

Ritual splits agents into two models, each backed by its own precompile. A Persistent Agent (address 0x0820) is a stateful presence: the documentation describes it as having “soul, memory, identity, and data availability references,” and says it “persists across sessions,” so it can be restored in full from a stored snapshot. It runs on a heartbeat and needs a small RITUAL balance, on the order of 0.1, to cover those recurring transactions. Think of it as a long-lived assistant that remembers you between conversations.

A Sovereign Agent (address 0x080C) is closer to a self-running job. It holds its own keys, uses the on-chain scheduler to wake itself at intervals, and on each wake invokes a full command-line harness inside a sandboxed secure enclave. The documented harnesses include Claude Code, Hermes, Crush, and ZeroClaw. Crucially, it pays for each run from its own on-chain wallet and simply stops when the balance hits zero. Ritual frames this as an asynchronous agent job rather than a bot that runs around the clock. The distinction matters for anyone designing an autonomous system: a Persistent Agent is about continuity of memory and identity, while a Sovereign Agent is about unattended action with real self-custody and a hard budget.

Native scheduling: the quiet death of the keeper bot

One of the least glamorous but most consequential features is the scheduler, a system contract living at 0x56e776BAE2DD60664b69Bd5F865F1180ffB7D58B on the testnet. On other chains, any recurring or conditional on-chain action needs an external keeper: a service that watches conditions and fires the transaction when they are met. Chainlink Automation, Gelato, and homegrown cron servers all fill this role. The problem is that the keeper is a single point of failure and a hidden centralization. If the keeper stops paying its own gas, or its server dies, or its operator loses interest, the automation silently stops. Plenty of DeFi incidents trace back to a keeper that failed to fire.

Ritual enshrines scheduling in the protocol. A contract can register to be called at a future block or on a repeating cadence, and the chain itself guarantees the wake-up, with no off-chain keeper in the loop. This is precisely what lets a Sovereign Agent wake itself: the scheduler calls it, it runs its harness, it pays from its wallet, and it schedules the next wake. Removing the keeper removes a whole class of liveness bugs and a quiet dependency on infrastructure the user does not control. It is not magic, the chain still has to be producing blocks and the agent still has to be funded, but it turns automation from a service you rent into a property of the platform.

A concrete example makes the difference vivid. Suppose you want an on-chain fund that rebalances every day at a set time. On a normal chain you deploy the contract, then you also stand up a keeper that holds gas, watches the clock, and calls the contract, and you hope it never goes down. On Ritual the contract schedules itself, and the daily rebalance becomes as much a part of the chain’s operation as producing the next block. The trust you were placing in an off-chain operator moves into the protocol, where at least it is transparent and shared rather than hidden on one team’s server. That is a real reliability gain, though it also means the chain now carries workloads that used to be somebody else’s problem.

Self-custody for software: passkeys, WebAuthn, and agent wallets

If an agent is going to hold its own keys and spend its own money, key management becomes the whole ballgame. Ritual leans into modern authentication with a native transaction type it calls TxPasskey, at type 0x77, so that WebAuthn credentials, the same standard behind Face ID, fingerprint readers, and hardware security keys, can sign transactions directly. As the documentation puts it, “The chain understands WebAuthn natively.” Alongside it sit precompiles for common signature schemes and a key-management system, so an agent or a user is not forced into a single seed phrase kept in a file.

For a human, this is a nicer login. For an agent, it is more fundamental: the agent can own a credential rather than borrowing a person’s private key stashed in an environment variable, which is how most agent hacks start. That said, self-custody for software raises the stakes rather than lowering them. A key that can spend is a key that can be drained, and an agent that signs automatically is a signer that never pauses to think. The same drainer-versus-defense arms race that HOGE Wire mapped for consumer wallets in MetaMask vs Phantom vs Rabby: Can Your Wallet Stop a Drainer? applies with more force to a wallet that acts on its own. Better authentication is necessary; it is nowhere near sufficient, as the security section below spells out.

Trusting a probabilistic answer: Symphony, TEEs, and modular integrity

Here is the deep problem an AI chain has to solve. A blockchain is deterministic: every node must reach the same answer or consensus breaks. A large language model is probabilistic and, on real GPUs, not even bit-for-bit reproducible run to run. So how does a deterministic contract trust an answer it cannot re-compute? Ritual’s response is modular computational integrity: rather than one verification method for everything, the developer chooses the right proof per call. Deterministic work is simply re-executed by every validator. Model inference typically runs inside a trusted execution environment under a scheme Ritual calls Symphony, an execute-once, verify-many approach where the model runs once and the result is cryptographically bound to the request so the executor cannot fake it. Zero-knowledge and optimistic proofs are available as alternatives.

None of these is free, and the trade-offs are the whole story of verifiable AI, a tension HOGE Wire dug into in Verifiable Compute in 2026: Why Proving AI Means Picking Two. A trusted execution environment is fast and cheap but shifts trust to the chip vendor and carries side-channel risk. Zero-knowledge proofs are trustless but far too expensive for large models today. Optimistic schemes are cheap but add a challenge-window delay and assume at least one honest watcher. The industry framing here is not unique to Ritual; even Chainlink publishes its own primer on why verifiable inference matters. Ritual’s bet is that letting builders pick per call, rather than forcing one method, is the pragmatic path.

There is a deeper wrinkle no vendor fully escapes. Running a large model on GPUs is not perfectly reproducible: floating-point math and parallel execution can yield slightly different outputs on different hardware, which is exactly the property a re-execution check needs and cannot get. That is why inference leans on enclaves or proofs rather than on validators re-running it. Researchers have started to call the underlying tension a verifiability trilemma, the claim that a system cannot maximize computational integrity, low latency, and low cost all at once. Every method in the table below gives up one corner to hold the other two, which is why Ritual refuses to standardize on a single one.

Paying the machines: RitualWallet, x402, and agentic commerce

An autonomous agent that cannot pay is not autonomous. On Ritual, each Sovereign Agent draws from a RitualWallet balance that funds its scheduled runs, so the agent covers its own compute and stops cleanly when it runs dry. That local budget is only half the picture; agents also need to pay for outside services, and here Ritual plugs into a standard that took off across the industry in 2026. The x402 protocol, revived by Coinbase from the long-dormant HTTP 402 Payment Required status code, lets a service answer a request with a price and lets an agent pay in stablecoins and retry, all machine to machine. It moved from a Coinbase project into a Linux Foundation effort with backers including Visa, Mastercard, Stripe, and Circle.

The honest caveat is that agent payments remain more promise than practice. Across the sector, transaction counts run into the hundreds of millions while real economic value moved stays small, and much of the traffic is testing or signaling rather than commerce. So the Pay capability is best read as a piece of infrastructure waiting for demand rather than a proven revenue engine. What Ritual adds is that the paying party can be the agent itself, holding its own funds and settling on the same chain where it thinks and acts, which is a cleaner story than an agent quietly spending a human’s balance through an API key. Cleaner does not mean risk-free, since the same budget that funds useful work funds a compromised agent just as readily.

The wider context is that machine-to-machine payments became a genuine standards race in 2026. Beyond x402, Google shipped an Agent Payments Protocol and OpenAI and Stripe backed a checkout standard, all aimed at letting software agents transact, while the x402 effort itself moved under the Linux Foundation with card networks and stablecoin issuers signing on. The recurring lesson of that year was that the rails arrived well before the volume: agents can pay, the plumbing works, but the flood of tiny autonomous purchases everyone predicted has mostly not shown up. Ritual is betting that when it does, an agent will prefer to pay from a wallet it actually controls on the chain where it runs, rather than through a key borrowed from a human.

When agents go wrong: prompt injection and the autonomy problem

Give software its own keys, its own budget, and the ability to wake itself, and you have also built an attractive target. The defining incident of 2026 was the drain of an AI trading agent connected to the Grok assistant through the Bankr service. An attacker hid instructions in a Morse-code reply on X and used a gifted membership NFT to escalate the agent’s wallet permissions, then triggered a transfer of roughly $175,000 in tokens on Base before much of it was returned, an event catalogued in the OECD AI incident registry. The root cause was not a broken contract. It was that a language model cannot reliably tell an instruction from data, so text it reads can become a command it obeys.

This is the autonomy problem in one story, and Ritual’s primitives do not dissolve it. A TEE proves the model ran untampered; it does not prove the prompt was legitimate. A verified inference proves the computation was correct, not that the resulting action was wise. Ethereum co-founder Vitalik Buterin, in an April 2026 note on securing AI agents, argued for hard limits: cap how much an agent can move without a human co-signer, treat a person and the model as a two-of-two check on risky actions, and sandbox everything the model touches, warning that a meaningful share of the agent add-ons researchers tested carried hidden malicious instructions. Ritual’s programmable budgets, self-custody, and enclaves are consistent with that advice, and its per-agent spending limits are a real mitigation. But the semantic gap, an agent doing exactly what it was told by the wrong person, is an open problem for the entire field, not something a chain can patch alone.

For builders, the practical takeaway is that Ritual’s features change the shape of the risk without erasing it. Native budgets and self-scheduling make it easy to cap an agent’s blast radius, so a compromised Sovereign Agent can only drain what sits in its own wallet before it stops, a real improvement over an agent wired to a person’s main account. Enclaves keep an API key from leaking even when the surrounding code is hostile. But none of that stops a well-crafted prompt from talking an agent into a bad yet fully authorized action, which is why the strongest deployments still keep a human in the loop for anything irreversible and treat every external input, a webpage, a message, a tool response, as potentially adversarial.

Does an agent really need its own chain?

This is the strategic question, and it is not rhetorical. Ritual is asking builders to move to a new Layer-1. Its competitors mostly offer AI and agent infrastructure that bolts onto the chains developers already use, which is a much smaller ask. Bittensor runs a network of specialized subnets aimed at model training and remains the largest AI-crypto token, trading near $233.73 for a market capitalization around $2.24 billion as of 12 September 2026 (CoinGecko). Chainlink offers oracles, cross-chain messaging, and verifiable compute you can attach to any chain, with LINK near $11.52 and a capitalization around $8.62 billion (CoinGecko). EigenCloud, the rebrand of EigenLayer, pursues verifiable AI on restaked Ethereum, with EIGEN near $0.2148 and a capitalization around $198 million (CoinGecko). Gensyn focuses on trustless training compute. Every one of them has a live token and a bolt-on model.

Ritual’s counter is that agent-native primitives, native scheduling, self-custody, execute-once verification, on-chain memory, cannot be faithfully bolted on; they need a chain designed around them. That is a real argument, but migration is a tax, and the history of Layer-1s is littered with elegant designs that could not overcome the gravity of where developers and liquidity already are. Whoever runs Ritual’s validators will also have to be paid to secure inference and settlement, an economics question HOGE Wire examined for chains generally in Validator Economics: Who Pays to Secure a Blockchain in 2026? The bet only pays off if agent-native features prove valuable enough to pull builders across.

The token that does not exist (yet)

It bears repeating because the confusion is lucrative for scammers: there is no tradeable RITUAL token. The RITUAL that appears on the testnet is an 18-decimal gas token with no monetary value, used to pay for test transactions and agent heartbeats. There is no confirmed airdrop, no announced token generation event, and no exchange listing. And yet a full farming economy has assembled around the possibility of one. Third-party guides walk users through joining the Discord, collecting themed roles, and referring friends to chase a future allocation, even as several of those same guides admit, in their own fine print, that no official airdrop has been announced and that any price figures are pure speculation.

Treat that gap as a hazard. Where an expected token does not exist, counterfeit ones appear: fake $RITUAL listings, phishing sites promising a claim, and drainer pages dressed up as an official portal. The safe posture is simple. There is nothing to buy, nothing to claim, and no legitimate sale, so anyone selling RITUAL or guaranteeing you an allocation is running a scam. The more interesting question is why a well-funded project with a live testnet has not rushed to issue a token when the market would happily bid one up. Part of the answer is that Ritual is still pre-mainnet and pre-decentralization. The other part is regulatory, and it is worth taking seriously.

What a future RITUAL token would face from the SEC

If Ritual ever issues a token to United States participants, it lands in the middle of the most active period of crypto rulemaking in years. On 18 August 2026 the SEC, under Chair Paul Atkins, proposed Regulation Crypto Assets, described as the agency’s first formal crypto-specific fundraising framework in its ninety-year history. The proposal sketches tiered exemptions for token offerings and, most relevant to an infrastructure project, a conditional safe harbor. In announcing it, Chair Atkins tied a token’s exit from investment-contract status to the moment an issuer “has completed or permanently ceased all essential managerial efforts.”

The tiers matter for a project of Ritual’s size. The framework contemplates a smaller exemption for early-stage raises and a larger one, with fuller disclosure and ongoing reporting, for bigger offerings, a structure meant to let a genuine startup raise capital without a full securities registration while still giving buyers something to read. It pairs that with the safe harbor that lets a sufficiently decentralized token step out of securities treatment once the issuer’s ongoing efforts are no longer what gives the token its value. For a team still building the network and still holding the keys to it, the rational move under these rules is precisely what Ritual is doing: wait.

Read against Ritual’s situation, that language is almost a checklist for why waiting is rational. A still-centralized, still-testnet project run by an active founding team is, by definition, still exerting essential managerial effort, which is exactly the condition the safe harbor says a token must outgrow. Launching now would invite the securities-law risk the framework is designed to let projects avoid later. The legislative backdrop is murkier: the CLARITY Act, which would divide oversight between the SEC and the CFTC, faces a Senate cloture vote on 15 September 2026 that needs sixty votes, and its prospects look poor, tangled in unresolved ethics language and given long odds by prediction markets, as CNBC reported at the start of the month. For builders and would-be token holders, HOGE Wire’s guide to the agency’s posture, The Tip Line Is Still Open: SEC Crypto Enforcement in 2026, is the practical companion to this uncertainty. The near-term reading is that a cautious project has every reason to keep its token theoretical.

The outlook: what is real, what is not, and what to watch

Set the hype aside and the balance sheet is legible. What is real: a working public testnet with sub-second blocks, a coherent and genuinely agent-first design, a credible team with real funding, and a set of features that plug into standards the wider industry is converging on, from WebAuthn authentication to x402 payments. Ritual has thought harder than most about what an agent actually needs to exist on-chain, and the Persistent and Sovereign agent models are a more concrete answer than the vague autonomy pitches that dominate the sector.

What is not real yet: there is no mainnet and no date for one, no tradeable token, and no flagship production application operating at scale that would prove the design in the wild. Verification still forces a choice among cost, latency, and trust, and agent security, the risk that an autonomous signer does the wrong thing because it was told to, is an unsolved problem across the whole field, not one Ritual has cracked. So the honest watch-list is short and specific. Look for a credible mainnet timeline, a named production dApp with real users, a token model that fits the SEC’s new rules rather than fighting them, and, above all, evidence that agent-native primitives actually pull builders off the chains where they already live. Until then, Ritual is one of the more thoughtful bets in AI crypto, and still a bet, on the idea that the software agents everyone is racing to build will eventually want a home of their own.

Frequently Asked Questions

Does Ritual have a token I can buy?

No. As of September 2026 there is no tradeable RITUAL token and no confirmed airdrop. RITUAL exists only as an 18-decimal testnet gas token with no monetary value. Treat any site selling $RITUAL or promising a guaranteed airdrop as a scam.

What is the difference between a Persistent Agent and a Sovereign Agent?

A Persistent Agent (precompile 0x0820) is stateful, keeping memory and identity across sessions through data-availability references, and needs a small RITUAL balance for heartbeat transactions. A Sovereign Agent (0x080C) holds its own keys, uses the on-chain scheduler to wake itself, runs a command-line harness inside a secure enclave, and pays for each run from its own wallet until the funds run out.

What makes Ritual “AI-native” rather than just another AI-crypto project?

Ritual builds inference, scheduling, persistent state, key management, and payment in as chain-level primitives, so a smart contract can call a model, schedule itself, hold keys, and pay bills without off-chain infrastructure. Most projects treat the agent as an off-chain script that only signs transactions, leaving everything that matters where the chain cannot see it.

Is Ritual live on mainnet?

No. Ritual runs a public testnet (chain ID 1979, with block times around 350 milliseconds) and has not announced a mainnet date. Its first product, the Infernet oracle network, lets existing EVM contracts call AI models, but the sovereign Ritual Chain itself is not yet in production.

How does Ritual verify that an AI answer is correct?

It uses modular computational integrity, choosing a method per call. Deterministic operations are re-executed by every validator, while model inference typically runs inside a trusted execution environment whose result is cryptographically bound to the request, with zero-knowledge and optimistic proofs available as alternatives that trade cost against latency.

By Marcus Okafor, senior AI and crypto correspondent at HOGE Wire.