Provenance · Lineage · Replay
Verifiable execution provenance for autonomous agents.
Each agent run becomes an execution record you can inspect: what ran, who authorised it, what changed—and whether an independent replay still verifies the lineage.
Stop trusting logs. Start verifying execution.
Agent execution · live record
- Task
- ——
- Agent
- ——
- Authorised by
- ——
- Timestamp
- ——
- Network
- ——
Waiting for agent execution…
LangGraph
ElizaOS
CrewAI
Temporal
Dapr
n8n
OpenAI
AutoGenThe problem
Autonomous agents are starting to touch code, capital, infrastructure, and production workflows.
But most agent systems still rely on fragile logs, screenshots, database rows, or “trust me bro” runtime traces.
In high-stakes environments, unverifiable execution history is not a tooling gap. It is infrastructure risk.
incident.log
▌
When something goes wrong, teams are left asking:
- 01Which agent executed this?
- 02Who authorised the action?
- 03Was the event modified later?
- 04Can we replay the decision chain?
- 05Was delegation scoped or overpowered?
Why logs are not enough
Traditional logs are mutable, fragmented, and hard to replay. Memora turns execution history into cryptographic evidence.
Traditional logs
- mutable
- fragmented
- hard to replay
- weak signer guarantees
- visibility after the fact
Memora
- tamper-evident
- lineage-linked
- replay-verifiable
- cryptographic attestations
- provenance by design
An agent deletes production infrastructure. The logs say cleanup succeeded. But the signer changed mid-run, the operator approval cannot be verified, and the parent workflow was silently modified. You do not have observability. You have ambiguity.
What Memora does
Memora Sentinel creates a tamper-evident execution lineage for autonomous systems.
Cryptographic Signing
Every execution event is signed by the agent runtime and countersigned by the operator — creating dual-attestation before anything is committed.
HCS Anchoring
Events are ordered through Hedera Consensus Service, establishing a tamper-evident sequence number that cannot be forged after the fact.
On-chain Registry
Attestation metadata is stored in the Memora registry contract. The commit path — VERIFIED, ATTESTED, or LEGACY — is enforced on-chain.
Replay Verification
The replay verifier reconstructs the full execution chain: signer validity, payload integrity, parent linkage, and HCS ordering — all independently checkable.
So your agent history becomes more than a log.
It becomes evidence.
Interactive demo
Add provenance in minutes.
Drop the SDK into any existing workflow. No new infrastructure. No runtime lock-in.
import { MemoraClient } from '@smritheon/memora-core'; const client = new MemoraClient({ agentId: 'treasury-agent', writeSecret: process.env.MEMORA_WRITE_SECRET, }); await client.write({ taskId: 'task-001', payload: { action: 'deploy', env: 'prod' }, }); // → commit_path: VERIFIED ✓
How it works
- 01
Capture execution events
Agents emit structured execution artifacts from workflows, tools, or runtime steps.
event_type: tool_call - 02
Sign and attest
The agent runtime signs the canonical event digest. The operator verifies and countersigns accepted events.
signature: 0x8b3c…f21a - 03
Anchor ordering
Events are ordered through Hedera Consensus Service, creating a tamper-evident sequence.
hcs_sequence: #1842 - 04
Commit provenance
Attestation metadata is stored through the Memora registry contract.
commit_path: VERIFIED - 05
Replay lineage
The replay verifier reconstructs the full execution chain, including parent links, signer validity, payload integrity, and commit path.
replay: 8 checks passed
Live activity
liveNetwork in motion.
Every agent execution logged, signed, and anchored in real time. Each row is a tamper-proof record.
No activity yet
Start the indexer or enable public live activity to see live records.
Built for agent systems that need proof
Memora works alongside existing runtimes instead of replacing them.
Wrap a task, trace an event, verify a lineage.
Use it with:
Provenance signal path
Execution artifacts move through attestation, ordering, registry commit, and independent replay—each step inspectable.
What Memora verifies
Memora can cryptographically verify:
Replay verification
- on-chain anchored—
- HCS indexed—
- event_id present—
- subscriber verified signature—
- parent linkage restored—
- parent HCS ordering preserved—
- agent countersignature valid—
- commit path verified—
Memora does not pretend to prove that an agent made the “right” decision.
It proves where the decision came from, who approved it, and whether the execution trail still holds.
Product surfaces
SDK
Add provenance to an existing workflow with a small TypeScript client.
await client.write({
event_id: "8f2a91c4…0512",
payload_hash: "0x7e3fa9…e5f0",
agent_signature: "0x…",
});CLI
Write, query, read, verify, and replay execution events from the terminal.
$ memora replay verify --memory mem_de…001 ✓ on-chain anchored ✓ HCS indexed ✓ event_id present
Web Console
Inspect live execution state, identities, replay results, ledger events, and failure visibility.
hcs_sequence #1842
Registry
Anchor execution attestations with on-chain signer and commit-path verification.
MemoryCommittedV3 commit_path: VERIFIED agentCommitDigest: 0x4a2e…9c01
Why teams use Memora
For agent developers
Debug execution history without relying on scattered logs.
For infra teams
Add auditability to autonomous systems before they touch production.
For security teams
Verify delegation, signer validity, and event integrity after the fact.
For web3 teams
Create provenance trails for agents operating across wallets, contracts, and decentralised infrastructure.
Early access
Start verifying your agents
Memora Sentinel gives autonomous systems a memory that can be checked, replayed, and challenged.
npm install @smritheon/memora-coreView on npm ↗