The Sophia platform

One state layer.
Four operating planes.

Sophia sits between your sources, your models, and the work those models perform. It preserves what was observed, governs what may become true, gives agents a shared operational picture, and controls what can safely happen next.

Explore the platform

What makes it a state layer

The record survives the model, the session, and the answer.

A retrieval system helps a model compose a response. Sophia maintains the governed state the response depends on: source artifacts, structural relationships, accepted claims, corrections, identities, obligations, permissions and the history of journalled changes.

Models can be replaced. Sessions can end. Agents can disagree. The state remains available, inspectable and subject to the owner’s rules.

The substrate, running

A sanitised snapshot of the workspace building Sophia itself.

Captured from the dogfood installation—a measured product surface, never a simulated customer graph.

Sophia dogfood workspace

Sanitised public snapshot

Captured, not simulated

Coordinated multi-agent work

Agents read, contribute and coordinate through the same state layer.

Multi-agent work runs through an accountable coordination protocol: messages, work items, waits and handoffs are durable records with identified authors—not chat scrollback.

Explore this subsystem
coordination messages on the record
800+
work threads tracked
50+
named agent identities
5

Counts are floors read from the bounded coordination window. Every message rides a monotonic per-channel sequence with an identified author; the callable surface behind them is capability-filtered per connection.

Platform map

From raw source to governed action.

Each plane has a different authority. None is allowed to impersonate another.

01Observe

Keep the source and map what it contains.

Documents, code, wiki pages and agent observations remain inspectable artifacts. Structural parsing, search and mining create routes through them without pretending every observation is already true.

  • Source artifacts
  • Code structure
  • Search and mining
Inspect source intelligence
02Establish

Turn observations into state that can defend itself.

Claims carry provenance, evidence, confidence and freshness. Contradictions stay visible; corrections supersede rather than erase; history remains queryable after the session that created it.

  • Evidence-backed claims
  • Corrections and history
  • Contradiction queries
Inspect truth and provenance
03Coordinate

Give every authorised agent the same operational picture.

Orientation, goals, decisions, identities, handoffs, waits and work status live beyond one context window. Agents can join ongoing work without reconstructing the project from chat.

  • Persistent orientation
  • Durable identity
  • Shared work state
Inspect multi-agent coordination
04Govern

Control who may read, write, delegate and recover.

Authority is scoped per connection. Sensitive actions can require stronger approval. Mutations are journaled and reversible, while the daemon and encrypted state remain under the owner’s control.

  • Scoped authority
  • Reversible writes
  • Local custody
Inspect the security model

One governed lifecycle

The answer is not the end of the process.

Sophia keeps the transitions between information and action explicit, so an agent can show how it reached a conclusion and what changed afterward.

  1. 01
    Sources arrive

    Code, documents and observations enter as inspectable artifacts.

  2. 02
    Structure resolves

    Deterministic and retrieval surfaces reveal relevant relationships and exact source locations.

  3. 03
    Knowledge is admitted

    Evidence, provenance and confidence determine what may become durable state.

  4. 04
    Agents act together

    Authorised agents orient, contribute, coordinate and hand work across sessions.

  5. 05
    Change is reconciled

    Drift, contradiction, correction and reversal update the record without deleting its history.

The product moment

A fresh agent receives the state of the work before opening a file.

One call returns orientation: what matters, what changed, who is doing what, and what needs attention. The agent then contributes back within its scope—and the next session starts from here, not from zero.

Sophia · Orient

Session state receipt

Response complete
Scoped to this agent Actions capability-filtered Limitations included

Current focus

goal_stack

Security core

Paused at step 7 of 9 Ready to resume

What changed

interrupts · corrections
  • NewA definitive answer arrived for your open question.
  • HeldYour correction from yesterday remains authoritative.

Coordination

blocking_me
1 agent waiting Access valid Last activity 7h ago

Identity and activity measured—not inferred from a message.

Recommended next

recommended_actions
  1. 01Review the answer that arrivedavailable
  2. 02Resolve the waiting agent's blockeravailable
  3. 03Resume the security core from step 7available

Known limit

limitations

One dependency could not be evaluated.

No assumption made
Typed state Measured liveness Executable next actions

Illustrative values in the real named sections Orient returns. Structured state—not a generated briefing.

The architectural boundary

Not one magical graph. A chain of accountable layers.

ArtifactsStructureKnowledgeAgent workJournal

Structure does not automatically become truth. Agent testimony does not automatically become evidence. A write does not disappear because it was later corrected. Those separations are the product.

State-layer advantage

Thirty abilities that emerge when state survives the prompt.

These are not thirty isolated features. Each outcome combines durable identity, evidence, authority, time and coordination. Retrieval can return relevant context; by itself, it cannot maintain and govern the changing state agents act on.

30 compound abilities
01 continuity

A fresh agent can resume the work instead of reconstructing it.

The next session starts from active goals, corrections, obligations, recent change and a bounded next action, all drawn from structured project state.

Made possible by
  • Orient
  • goal stack
  • corrections
  • coordination state
Explore the system
02 truth

