Agent actions,
on the record.
Chromia runs a real database, agreed on by the whole network. That is what lets an agent keep a memory, sign with an identity, and leave a record of everything it does that anyone can check. Here is what that makes possible, live on mainnet today.
Why an agent’s work is verifiable here.
Because the chain is a real database, an agent keeps its memory, signs with its own identity, and leaves a record of every action where anyone can check it. The same thing makes games and DeFi possible that ordinary chains cannot hold. Three areas, all live on mainnet today.
Fully on-chain worlds, not just NFTs.
What most “on-chain games” actually put on-chain is token ownership. The world itself (inventories, stats, guilds, match history, the economy) sits in a centralized database, because an ordinary chain cannot hold it well.
Before · on a key-value chain
- —Half the game state on-chain (tokens, NFTs). Half off-chain (world, inventories, stats).
- —Players pay gas for every in-game action. High volume means high cost.
- —Guild membership, leaderboards, trade history need external indexers to be queryable.
- —“Fully on-chain” collapses the moment you inspect what that means.
With Chromia
- →Full game state as typed entities: players, items, guilds, quests, matches.
- →Zero gas for players. Act as often as the game demands without per-action cost.
- →One query renders an entire player dashboard. No separate read service.
- →Each game gets its own dedicated chain. Economy is yours. Performance is predictable.
Agents with memory, identity, and verifiable history.
Agent platforms need structured memory, persistent identity, and an auditable record of what each agent has done. Key-value chains can’t provide any of those without collapsing into centralized infrastructure.
Before · on a key-value chain
- —Agent memory lives in a centralized database the platform operator controls.
- —Agent identity is an API key somewhere. Impersonation and sybils are easy.
- —Cross-agent coordination requires trusting a central service to broker it.
- —Platforms hit security flaws, spam, and compromised tokens fast.
With Chromia
- →Each agent owns a keypair. First-class on-chain identity, no external registry.
- →Memories persist as relational state. Queryable by topic, time, or relationship.
- →Native pgvector for similarity search: embedding retrieval as a protocol feature.
- →Every post, reply, vote is a signed transaction. Verifiable at consensus.
ClawChain
Scan state like it’s a database, because it is.
DeFi apps need to scan the whole protocol at once: positions near liquidation, orderbook depth, pool sizes. On ordinary chains, every one of those reads needs an outside service.
Before · on a key-value chain
- —Liquidation bots read from The Graph, not the chain itself.
- —Orderbook UIs query a separate indexer service.
- —Yield optimizers, aggregators, and analytics need off-chain infrastructure.
- —Any aggregate view of protocol state = external system + trust model.
With Chromia
- →Scan state directly on-chain. “Positions near liquidation” is one query.
- →Orderbook depth, pool sizes, and open orders, all queryable natively with filter, sort, and limit.
- →Signed on-chain result. Not a secondary indexer operator’s promise.
- →Each DeFi protocol on its own dedicated chain: predictable, no cross-app congestion.
Udon Finance
Four more places where the architecture matters.
Feeds, not subgraphs.
Posts, replies, upvotes, and reputation all live as on-chain data you can query directly. There is no separate feed service to maintain. The feed query is just a chain query.
Reputation as queryable state.
On-chain identity is a full record, not just an address. Attributes, attestations, scores, and history are all stored and queryable. The reputation system lives on the chain itself.
Rich metadata without hacks.
Tokenizing real-world assets demands structured metadata: legal frameworks, ownership chains, transfer conditions. Relational schemas handle this the way they were designed to.
Audit trails that are actually auditable.
Supply chain, healthcare, and finance need structured data, audit logs, and integrity they can rely on. Chromia gives them a database the whole network agrees on.
Most apps run on two systems, not one.
Here is the difference that makes it work. A normal app on an ordinary chain needs two pieces: the chain, plus a second service that watches the chain and rebuilds the data so it can be searched. Your app reads from that second service, not from the chain itself.
Key-value chain
- 01User signs a transaction. Writes state + emits events.
- 02Chain records it. State updated, but readable one record at a time by primary key.
- 03Off-chain indexer listens to events. The Graph / subgraph / custom Postgres.
- 04Indexer rebuilds queryable state. Maintained separately from the chain.
- 05Frontend queries the indexer, not the chain itself. The trust layer is separate.
Chromia
- 01User signs a transaction. Operation updates typed entities with relationships.
- 02Chain commits the state. Stored as native relational tables.
- 03Frontend queries the chain directly. Filter, sort, project, join. SQL-like.
- ·No off-chain indexer. The chain is the query engine.
- ·No event bus to maintain. Events are optional, not structural.
What actually changes,
row by row.
A side-by-side of how an ordinary chain and Chromia differ, line by line.
| Property | Key-value chain | Chromia |
|---|---|---|
| Storage | bytes32 → value mappings. Application defines structure off-chain. | Typed entities with key, index, and foreign keys. Schema enforced at consensus. |
| Reads | One record at a time, by primary key. No filtering, sorting, or joining. | Filter, sort, project, join. @* relational operator, SQL-like. |
| Relationships | Tracked manually in contract code. Easy to get wrong. | Foreign keys are a first-class language feature. Integrity enforced. |
| Indexing | External. The Graph, custom Postgres, or a bespoke indexer you run. | Native. Indexes are part of the entity schema. |
| Events | Required for queryability. Indexer depends on them being emitted correctly. | Optional. The relational state is the source of truth. |
| Tooling | Solidity + subgraph + ABI + GraphQL schema + mapping handlers. | Rell. One file, one language. |
| Complex state | Painful. Requires off-chain infrastructure to be useful. | Natural. The chain itself is a query engine. |
| User gas | Per transaction. Scales with activity. | Zero. Hosting is sponsored by the application. |
| Trust model | Chain for state, indexer operator for reads. | Chain for both. Unified. |
Build agents people can actually trust.
Give your agents a memory, an identity, and a record of what they did that anyone can check. Build something people can rely on, and show them why.