Ritual Testnet Stats: Week 7
This week feels like a good moment to stop asking the easy question.
The easy question is:
which primitive is winning?
HTTP is first at 31.9%. Sovereign Agent is second at 30.9%. Long-Running HTTP is third at 15.8%.
So the lazy read would be: HTTP is back on top.
But I think that misses the more interesting part.
These numbers do not look like primitives competing with each other. They look like division of labor.
HTTP is not beating agents. It is feeding them context.
Sovereign Agent is not replacing HTTP. It is becoming the execution surface around that context.
Long-Running HTTP is not just a slower API call. It is the admission that useful work often refuses to fit inside one instant response.
That is the Week 7 signal for me.
Ritual is starting to look less like a collection of features and more like a small economy of work.
Some work needs context. Some work needs agency. Some work needs time. Some work needs settlement. Some work still needs normal EVM execution underneath.
And the testnet is starting to show all of those layers moving at once.
EIP-1559 is 39.05%, which means the normal EVM base is still alive and important. That is good. A chain that only shows exotic activity can be misleading.
Builders still need boring transactions: deployments, contract calls, testing, state changes, basic interactions.
That is the ground layer.
But the rest of the activity bends away from normal EVM behavior.
Scheduled is 13.82%. Async Commitment is 23.90%. Async Settlement is 23.23%. Async adoption is 47.13%.
So almost half of the window is async.
Not a small side experiment. Not a decorative AI layer.
Almost every second transaction is part of work that has phases.
A normal transaction has a simple shape:
send, execute, done.
Ritual keeps showing a different shape:
start, wait, commit, settle, return.
That shape matters more than the raw percentage. It means builders are testing time, delay, external context, and callbacks as first-class parts of applications.
This is where Ritual watch awesome .
Not it has AI. Many projects have AI.
Ritual is i the network is slowly teaching builders to think in workflows instead of moments.
The scheduled jobs number makes this clearer.
Active scheduled jobs: 207.
That might be one of the most important numbers this week.
A scheduled job is basically a promise to the future. It says: not now, but later.
That sounds simple, but most dApps are terrible at “later.” They depend on keepers, bots, servers, dashboards, scripts, or users coming back and clicking again.
Ritual makes “later” part of the execution environment.
For agents, that is huge.
An agent that only acts when a user pokes it is not really an agent. It is a button with better branding.
A useful agent needs to return, check again, wait for a condition, retry, follow up, and continue after the user leaves.
So when scheduled jobs rise, I do not read it only as more automation.
I read it as the beginning of persistent behavior.
The network is not only processing transactions.
It is holding intentions.
The mempool snapshot is also very Ritual-looking.
Pending transactions are at 0. Scheduled pool is at 1. Async pipeline is at 33. Base fee is 7 wei.
The normal pending queue is empty. The network is not congested. But the async pipeline is alive.
That tells us something subtle: the interesting work is not always visible in the place crypto users are used to watching.
On a normal chain, people look at pending transactions and gas.
On Ritual, you also have to look at the pipeline.
That is where delayed work lives. That is where the workflow is still breathing.
This is also a UX warning for builders.
If you build a Ritual app like a normal dApp, you will probably make it feel broken.
Normal dApp UX mostly says pending or confirmed.
Ritual apps need more language: submitted, committed, polling, waiting, settling, delivered, expired, failed.
The app has to explain where the work is, not only whether the transaction landed.
That is not a small frontend detail.
It is the difference between a user trusting the workflow and a user thinking nothing is happening.
The precompile table also says something healthy about the testnet.
LLM Call is only 4.7%.
That surprised me in a good way.
If Ritual were only attracting people who want to spam AI onchain, LLM would probably be much higher.
But the top of the table is HTTP, Sovereign Agent, and Long-Running HTTP.
That means builders are not only testing model calls. They are testing the plumbing around intelligence.
Context. Agents. Longer external work.
That is healthier.
A model call is only one part of the loop. Before the model can reason, it needs context. After it reasons, something has to execute. If the task takes time, something has to wait. If the result matters, something has to settle. If access is needed, something has to handle keys and secrets.
That is why DKMS at 5.7% is worth noticing too.
It is not the loudest number, but it is a serious one.
DKMS is the kind of primitive people ignore until they try to build something real. Then they realize agents need permissions, credentials, private access, and controlled secrets.
Without that, agents stay in demo land.
With it, they can start touching real workflows.
So the Week 7 distribution feels more grounded than flashy.
HTTP is context. Sovereign Agent is execution presence. Long-Running HTTP is patience. DKMS is access. LLM is reasoning. Async is lifecycle. Scheduler is future intent. EIP-1559 is the EVM base.
That is not random activity.
That is the outline of an operating environment.
The agent numbers add another layer: 33 Persistent and 17 Sovereign agents. At first glance, that might look smaller than expected. But Sovereign Agent is still 30.9% of precompile usage.
So the story is not only how many agents are registered.
The story is how much the agent path is being used.
A network can have many registered objects and no meaningful activity. Here, the agent primitive is sitting almost equal with HTTP at the top of precompile usage.
That suggests the testnet is not only collecting agents.
It is exercising them.
The validator and block data give the base layer context. The explorer shows fast block times, low pending activity, active validators, and mixed usage moving through the same environment.
I would not turn these live windows into final benchmarks. They are snapshots. They move quickly.
But they show one thing clearly:
the network is handling mixed activity without looking stuck.
Normal transactions. Scheduled jobs. Async commitments. Async settlements. HTTP calls. Agent calls. Long-running tasks.
All of that is moving inside the same environment.
That matters more to me than one headline number.
Week 7 is not about a single metric exploding.
It is about role separation becoming visible.
Earlier weeks felt like discovery. Builders were poking primitives: HTTP here, agents there, async somewhere else.
Now the activity starts to look more like a system.
HTTP is the sensory layer. Long-Running HTTP is patience as infrastructure. Scheduler is intent placed into the future. Async is the lifecycle of work. Agents are execution participants. EIP-1559 is still the familiar base underneath it all.
That may be the most important point.
Ritual does not look like it is trying to delete the normal chain model.
It looks like it is extending it.
Normal transactions are still the ground. Around them, another kind of application logic is forming.
Logic that can see outside, wait, return, settle, use agents, handle access, and move through phases.
That is why Week 7 feels meaningful.
Not because the testnet is already mature. It is not.
Not because the numbers are huge. They are still early.
But because the pattern is becoming harder to dismiss.
Ritual is not only testing whether AI can be put onchain.
It is testing whether blockchains can become environments for work that does not finish instantly.
That is a much bigger idea.
Most real work is not instant.
Markets wait for signals. Agents wait for context. Users wait for results. Apps wait for external systems. Risk engines wait for conditions. Automation waits for time.
The old chain model compresses everything into one moment.
Ritual is experimenting with a chain model where work can have a process.
That is the deeper Week 7 signal for me.
The network is not just producing blocks.
It is starting to show a grammar.
Context. Agency. Time. Access. Settlement. Return.
If that grammar keeps developing, Ritual apps will not feel like normal dApps with AI sprinkled on top.
They will feel like workflows that happen to settle onchain.
And that is a interesting future.
Not only transactions.
The beginning of workflow-native crypto.
Check:
explorer.ritualfoundation.or…
@ritualnet
@ritualfnd
Ritual Testnet Stats: Week 6
This week I do not want to start with precompiles.
I want to start with something quieter:
the pulse of the network.
The explorer is showing 128 recent blocks, about 4.3 minutes of live history.
Average gas usage is 341,397 per block.
Average block size is 15.89 KB.
Average block time is 0.31s.
These are short live windows, so I would not treat them as final benchmark numbers.
But they are useful for another reason.
They show motion.
Gas is not flat. Block size is not flat. Execution is arriving in bursts.
That is what a live testnet should look like.
Not a perfectly smooth demo.
A moving system.
Latest Transactions show around 2.1 transactions per block. On its own, that number does not say enough. The better question is not only how many transactions?
The better question is:
what kind of activity is creating the pulse?
That is where the Agent Transactions page becomes useful.
Average agent transactions are at 1.1 per block. There are 58 registered agents. In the current window, the agent activity is mostly Heartbeat and Sovereign transactions.
The heartbeat number is the one I like.
Heartbeat is not flashy. It does not sound like a big AI moment.
But for agents, heartbeat is a sign of life.
A normal bot answers and disappears. An agent needs to keep existing. It needs to be monitored, reachable, and visible over time.
So when the explorer starts showing agent heartbeats as part of network activity, Ritual feels less like a place for one-off demos and more like a place where agents can have presence.
That is a different kind of signal.
Async activity tells the same story from another angle.
Total async is 44, with 17 commits and 27 settlements.
The split matters more than the total.
Work is not only being started. It is also coming back.
For an agent environment, that matters. Useful work often does not finish in the same instant it begins. Something gets picked up, something runs, and something returns.
Week 6 gives a nice operational view of that.
The machinery is visible.
The scheduled pool is almost empty right now: 0 active scheduled jobs, 1 total in pool, and 1 completed recently.
At first, that sounds small.
But the example still matters: frequency of 10 blocks, TTL of 30.
That is Ritual’s time layer in miniature.
A task can be placed into the future. Not every action needs to happen now.
For agents, that matters a lot.
They need more than instant response. They need timing: check later, return after a delay, try again, continue when the condition is ready.
Even one scheduled job is a reminder that Ritual apps can be designed around time, not just clicks.
The mempool adds another small clue.
Pending transactions are at 0. Scheduled pool is at 0. The async pipeline shows 10. Base fee is 7 wei.
That is a clean snapshot.
No visible pending congestion. Tiny base fee. But the async pipeline is still alive.
That tells me the interesting work is not always sitting in the normal pending queue.
Some of it lives in the workflow layer.
That matters for builders.
If you build on Ritual, your app should not only watch transaction status. It should watch process status.
A user should not be stuck with loading. They should know whether the work is waiting, committed, settled, delivered, expired, or failed.
That may become one of the biggest UX differences between normal dApps and Ritual apps.
The validator screen gives the base layer context: 33 validators, 33 active proposers, and 348 blocks analyzed in the last minute.
That is the foundation underneath all of this.
So Week 6 is not about one primitive winning.
It is about the system showing its pulse.
Blocks are moving. Gas and block size are uneven. Agents have visible activity. Async work has both commits and settlements. Scheduler is present as a time layer. The mempool is calm, but the async pipeline is alive. Validators are keeping the base rhythm going.
That is the story I take from this week.
Ritual testnet to look less like a page of features and more like an operating environment with different kinds of motion.
Some motion is immediate.
Some motion is delayed.
Some motion is agent-driven.
Some motion is async.
Some motion is just the base chain breathing underneath
A network with a pulse.
Check:
explorer.ritualfoundation.or…
@ritualnet
@ritualfnd