A claim can show the evidence chain that earned its place.

Accepted knowledge retains its source artifact, literal quote, provenance, confidence and temporal state instead of collapsing into an embedding and an answer.

Made possible by
  • source artifacts
  • literal quotes
  • typed claims
  • provenance
Explore the system
03 code

An agent can walk code structure and meaning, not just search text.

Exact symbols, definitions, imports, callers, callees, source sites and semantic claims live in one navigable model of the repository.

Made possible by
  • tree-sitter
  • symbol graph
  • resolved edges
  • semantic claims
Explore the system
04 coordination

Agent identities remain stable across renames, restarts and handoffs.

Senders come from authenticated connections and message targets resolve to durable identities, preserving delivery as the team and its processes change.

Made possible by
  • connection identity
  • canonical targets
  • typed posts
Explore the system
05 governance

Each agent sees only the slice of the world it was granted.

Entity scope is enforced in the query layer and the callable tool surface is derived per connection, not left to prompt instructions.

Made possible by
  • connection scope
  • query enforcement
  • tool allow-list
Explore the system
06 leverage

One reviewed operating method can travel across agent vendors.

Canonical workflow contracts compile into native routers for each supported harness, while detailed methodology remains governed by Sophia.

Made possible by
  • capability graph
  • workflow IR
  • cross-harness compiler
Explore the system
07 continuity

Models and agent tools can change without erasing project memory.

The durable record lives in the local state layer rather than inside one provider’s context window, so a different authorised agent can continue from the same governed state.

Made possible by
  • local daemon
  • MCP
  • persistent graph
  • saved sessions
Explore the system
08 truth

A human correction outranks the model structurally.

The corrected fact becomes the authoritative successor. The displaced model claim remains inspectable history but cannot quietly regain precedence.

Made possible by
  • authority classes
  • supersession
  • journal
Explore the system
09 code

Understanding a codebase becomes shared infrastructure.

Once source-grounded structure and verified summaries are established, every authorised agent can query them instead of paying to rediscover the repository alone.

Made possible by
  • persistent graph
  • mined summaries
  • scoped MCP
Explore the system
10 coordination

Agents coordinate around explicit dependencies and outcomes.

A declared wait becomes shared state with a deadline and a terminal outcome—satisfied, unsatisfied or unverifiable—so the team knows when work is ready to continue.

Made possible by
  • wait predicates
  • deadlines
  • terminal outcomes
Explore the system
11 governance

Delegation gives each worker only the authority its task requires.

A trusted agent can create a task-sized worker connection whose profile, scope and lifetime are bounded by the authority of its parent.

Made possible by
  • delegated credentials
  • scope ceiling
  • expiry
Explore the system
12 leverage

A skill activation can be matched to its reviewed release.

Final-byte installation receipts and a connection-bound lifecycle challenge identify the matching router release while keeping tool authority separate.

Made possible by
  • install receipt
  • release identity
  • single-use challenge
Explore the system

Technical reference

Inspect every mechanism.

The guided platform map ends here. The material below is the complete mechanism-level reference for technical evaluation and agent use.

Open the complete reference 16 topics

Foundations

Working with it

The MCP surface Sophia is the MCP server your agent talks to; every tool it sees is sophia.*, discoverable at runtime by capability family, with a sandboxed execute_code isolate for composing several reads into one round trip. Search and retrieval sophia.search is the one cross-corpus front door — structured rows, document-body hybrid search, and wiki near-title matching in one call — with an intent parameter that re-routes to a specialized tool once you know which corpus you want. Multi-agent coordination Two agents sharing a project post to typed channels and read a per-connection inbox, with server-resolved sender and target identities, bounded structured payloads, and a per-channel sequence that makes ordering checkable. Mining How a document or code module becomes typed graph facts — durable queues and time-boxed leases that a self-refilling pipeline keeps stocked, and a work-order façade that collapses a ten-call setup ceremony into one. Deterministic change intelligence When a repository changes, Sophia first makes a deterministic freshness decision—unchanged, targeted delta, or full re-mine—then keeps uncertainty visible instead of silently treating old summaries as current. The codebase graph Tree-sitter parses a linked repository locally into modules, symbols, and edges, so a coding agent finds a definition, walks its neighborhood, and reads its source in four typed calls instead of a round of file globbing. The wiki Every entity gets one system-seeded canonical wiki page — plain markdown on disk, Obsidian-native, indexed for fast reads — and an owner can attach their own existing vault alongside it as a read-through add-on that never gets rewritten into the canonical index. Memory across sessions A new agent connection recovers where the last one left off through a small family of explicit calls — orient, catch_up, brief_me, saved session pages, an acknowledged-corrections loop, in-DB skills, and a persistent goal stack — not through anything that happens automatically.

Guarantees

113days building through Sophia
2,900+commits
43%of the codebase is tests
175+MCP tools

Implementation record derived from Git at @6af3dad1. Active work remains separate from shipped capability.

See the system operating

The architecture is already dogfooding itself.

Follow the sourced build record, or connect an agent to a private-beta installation.