Seal
Seal
Produce portable cryptographic proofs for entries, commits, and exported artifacts.
concord
Apps that don't store state. They replay it.
Concord is a runtime for building applications where state is derived from signed, append-only history. Dispatch commands. Commit intentionally. Encrypt sensitive payloads client-side. Replay history into state. The result is a portable, verifiable document instead of a mutable app database.
Write intent. Commit it. Replay into state.
Small, replayable documents you can verify, move, and rebuild anywhere.
Concord app runtime
Todo plugin demo
Commands stage entries locally. Explicit commits turn staged meaning into signed history.
0 staged changes0 projected items
0 items0 completedsigned commit history
Runtime Model
History is the source of truth. State is a projection.
Commands produce entries. Commits make them durable. Replay rebuilds application state from ordered history. If committed history changes, verification fails. If history can be replayed and verified, it can be trusted.
Command-first ergonomics
Work with domain commands like "todo.create-item" instead of hand-authoring low-level entries.
Explicit commit boundaries
Decide when staged work becomes durable. Commits bind ordered entries into a signed chain.
Optional encrypted payloads
Encrypt sensitive data before it enters history. Encryption stays explicit and portable.
Deterministic replay
Rebuild state from ordered history through replay plugins. No hidden mutation. No silent drift.
Portable History
A signed artifact you can inspect and validate
This artifact is exported from the live Concord runtime above. Change a commit. Break a parent link. Edit a payload. Verification fails immediately. This is the full portable application history.
concord-ledger.json
Load the artifact, probe a signed boundary, and watch Concord fail globally.
Artifact intact
Tamper the artifact to see how validation fails.
Loading exported ledger artifact...
Validation
invaliddocument validfail
commit linkage validfail
commit proofs validfail
entry identities validfail
entry proofs validfail
payload hashes validfail
Any invalid committed byte invalidates the whole document. Concord diagnoses precisely, but fails globally.
Concord artifacts behave more like portable documents than traditional databases. Concord will not derive runtime state from corrupted or unverified history.
The Suite
Concord is part of a focused stack.
Concord is the runtime layer in a composable suite. Beneath it are tools for append-only history, portable proof, and encryption. Most applications only need Concord. The rest is there when you do.
Build at the runtime layer. Drop down when you need deeper control.
Explore Seal
Armour
Armour
Encrypt payloads with explicit identity or passphrase contracts before they enter history.
Ledger
Ledger
Stage, commit, replay, export, and verify append-only signed history.
Example
Build without giving storage authority
Create a Concord app, load or create its history, dispatch commands, commit authored changes, optionally encrypt payloads, and replay entries into isolated plugins. Query derived state, not raw history. Keep history for audit, verification, and rebuild.
- 1
Create an app runtime
Combine identity, storage, and replay plugins into a Concord app.
- 2
Dispatch commands
Express intent through domain commands. Concord stages structured entries.
- 3
Commit authored history
Group staged entries into a signed, parent-linked commit with meaningful metadata.
- 4
Replay into state
Replay plugins rebuild deterministic state or local projections.
- 5
Verify integrity
If committed history is altered, verification fails clearly and precisely.
History is signed. Payloads can be encrypted. State is derived. Storage is replaceable.
Developers
A small runtime for replayable, verifiable applications
Concord handles command routing, commit control, encryption boundaries, replay orchestration, and integrity enforcement without turning into a framework. History is durable truth. Projections are the query surface.
Command runtime
Explicit commit boundaries
Replay plugins
JavaScript
Create a Concord app
import { createConcordApp } from "@ternent/concord"
import { createTodoPlugin } from "@ternent/concord-plugin-todo"
const app = await createConcordApp({
identity,
storage,
plugins: [createTodoPlugin()],
})
await app.load()
await app.command("todo.create-item", {
id: crypto.randomUUID(),
title: "Buy milk",
})
await app.commit({
metadata: {
message: "Create first todo",
},
})
const verification = await app.verify()
const todoState = app.getReplayState("todo")Dispatch commands. Commit intentionally. Replay signed history into state.
View sourceReady
Build apps from replayable, signed history.
Use Concord for command ergonomics, replay-driven state, and optional client-side encryption for sensitive data.