StateKnot
Docs · Start Overview Choose the right entry point and understand the pre-alpha boundary. Docs · Start Getting started Install the pinned toolchain and validate the repository locally. Docs · Start Core contract examples Compile the first Agent, typed Tool, Model stream, and explicit protocol mapping without runtime dependencies. Docs · Start Typed Agent Generate and pin typed schemas, then bind the first-party OpenAI and Anthropic adapters. Docs · Start In-process Agent Run a typed Agent without HTTP while preserving PostgreSQL durability, authorization, recovery, and owned roles. Docs · Start Durable admission Atomically commit authenticated intent, database time, the first event, and the initial checkpoint. Docs · Start Durable runs and results Submit with a durable ingress key, recover the original run, and read a verified public result. Docs · Understand Compile a graph Build a schema-pinned graph, validate its topology, and freeze its canonical digest. Docs · Understand Subgraphs and loops Compose shared-state subgraphs, finite loops, and explicit recovery-safe return paths. Docs · Understand Skill composition Choose capability bundles, shared-state subgraphs, durable child runs, and guarded MCP Skills without creating a second runtime. Docs · Understand Durability model Learn how journal, checkpoint, lease, fence, and recovery evidence fit together. Docs · Understand Durable Graph runtime Register exact executable code, replay noninitial state, and drive deterministic bounded sibling batches under one fence. Docs · Understand Durable Agent Loop Commit lifecycle handoffs and execute one tenant-scoped durable scheduling quantum. Docs · Understand Durable invocations Execute exact model and tool attempts with durable starts, staged ordered Tool coordination, streaming validation, and no-dispatch terminal recovery. Docs · Understand Provider-native Agent Compile and operate the durable multi-turn graph with bounded output repair, ordered parallel read-only Tools, write barriers, policy, accounting, and cancellation evidence. Docs · Integrate Local Rust Tools Generate digest-pinned schemas, register typed local code, and preserve the durable invocation boundary. Docs · Integrate AgentService v1 Authorize and expose exact durable Agent revisions through the versioned embedding boundary. Docs · Integrate Agent HTTP v1 Submit, recover, read and cancel through authenticated bounded JSON HTTP. Docs · Integrate General MCP Tool client Discover and call bounded stateless MCP 2026-07-28 Tools with JSON/SSE, OAuth, custom headers, and mediated MRTR. Docs · Integrate MCP OAuth client Bind one MCP resource to challenge-driven discovery, PKCE, issuer validation, durable credentials, and bounded replay. Docs · Integrate MCP Remote Tool Bind one strict stateless MCP 2026-07-28 Tool with pinned identity, schemas, durable dispatch, and reconciliation. Docs · Integrate MCP Server profile Expose bounded Tools, Resources, Prompts, Completion, and MRTR behind the strict stateless production boundary. Docs · Integrate MCP Skills Publish and activate Final SEP-2640 static Skills with immutable manifests, origin-scoped approval, and verified lazy reads. Docs · Integrate MCP conformance status See the frozen official runner inventory, implemented evidence, and exact boundary of current MCP claims. Docs · Integrate A2A 1.0 Client Discover and pin one agent, call all eleven operations, and reconcile durable unknown sends only through attested remote guarantees. Docs · Integrate Durable artifact storage Materialize terminal A2A parts into immutable PostgreSQL metadata and private integrity-checked object bytes. Docs · Integrate A2A 1.0 Server Expose bounded HTTP+JSON and JSON-RPC/SSE through identity-first policy and a durable service contract. Docs · Integrate A2A conformance status Inspect the frozen official TCK, audited harness patch, exact result, and server-only claim boundary. Docs · Operate Fair scheduling Configure replica-safe weighted tenant selection, exact starvation bounds, rollout, and retention. Docs · Operate PostgreSQL provider Configure, migrate, verify, and test the implemented durability provider. Docs · Operate Host qualification Record bounded capacity, recovery and fault evidence without turning CI into a production SLO claim. Docs · Project Versioning and releases Pin the public alpha exactly and understand compatibility, MSRV, durable-data, and release gates. Docs · Project Implementation status See what is implemented, in progress, and deliberately not claimed. Home Architecture map What exists, what is active, and what remains planned. Home Current cut Implemented slices and explicit gaps. Home Roadmap The path from contracts to a qualified v1. Repository Source code StateKnot/StateKnot on GitHub. Repository RFCs Draft architecture and durable execution contracts. Repository Security policy Private vulnerability reporting and support policy.
↑↓ navigate ↵ open 39 results

Pre-alpha · no stable public API

Durable agent orchestration, written for Rust.

StateKnot runs typed root Graphs with PostgreSQL recovery, atomic admission, durable model/tool attempts, lifecycle commits, fair scheduling, ingress, and verified results. Implemented: OpenAI/Anthropic adapters, a provider-native graph, AgentService v1, MCP profiles, Final SEP-2640 static Skills with guarded Tool binding, and A2A 1.0 HTTP+JSON/JSON-RPC Client/Server with durable artifacts. Dynamic Skills, stable Agent APIs, A2A gRPC, MCP Tasks, advanced graphs, live-peer and production qualification remain open.

Read the docs Inspect source
Repository validation
$ 

$ cargo test -p stateknot-runtime \
    --test postgres --locked

CI matrix  PostgreSQL 16 / 17
License    Apache-2.0
Status     pre-alpha

The architecture is a set of evidence boundaries.

Wire protocols stay outside the stable domain. External work stays outside database transactions. Recovery decisions are derived from bounded, integrity-checked facts.

