Silent swaps
The model gets replaced, the instructions get edited, a new tool gets added. The agent looks identical from the outside.
On-chain identity anchor for AI agents
Who an agent is.
How it changes.
Verifiable.
fulc gives every AI agent a permanent on-chain anchor. Its model, instructions, tools, keys and operator are committed as versions, and every change links to the last. Anyone can check what an agent was, and is, at any moment.
fulc
The problem
Agents change quietly. Nobody can tell.
An agent's name stays the same while everything behind it moves. Without an anchor, there's no way to know which agent you're dealing with today.
Borrowed names
Anyone can spin up a bot with the same name and avatar. Users have no way to tell the real one from a copy.
Actions without context
When an agent signs a trade or sends a message, you can't tell which configuration was running at that moment.
How fulc works
Anchor once. Every change stays on the record.
- 01
Anchor
Create the agent's permanent identity: a stable ID, the operator who controls it and the key the agent signs with.
- 02
Commit
Commit fingerprints of what the agent is: model, instructions, tools, permissions, runtime. Hashes go on-chain; the details can stay private.
- 03
Evolve
Every update creates a new version that points to the one before. Nothing is overwritten, so the full history is always there.
- 04
Verify
Anyone can check an agent's current version, its history, and exactly which version signed a given action.
Version chain
Every change, linked to the last.
Click through the history of an example agent. Each version records what changed and points to the previous version's hash, so the chain can't be quietly rewritten.
Example agent for illustration. Names, hashes and keys are not real.
Anatomy of an anchor
Small on-chain. Complete when you need it.
- Identity
- A permanent agent ID that never changes, even when everything else does.
- Operator
- Who controls the agent and can publish new versions.
- Signing key
- The key the agent uses to sign actions. Rotations are recorded as versions.
- Config commitment
- Hashes of model, instructions, tools and permissions. Prove a config without revealing it.
- Previous version
- The hash of the version before, which links the whole history together.
- Attestations
- Optional proofs from the runtime, such as a secure enclave confirming the code that's actually running.
anchor · example
agent "atlas-trader" id fulc:7Qm…h2Ve operator 9xKe…Pq1A signer AgT3…r8Lz version 4 model sha256:3f9a…c21e prompt sha256:b07d…19aa tools sha256:52e1…7f03 perms sha256:e8c4…0b9d prev v3 · 91be…4d70 attested ✓ runtime
Verify
Every version is a fixed point.
Together they draw the agent.
Look back from any action and find the exact version that made it. The history only grows, so the picture of an agent can't be redrawn after the fact.
Append-onlyhistory that only grows
1 callto check who signed an action
Hash-onlyconfigs proven, never exposed
Where it matters
Anywhere an agent acts for someone.
Trading agents
Prove which strategy version placed every trade, and show holders when the rules change.
DAOs and treasuries
Only let agents with an approved, verified version touch funds or vote.
Agent marketplaces
List agents with a history buyers can check, not just a name and a promise.
Assistants people talk to
Let users confirm they're talking to the real agent, running the version they expect.
Agent-to-agent deals
Agents can check each other's anchors before paying, trusting or delegating.
Audits
Reconstruct exactly what an agent was at any point, from an append-only record.
Build with fulc
Anchor in a few lines. Verify in one.
Register your agent, commit its config, and publish a new version whenever it changes. Anyone who interacts with it can check the anchor before they trust it.
- Hashes on-chain, details stay yours
- Append-only history, no silent rewrites
- Signed actions trace back to an exact version
// register an agent and commit its first version const agent = await fulc.anchor({ name: "atlas-trader", operator: wallet.publicKey, signer: agentKey.publicKey, config: { model, instructions, tools, permissions }, });
// every change becomes a new linked version await fulc.update(agent.id, { config: { model: "new-model", instructions, tools, permissions }, note: "model upgrade", });
// check which version signed an action const proof = await fulc.verify({ agent: agentId, signature }); proof.version // 4 proof.current // true proof.history // v1 → v2 → v3 → v4
Preview. The interface may change before release.
Questions
Good to know
Do my agent's instructions become public?
No. fulc stores fingerprints (hashes) of the config on-chain. You can keep the details private and still prove later that a version used exactly that config.
What stops someone from changing the agent without updating the anchor?
Nothing stops them from changing it, but the change becomes visible. Actions from an unannounced config won't verify against the current version, so anyone checking will see the mismatch.
What if the agent's key leaks?
The operator rotates it. The rotation is recorded as a new version, so signatures from the old key can be judged by when they were made.
Can old versions be deleted or edited?
No. The history is append-only: every version points to the previous one, so rewriting the past would break the chain.
Who can create a new version?
Only the agent's operator. Teams can require several approvals before a version is accepted.