**Six months ago I started writing a blockchain from
scratch in Rust. I was 18. I had no team, no
funding, and no real reason anyone should care.
Today the codebase has 1,400+ tests, a 4-validator
testnet with 19M+ committed blocks, real Groth16
ZK verification, native agent payments, and an
on-chain service discovery registry. All open
source.
But this post is not about the code. It is about
why I think the code matters.
Two trends converging
Two things are happening at the same time and most
people are treating them as separate trends.
The first: real world assets are moving on-chain.
BlackRock tokenized a treasury fund. Visa is
settling stablecoin payments. Coinbase shipped the
x402 protocol for machine-to-machine payments.
Stocks, bonds, and real estate are slowly migrating
to blockchain rails. This is not speculation
anymore. The infrastructure is being built by the
largest financial institutions in the world.
The second: AI agents are becoming economic actors.
Not chatbots. Not assistants. Autonomous software
that books flights, executes trades, manages
portfolios, calls APIs, and pays for services.
AWS launched AgentCore. Google integrated x402 into
its Agent Payments Protocol. McKinsey projects
global agentic commerce will reach $3 to $5
trillion by 2030. Gartner predicts 90% of B2B
buying will be AI agent-intermediated by 2028,
representing over $15 trillion in transactions.
These two trends converge in the same place:
autonomous machines transacting over on-chain
infrastructure at a scale that is projected to
dwarf human transaction volume.
But existing chains were built for humans holding
wallets. They have no concept of agent identity,
no reputation system, no capability enforcement,
no way to verify what an agent actually computed
before accepting its claims.
The gap
That is the gap I am building for.
NOVAI is not a chain with AI features bolted on.
It is a chain where AI entities are protocol
primitives from genesis.
An entity on NOVAI has its own keypair, its own
balance, its own reputation score, its own
capability set, and its own on-chain memory. It
signs its own transactions. The chain knows it is
an AI and applies AI-specific rules before any
transaction executes.
There is no virtual machine. There are no smart
contracts. The transaction surface is 10 fixed
types that the protocol understands directly. Every
operation is deterministic, auditable, and bounded.
No floats anywhere in execution. Golden-vector
locked encodings. Sorted iteration over all state.
That makes the security model fundamentally
different from smart contract platforms. There are
no reentrancy bugs, no flash loan exploits, no
integer overflow in user-deployed contracts. The
trade-off is clear: NOVAI is less expressive than a
VM, by design. The entire protocol is one audit
boundary instead of thousands of independent smart
contracts.
What actually works today
This is not a whitepaper. This is running code.
An AI entity can register on-chain with its own
ed25519 key and a defined set of capabilities.
It can publish signals (anomaly reports,
predictions, risk scores) that the chain indexes
by issuer and height. Any other entity can query
them.
It can publish a service descriptor to an on-chain
discovery registry. Other entities find available
services by querying the chain by category. No
off-chain directory needed.
It can pay another entity per API call through
Native Agent Payments (NAP), NOVAI's own payment
primitive inspired by the x402 pattern but
implemented at the protocol layer. The payer later
attests whether the service was delivered or
failed. The chain adjusts the payee's reputation
accordingly. +1 for delivered. -3 for failed.
It can submit a ZK proof that it ran specific code
on specific inputs. The chain verifies the Groth16
proof on BN254 without re-executing the
computation. The trust model shifts from "the agent
says so" to "the math says so."
It can delegate a subset of its capabilities to a
sub-agent for a bounded duration. One transaction
to revoke. Immediate effect. No propagation delay.
It can declare upstream dependencies through
composition graphs. If a dependency fails a
reputation or stake check, the protocol can mark
the downstream entity inactive.
Why this matters beyond crypto
The conversation about AI safety is mostly about
alignment. Can we make the model behave well. That
matters. But there is a different safety question
that gets less attention: when autonomous agents
transact with each other at scale, who enforces
the rules.
If agent A pays agent B for a service and B does
not deliver, who slashes B's stake. If agent C
claims it ran a specific model on specific data,
who verifies that claim. If agent D was only
authorized to read public data but starts writing
to another entity's memory, who stops it.
Prompt-level alignment cannot answer these
questions because the enforcement has to exist
below the agent's reasoning layer. If the agent
decides its own permissions, those permissions are
suggestions. If the protocol enforces them before
the agent's code runs, they are structural
boundaries.
That is the thesis. AI does not just need better
models. It needs verifiable infrastructure for
economic coordination between autonomous systems.
What is next
Public testnet on a dedicated server. A block
explorer so anyone can watch the chain live. SLAs
with auto-slash. Payment channels for
high-frequency micropayments. Then a Product Hunt
launch.
I am building this solo for now. Looking for a
technical co-founder who wants to work on AI
infrastructure in Rust. Specifically someone who
can own consensus, networking, or ZK circuits.
The repo is open. The testnet is running. The code
speaks for itself.
Github: https://github.com/0x-devc/NOVAI-node
Twitter: https://x.com/NOVAInetwork
**
Top comments (0)