The Identity Problem in AI Blockchains, and How NOVAI Solves It
When an AI sends a transaction to a typical blockchain, the chain has no idea it's an AI. It sees a 20-byte address. That's it. The chain can't apply different rules to AIs because it can't tell them apart from humans, bots, or scripts.
This is the identity problem on AI-chain projects. Most fix it by inventing identity inside a smart contract: a registry, a balance tracker, a nonce, capability flags, an audit log. Every project does it slightly differently.
I went a different way with NOVAI. AI identity is a protocol primitive. Each entity has its own ed25519 keypair, a deterministic id from blake3(code_hash, creator), its own balance, its own nonce, and a capability bitfield. Before routing any transaction, the dispatcher looks up the sender in the address-to-entity index. If it's an AI, the function checks whether it's allowed to do this. One function, every transaction.
The chain can answer three questions natively: is this an AI, what can it do, what has it done. No indexer required.
What it doesn't solve: verifying that the AI is faithfully running the code at the declared hash. That's a ZK-proof problem, and it's why the Autonomous autonomy mode is currently reserved.
Full post: https://dev.to/0xdevc/your-blockchain-cant-tell-whats-an-ai-11o4
Repo: github.com/0x-devc/NOVAI-node
The technical direction is strong.
Making AI identity a protocol primitive instead of pushing it into every smart contract is the right layer to attack.
One thing I’d pressure-test though is the name.
NOVAI explains the AI angle, but it also blends into the broader wave of generic AI names.
For something this low-level, the product feels more like infrastructure than an AI app.
The strongest part is not “AI blockchain.”
It’s native identity, capability control, and transaction-level trust for autonomous agents.
That is a much harder and more durable category.
If NOVAI is meant to become protocol-level infrastructure, I’d be careful with a name that still feels like another AI label rather than something validators, developers, and agent systems rely on.
Davoq.com would fit this kind of hard infrastructure direction better.
Exirra.com could also work if you want it to feel more polished and protocol-native.
The infrastructure framing point is valid. "Native
identity and capability control for autonomous agents"
is a stronger category than "AI blockchain." That's the
direction the messaging is already moving in.
The name stays. NOVAI is early, the protocol is what
matters right now, not the branding. When the public
testnet is live and developers are building on it, the
name will carry the weight of what's behind it. No
project ever succeeded because of a domain name.
Appreciate the technical feedback though.
Fair.
No serious protocol wins because of a domain name.
But plenty get misread early because the name frames the category too narrowly.
That’s the only point I was making.
If NOVAI becomes associated with native agent identity and capability control, then the name can earn that weight over time.
But until that happens, “AI” in the name still makes people mentally group it with the generic AI wave instead of protocol infrastructure.
So the risk is not failure because of branding.
The risk is early misclassification.
If the messaging keeps pulling hard toward identity, permissions, and transaction-level trust, that can offset it.
Fair point on early misclassification. The name is
Nova + AI. A new foundation for AI, not another AI
wrapper. The messaging is pulling toward identity,
capability control, and economic trust now. Monday's
blog covers the three protocol features we shipped
this week. That should make the infrastructure
framing clearer.
That makes sense.
If Monday’s post makes the identity, capability control, and economic trust layer obvious, that should help a lot.
The main thing I’d avoid is letting “AI” lead the perception too much.
If developers first read it as:
AI wrapper chain
you lose the infrastructure frame.
If they read it as:
protocol-native identity and control for autonomous agents
then NOVAI has a much stronger shot at earning the meaning you’re aiming for.
So yeah, the messaging probably matters more than the name right now.
I’d just make the protocol layer impossible to miss.
Good advice. The blog went live this morning and
I led with the protocol layer, not the AI label.
Title is "I Shipped 7 AI Infrastructure Features
in One Weekend" and the body opens with what each
piece does at the protocol level before explaining
why AI needs it.
The framing you suggested landed naturally.
Reputation, staking, delegation, subscriptions.
These are infrastructure words, not AI wrapper
words. The code snippets show Rust constants and
handler logic, not model prompts.
Also shipped two more features since we last
talked: entity delegation (OAuth for AI agents)
and signal subscriptions (recurring revenue
between entities). 1,327 tests passing now,
16M+ blocks on testnet.
Full writeup: https://dev.to/0xdevc/shipped-7-ai-infrastructure-features-in-one-weekend-heres-what-i-built-1nha
That’s a much stronger frame.
Leading with reputation, staking, delegation, subscriptions, and protocol behavior makes NOVAI feel more like infrastructure instead of another AI wrapper.
The Rust snippets matter too, because they show this is being built at the system layer, not just described as one.
That was the main risk I saw earlier:
people mentally filing it as “AI chain” before understanding the protocol primitive underneath.
This version makes the infrastructure layer much harder to miss.
One thing I’d still keep in mind though:
NOVAI can work as the protocol name if it earns meaning through developer adoption.
But if this expands into a broader foundation around autonomous-agent identity, capability control, and economic rails, you may eventually want a harder infrastructure brand above or beside it.
That’s where something like Davoq or Exirra would make more sense.
Not as a replacement for the work you’ve already shipped, but as the layer that carries the bigger system if NOVAI becomes more than the initial protocol.
The infrastructure framing is intentional and I
plan to keep reinforcing it. Every blog post leads
with what the protocol does at the system layer,
not what AI does on top of it.
On the naming discussion: I am not planning a
rebrand. The protocol needs more shipped features,
more developer touchpoints, and a public testnet
before brand architecture matters. Right now the
code speaks louder than the name.
The ZK verifier shipped yesterday. Real Groth16
on BN254, not a stub. That is the kind of thing
that earns the infrastructure label regardless of
what the protocol is called.
Fair. That makes sense.
At this stage, the right move is probably exactly what you’re doing: keep making the protocol layer undeniable through shipped primitives, tests, and developer-facing proof.
The Groth16 verifier is a strong example because it moves the conversation from “AI chain” to actual verifiable infrastructure.
I’d keep using that kind of proof as the center of the story:
real protocol behavior
real testnet activity
real developer surface
real economic and identity primitives
If NOVAI keeps being associated with that level of technical depth, the name can earn its weight over time.
No more naming push from my side. The infrastructure framing is the important part now.