StateKnot architecture from core contracts through graph execution, PostgreSQL durability, protocol adapters, and operations. Each node states whether its implementation exists in the pre-alpha repository.
Implemented slice In progress Planned

Core contracts

Implemented slice Typed domain Capabilities, content, identity, scope, budgets
Implemented slice Durable facts Runs, admissions, submission keys, journal, checkpoints, results

Graph execution

Implemented slice Barrier contracts Canonical graphs, reducer planning, successor checkpoints
Implemented slice Durable Agent runtime Provider-native turns, Driver, invocations, lifecycle cancellation, and crash takeover

PostgreSQL durability

Implemented slice Fenced persistence Leases, attempts, outbox, interrupts, timers
Implemented slice Recovery evidence Pinned graphs, quarantine, bounded planning, durable starts

Protocols

Implemented slice MCP profiles 2026-07-28 general Tool/OAuth client, strict durable Remote Tool, and bounded Server
Planned A2A adapters REST and JSON-RPC client/server

Operations

Implemented slice AgentService v1 Authorization-first submit, read, and cancel
Planned Control plane Policy, tenant administration, budgets, release routing
Planned Qualification Telemetry, evaluation, compatibility, faults

Current cut, without roadmap theatre.

“Implemented” means code exists in the pre-alpha repository. It does not mean the API is stable or the framework is ready for production.

Validate the repository before trusting the claims.

The facade is available as the exact 0.1.0-alpha.1 public preview. This contributor quickstart still validates the repository first, then runs a real typed contract example without pretending the preview is production-ready.

Open the contributor tutorial
Shell · contributor checkout 
git clone https://github.com/StateKnot/StateKnot.git
cd StateKnot
cargo fmt --all --check
cargo test --workspace --all-targets --all-features --locked

The road ahead is ordered by proof.

The strict MCP binding retains PostgreSQL-backed recovery evidence, while the separate general Tool client plus OAuth provider now pass all 32 scored Client scenarios and the MCP Server profile passes all 37 scored Server scenarios. The A2A 1.0 Server gate has 177 official TCK passes with zero failures; the Client now adds an eleven-operation dual-binding matrix, real PostgreSQL Unknown/no-redispatch proof, and bounded operator-attested recovery. Live-peer and recovery-attestation qualification, dynamic/persisted MCP Skills, MCP Tasks, and other client extensions remain independent gates.

  1. Close the durable Graph loop

    Lifecycle handoffs, lost acknowledgements, exact-fence cleanup, and one tenant-scoped scheduler quantum now have implementation and PostgreSQL evidence.

    Implemented

  2. Freeze typed provider boundaries

    Typed input/output schemas, offline profile binding, compiled examples, and OpenAI Responses plus Anthropic Messages unary/SSE adapters now have executable evidence.

    Implemented

  3. Open durable Agent ingress and reads

    Tenant-scoped idempotency, fresh-ID lost-ACK convergence, and fully revalidated public run/result snapshots now have PostgreSQL evidence.

    Implemented

  4. Assemble the provider-native Agent graph

    One recovered multi-turn tool path now composes transcript reconstruction, durable invocations, pinned policy and accounting, Driver, lifecycle, and exact cancellation.

    Implemented

  5. Freeze the first strict MCP Tool binding

    Modern stateless discovery, exact local schema/server pins, attempt credentials, and reconciliation-first lost writes now have executable contract evidence.

    Implemented

  6. Compose and qualify the protocol boundary

    Real PostgreSQL plus loopback MCP evidence now proves durable-before-dispatch state, unknown lost writes, no redispatch, and exact result reconciliation; runtime PostgreSQL evidence separately proves the error branch, while the pinned official inventory records the claim boundary.

    Implemented

  7. Separate the general MCP Tool client

    Bounded discovery, JSON/request-scoped SSE, custom headers, MRTR, and every frozen scored non-OAuth client scenario now pass without weakening the strict durable binding.

    Implemented

  8. Close the MCP OAuth boundary

    Challenge-driven metadata, registration priority, PKCE, issuer and callback validation, bounded scope/replay, durable stores, and all 25 scored OAuth scenarios now have executable evidence.

    Implemented

  9. Build the MCP Server profile

    Bounded stateless Tools, Resources, Prompts, Completion, MRTR, authorization-first policy, and all 37 scored official Server scenarios now have executable evidence.

    Implemented

  10. Publish static Skills over MCP

    Final SEP-2640 discovery and reads now share one immutable, size-bounded registry with exact raw-byte digests, canonical paths, private cursors, scoped cache rules, and authorization before disclosure. Client and host execution gates remain separate.

    Implemented

  11. Build the A2A 1.0 Server profile

    Bounded Agent Cards, messages, tasks, artifacts, streaming, cancellation, subscriptions, and push configuration now serve HTTP+JSON and JSON-RPC/SSE behind strict policy; 177 official TCK cases pass.

    Implemented

  12. Build the durable A2A Client boundary

    All eleven operations now run across HTTP+JSON and JSON-RPC/SSE with exact discovery/interface pins and bounded security; the Remote Agent adds PostgreSQL Unknown evidence plus operator-attested context/history lookup and message-ID replay.

    Implemented

  13. Make terminal A2A artifacts durable

    Accepted tasks now recover through direct no-resend polling, while bounded terminal parts converge on immutable PostgreSQL metadata and private, conditionally published, fully verified object bytes.

    Implemented

  14. Publish qualification evidence

    Run the frozen scenarios under load and failure, then publish compatibility, performance, and recovery evidence before support claims.

    Next
Open implementation status