Thinking System

Sovereign AI Framework

A copyleft, vertically integrated architecture for deploying AI systems that are sovereign, auditable, and extensible.

Build Contribute License

What is the Thinking System?

The Thinking System is the underlying software stack that powers Thunk. It's a collection of Rust libraries designed for building AI systems with explicit trust boundaries, verifiable behaviours, and complete user sovereignty.

Released under AGPLv3, the Thinking System ensures that modifications to the core remain open source while permitting broad use and integration. This copyleft license is freedom-preserving by design.

Six Foundational Layers

STEEL Kernel

The bedrock kernel, written entirely in Rust. Resource management, process scheduling, IPC, cryptographic primitives, and QUIC-based network optimisation.

STELE Cognitive Core

Multi-tier memory (episodic, semantic, short-term), self-documenting knowledge graph, NL-to-SurrealQL query generation, emotional-state aware retrieval.

SLEET Agent Runtime

29-opcode gas-metered bytecode VM, ephemeral Theatres for sandboxed execution, two-pass flow transpiler, WASM extension hosting via Wasmtime.

SCRIBES Trust & Policy

Twelve specialised Scribes mediate between ephemeral computation and durable state. Each owns a narrow semantic concern with programmable policies.

ESTEL Human-AI Interface

Translates between human intent and machine execution. Automatic visualisation selection, intelligent data transformation, natural language interaction.

ECON Economic Fabric

The GTR-Fabric: peer-to-peer task marketplace, network-aware scheduling, reputation ledger, dynamic pricing. Decentralised compute pools for distributed resources.

Key Crates

stele

Cognitive core—memory, knowledge graph, NLU, flows, Scribes

sleet

Agent runtime—flow DSL, transpiler, VM, orchestration

steel

Kernel—crypto, networking, scheduling

estel

Interface—intent capture, visualisation, transformation

The Twelve Scribes

Scribes are persistent guardians that mediate between ephemeral computation and durable state. They're the only entities authorised to commit to long-term storage.

SUPER_SCRIBE User relay

DE_SCRIBE System manifest

IN_SCRIBE Data lifecycle

TRAN_SCRIBE Multimodal transduction

SUB_SCRIBE Stream subscription

PRE_SCRIBE Planning

PRO_SCRIBE Policy governance

CIRCUM_SCRIBE Consensus mediation

CON_SCRIBE Composition management

POST_SCRIBE Post-processing

A_SCRIBE Identity & trust

E_SCRIBE Events & observability

Why Rust?

Rust provides memory safety without garbage collection, fearless concurrency, and zero-cost abstractions. For a system that handles sensitive data and runs untrusted code, these guarantees are essential.

The entire kernel (STEEL) and most core libraries are pure Rust. This isn't just a preference—it's a security requirement.

Extend the System

Flows

Declarative specifications of reasoning workflows. Graphs of semantic blocks transpiled to deterministic bytecode.

WASM Modules

Sandboxed complex logic via Wasmtime. Implement arbitrary integrations while remaining capability-scoped.

Adapters

Custom implementations for agents, LLMs, tasks, and services. Plug into the architecture without modifying core.

Policy Bundles

Versioned, signed governance rules. Define exactly how your Scribes evaluate persistence requests.

Getting Started

# Clone the repository
git clone https://github.com/thinksystem/thinkingsystem.git
cd thinkingsystem

# Build with Cargo
cargo build --release

# Run with configuration
TS_HTTP_ADDR=0.0.0.0:8080 \
TS_DATA_ROOT=./data \
TS_ENABLE_NLU=true \
cargo run --release

Start Building

Explore the codebase, read the docs, and join the community.

Build Contribute License