StateKnot
On this page Architecture map What exists, what is active, and what is planned On this page Current cut Implemented slices and explicit gaps On this page Repository quickstart Clone and run the validation suite On this page Road ahead The path from contracts to a qualified v1 Repository Source code StateKnot/StateKnot on GitHub Repository Architecture contracts RFCs, scope, scenarios, and operations notes Repository Security policy Private vulnerability reporting and support policy
↑↓ navigate ↵ open 7 results

Pre-alpha · no stable public API

Durable agent orchestration, written for Rust.

StateKnot is building typed graph execution and PostgreSQL-backed recovery around explicit durability contracts. The runtime loop and protocol adapters are still under development.

Read the contracts Inspect source
Repository validation
$ 

$ cargo test -p stateknot-store-postgres \
    --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, journal, checkpoints, invocations

Graph execution

Implemented slice Barrier contracts Immutable results and successor checkpoints
In progress Runtime loop Routing, reducers, dispatch, retry wakeups

PostgreSQL durability

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

Protocols

Planned MCP adapters Client and server boundaries
Planned A2A adapters REST and JSON-RPC client/server

Operations

Planned Control plane Policy, tenancy, budgets, graph registry
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 crate is intentionally unpublished. Today’s honest quickstart is for contributors reviewing the implementation and its failure semantics.

Read the contribution contract
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.

Protocol breadth comes after one end-to-end durable path survives crashes, retries, stale workers, and lost acknowledgements.

  1. Close the durable execution path

    Finish route, reducer, successor, retry-wakeup, and barrier dispatch semantics around the existing recovery evidence.

    Now

  2. Ship a runnable agent loop

    Bind model and tool execution to durable attempts without weakening the core contracts or holding database transactions across external work.

    Next

  3. Add protocol adapters

    Map MCP and A2A wire models into versioned internal types, with policy and tenant boundaries enforced at admission.

    Planned

  4. Publish qualification evidence

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

    Before v1
Open the complete roadmap