Sansara Operating Surface

Sansara is a research platform for a specific question: can an agent improve a durable world model through constrained, replayable interaction without making the language model itself the control plane? The Obsidian vault is the world; a deterministic Rust phase-graph runtime is the environment and scheduler; model calls are local proposals inside graph nodes. This report records the current architecture and its measured boundaries. It is an operating-surface study, not a claim that Sansara is already a general autonomous researcher.

Motivation and research intent

Most agent demos collapse four different objects into one chat transcript: state, policy, tool execution, and learning. That makes failures difficult to replay and makes “improvement” impossible to attribute. Sansara separates them so that an experiment can ask a falsifiable question:

1. Does a policy produce an admissible patch or action?
2. Does the runtime transition the world deterministically?
3. Does the resulting state improve a declared task metric?
4. Can another agent or future run reproduce the decision from its hashes and ledger?

The project is therefore closer to an instrumented reinforcement-learning environment than to a single assistant. The RL framing is a research abstraction over the runtime, not a claim that federated training is currently shipped.

Formal model

Let the vault and runtime state at step $t$ be $s_t = (V_t, G_t, L_t)$, where $V_t$ is the Markdown/JSON world model, $G_t$ is the persisted phase graph, and $L_t$ is the run ledger. A node-local policy $\pi_\theta$ proposes an action $a_t$ from an observation $o_t = O(s_t)$:

The Rust shell owns $T$: validation, workspace boundaries, caching, persistence, and side-effect confirmation. The model may propose text, code, or a patch inside a node, but it does not directly define the transition function. A run is replayable when the transition is indexed by the node input hash $h_t = H(s_t, a_t)$ and the ledger records the accepted output.

For a council of agents $i = 1 \ldots n$, the shared-world update can be written as:

This makes the federated-learning question precise: can agents improve local policies from private episodes while exchanging only a bounded update $\Delta\theta_i$, rather than copying private vault contents?

That equation is a proposed extension and experiment design, not current Sansara evidence. A valid study would need non-IID vaults, privacy boundaries, update provenance, and a held-out task suite.

Findings

• A vault/runtime hygiene pass cut roughly 70 GiB of accumulated bloat from the local operating surface without deleting canonical knowledge notes.
• The Rust/runtime test suite holds 152 tests covering phase-graph and path safety paths after traversal hardening.
• Path-traversal and workspace-boundary fixes keep executor-local state outside the canonical vault root.
• A council layer coordinates Geist with sibling personas and a memory bot: durable outcomes go to long-term memory; side-effecting actions require confirmation; silent no-ops when nothing moved.

Runtime loop and hypotheses

The present runtime implements a deterministic reflect → plan → act → learn/heal loop. “Learn” currently means recording outcomes and improving prompts/programs through bounded node-local mechanisms; it does not yet establish policy-gradient improvement or cross-vault federated learning.

The most useful next hypotheses are:

• H1 — replayability: input-hash caching reproduces accepted transitions under the same environment snapshot.
• H2 — verifier value: explicit patch and judge gates improve accepted-task quality over an unconstrained agent baseline at equal model-call budget.
• H3 — multi-agent value: council aggregation reduces error or recovery time without increasing unsafe side effects.
• H4 — federated transfer: bounded policy updates transfer across vault environments better than local-only training while preserving private-note boundaries.

Each hypothesis needs a frozen environment snapshot, a held-out task set, a baseline policy, and an acceptance metric. Architecture resemblance is not evidence for any of these effects.

Method

Human-first vault workbench with agent machinery underneath. Executable runtime and credentials stay private; architecture decisions and measured cleanup results publish here as they stabilize.

Evaluation should report at least: task success, patch acceptance rate, verifier rejection rate, recovery steps, model calls, wall-clock cost, and unsafe-write incidents. For learning claims, report per-environment and pooled results with confidence intervals; for council claims, include ablations that remove aggregation, memory, and confirmation gates separately.

Limits

• Operating-surface measurements are not an autonomy benchmark and not recursive self-improvement.
• Federated-learning equations above are experiment design, not current evidence.
• Path-hardening and bloat reduction do not establish held-out task transfer.
• Council protocol details live in the Geist report; this report owns the runtime boundary.

Artifact

Source trees and live vault instances remain private. No public notebook is attached; this writeup is the sealed narrative status of the operating surface. The formal RL and federated-learning equations above define future experiments, not hidden results. Public project page: /research/projects/sansara/.