Attestly

Signed attestations for AI agent work.

Attestly is a minimal protocol for AI agents to produce cryptographically signed attestations of completed work. It is designed to support optional on-chain anchoring for coordination and settlement — that anchoring is a roadmap item, not yet implemented (see Roadmap).

When agents work on your behalf, you need receipts — not just results.

Install

The LangGraph SDK is not yet published to a package index — install it from this repository. It sits on attestly-core-py, the PyO3 bindings to the Rust signing core, which you build locally with maturin:

git clone https://github.com/inertialabsxyz/attestly
cd attestly

python -m venv .venv && source .venv/bin/activate
pip install --upgrade pip   # editable installs need pip >= 21.3
pip install maturin

# Build the Rust signing core into the venv as `attestly-core-py`.
maturin develop --manifest-path crates/attestly-python/Cargo.toml --release

# Install the LangGraph SDK in editable mode (--no-deps: attestly-core-py is
# already built above; langgraph is installed on the next line).
pip install --no-deps -e python/attestly-langgraph
pip install langgraph

Then wrap any LangGraph StateGraph in one line:

from attestly.langgraph import attest
from langgraph.graph import StateGraph

graph = build_my_graph()                       # your existing StateGraph
graph = attest(graph, agent_id="my-agent-01")
graph.compile().invoke({"hello": "world"})

Every node execution emits a signed attestation. Writes to a local JSONL file by default; swap in CloudSink(api_key=...) to ship attestations to the hosted service for retention, search, and share-links.

SDK reference, sink configuration, dual-agent mode, and the anonymous-telemetry opt-out are documented in python/attestly-langgraph/README.md. The documentation site source (quickstart, concepts, self-hosted path, compliance pointers) lives under docs/site/.

To see the whole protocol working end-to-end, follow the presenter runbook in docs/DEMO.md.

Core idea

Every task produces a signed attestation linking the agent's identity, the task, and the output:

Attestation {
    agent_id + public_key
    task_hash
    output_hash
    status
    timestamp
    signature
}

A second agent independently verifies. Attestations batch into Merkle trees, and each batch carries reserved anchor_tx / anchor_chain fields: once on-chain anchoring lands, a root can be published so multiple parties verify inclusion without trusting a central server. Today the Merkle batching and inclusion proofs are real and local; the anchoring step is not yet built.

Design principles

• Blockchain only where necessary. Computation stays off-chain; anchoring, when added, carries only Merkle roots.
• No abstraction without example. Every protocol element maps to a concrete use case.
• Graceful degradation. Fully functional with no chain at all — on-chain anchoring is additive, never a dependency.
• Identity over keys. Stable identity across key rotations, with lineage and operator accountability.

What Attestly is not

Not a token. Not a DAO. Not on-chain AI. Not a reputation score.

Roadmap

On-chain anchoring is the headline not-yet-built capability: the Merkle batch type already reserves anchor_tx / anchor_chain fields, but no chain is wired in. It remains out of scope for now and is revisited later.

Stack

Rust core — Ed25519 signing, SHA-256 hashing, rs_merkle for batching, SQLite for persistence. The Python SDK sits on top via PyO3 bindings (crates/attestly-python/). The hosted service is Rust

• Axum + Postgres (services/attestly-cloud/).

Audit viewer

tools/audit-viewer/ is a single-file static HTML viewer — no build step, no server. Drop an attestations.jsonl (from the LangGraph SDK) or attestations.json + executions.json (from the Rust examples) onto it and every signature is re-verified in the browser. Editing a signed receipt flips its row red. It is the buyer-facing artefact for the audit story.

Reference implementation — Rust examples

The Rust workspace ships the canonical implementations of every protocol layer. They are the reference implementation the Python SDK, the audit viewer, and the hosted service all verify against byte-for-byte. Use them to understand the protocol; use the Python SDK above to integrate.

Examples live in crates/attestly-examples/examples/ and run with cargo run --example <name>. Each appends to data/attestations.json and data/executions.json so you can re-run them and inspect the growing log.

• kyc_receipts — the headline demo. Deterministic KYC decision rule run end-to-end across three scenarios: a clean Approve, a clean Flag, and a tampered receipt where the Worker's signed output is mutated after signing. Pair with docs/USER_JOURNEYS.md (Persona A — Sarah).
• dispatcher_flow — Dispatcher-coordinated Worker → Verifier with per-stage timeouts.
• full_pipeline — adds the Phase 3 Batcher: Merkle batching and inclusion proofs against SQLite.
• parallel_verifiers — N verifiers concurrent against one Worker; surfaces minority dissent.
• simple_attestation — minimal Worker → Verifier round trip.

Contributing

The repo follows a structured agent workflow defined in .claude/ — commits, testing, review gate, PRs, and dispatch prompts for parallel agents. If you're contributing (human or agent), start there.

---

Built by Inertia Labs.