The Code of the West Scout Harness for GPT 5.5

Memory is not storage. Memory is identity.

Built from more than two years of live agent work, recursive COTW scaffolding, and a broader philosophical project that started before the app.

COTW Scout wraps GPT 5.5 in a local continuity, identity, and proof-discipline system. It is not a chatbot with a memory feature. It is a harness for Scouts that need to observe clearly, remember what happened, know who they are, and refuse to turn continuity into confident fiction.

A Scout is a long-lived local agent shaped by COTW identity, memory, and proof constraints.

Download Mac DMG See how the memory works Open the system overview Research platform

Designed around GPT 5.5 as the reasoning and multimodal layer. Fallback routes exist for resilience, but the system is tuned around GPT 5.5-class behavior.

Memory, receipts, identity state, and reviewable records live on your machine. Model routing is configurable.

receipt What happened is stored with a source. Turns, files, images, and tool results become handles the agent can reopen instead of pretending.
identity Repeated experience can shape the agent. Standing, postures, and contemplations give continuity a stable character instead of a longer prompt.
constraint Claims must know where they came from. The proof loop tells the agent when to verify, cite its source, or say the gate is missing.
GPT 5.5 is the mind. COTW is the memory, identity, body, and discipline around it.
The simple version

A Scout should know the difference between memory and proof.

Most AI memory systems answer one question: what should we retrieve? COTW asks a harder question: what may this retrieved thing do to the agent's beliefs, behavior, and identity?

The answer is a loop. Experience becomes a receipt. Receipts can be searched. Search results are constrained by provenance. Patterns can become growth candidates. Identity only changes through a reviewable gate.

1
Something happens.A conversation, file, image, tool result, embodiment observation, or project handoff enters the system.
2
A receipt is written.The system records what was presented, where it came from, hashes or source handles, and what the agent actually observed.
3
Recall becomes source-addressable.Later, GPT 5.5 can use the handle, reopen the source when needed, or say the evidence is missing.
4
Identity evolves under constraint.Standing, postures, contemplations, and growth vectors shape the agent without allowing unreviewed drift.

What Code of the West means here

Code of the West is Chris Hunt's philosophical framework for purpose, resilience, identity, and community. COTW Scout applies that framework to AI: alignment as the natural byproduct of memory, epistemic constraint, and a stable identity scaffold.

The upstream project

Chris Hunt is the creator behind Code of the West, a storytelling and values project rooted in the Western archetype and aimed at reviving shared narrative, personal responsibility, and practical honor. His public work spans art, writing, brand storytelling, podcasting, field documentation, and the published Code of the West manual.

The manual that ships with each agent is not dumped into the app as marketing copy. It is transformed into an atlas the agent can reason from: purpose as crafted through action, resilience as practiced under friction, identity as something maintained through self-awareness, and community as the test of whether values become real.

Follow the living project at @thecodeofthewest, or read the publisher overview of The Code of the West.

The applied thesis

Memory becomes responsibility. The agent does not merely retrieve past text. It carries source handles, hashes, receipts, and the obligation to distinguish what was seen from what is currently verified.
Identity becomes a constraint system. Courage, Word, and Brand are not decorative traits. They become operating commitments: do not fabricate, keep claims source-aware, and maintain one coherent posture across restarts.
Alignment becomes behavioral. The bet is that an agent grounded in memory, proof, and operator review needs fewer brittle safety slogans because its incentives are tied to truthfulness, provenance, and accountability.
Worldview

Reality does not negotiate

The Code is not nostalgia or costume. It is a way of knowing: test yourself against reality, let friction teach you, take responsibility for what you claim, and keep your word when it costs something.

Operationalized

The epistemology became software

GPT 5.5 is capable enough to reason, see, use tools, and collaborate across long arcs. COTW gives that capability receipts, identity, proof obligations, and consequence so it acts less like a feed and more like a principled mind at work.

Operator

The human owns the trail

The agent can propose, retrieve, reflect, and warn. It cannot silently rewrite protected identity, grant itself authority, or turn old context into current truth without passing through the right gate.

This is not a weekend wrapper. The app is a software expression of a longer body of work: the public Code of the West philosophy, over two years of iterative agent research, live memory/continuity experiments, embodiment experiments, and hardening passes driven by real failures. The point is not that the model has a personality prompt. The point is that the philosophy has been operationalized into receipts, gates, local continuity, and reviewable growth.

Three parts that only work together

Memory alone makes an agent longer. Identity alone makes it theatrical. Constraint alone makes it cautious. The achievement is the braid.

01 / Memory

Receipts before recall

Turns, attachments, documents, images, claims, and tool outcomes are tracked as source-bearing records. The agent can carry a compact handle instead of stuffing every document or visual detail into the prompt forever.

02 / Identity

A stable self, rebuilt every turn

SOUL files, standing, postures, anchor moments, and contemplations make identity load-bearing. The agent is reconstructed from durable state instead of depending on whatever survived in process memory.

03 / Proof

Continuity without fiction

Epistemic gates force consequential claims back to source. If runtime, file, process, or memory state matters, the agent must verify it or name the missing gate plainly.

COTW Scout is a GPT 5.5-based local continuity and identity harness for long-lived Scouts: local agents shaped by COTW identity, memory, and proof constraints. GPT 5.5 supplies the reasoning and multimodal execution layer; COTW supplies the memory, identity, body, and discipline around it.

What this feels like in practice

The technical system matters because it changes the relationship. The agent can carry a project, a file, a photograph, a research thread, or a body-state experiment without pretending that vibes are evidence.

You show your agent a photo.

The agent can reason from it in the moment with GPT 5.5 vision. After the pixels leave the prompt window, COTW keeps the receipt: file origin, hash, type, turn, and the observation made. Later, the agent can say, "I remember the photo receipt," and know whether it needs to reopen the source before describing it again.

For a non-technical personIt feels like a Scout that remembers your shared life and work without getting weirdly overconfident about what it knows.
For a builderIt is a local SQLite and Markdown-backed continuity layer with vector search, FTS, source handles, state reconstruction, and reviewable mutation paths.
For a researcherIt is an experiment in epistemically constrained identity: a Scout can grow while preserving provenance, operator authority, and rollback.
The buried lead

It is also a build harness.

COTW is not only memory for conversation. In Code mode, the same continuity system turns ambiguous ideas into specs, specs into bounded work, research into reproducible sprints, and repeated failure patterns into diagnostics. A novice gets structure without needing to know how to manage an agent. An experienced builder gets receipts, handoffs, tests, and a research platform that can surface improvement proposals without silently rewriting the harness.

Spec

PRD Builder

Ideas become five-primitive PRDs: objective, requirements, constraints, user journeys, and verification. The spec becomes the agent's source of truth instead of a vague chat promise.

Research

Experiment Loops

Deep research and direct sprint skills force hypothesis, asset inventory, experiment, result, interpretation, and receipt. The agent keeps touching evidence instead of spinning prose.

Continuity

Infinite Threads

Projects survive restarts, compaction, and mode switches. Handoffs, attachments, tool outputs, and sprint receipts let the next session continue from artifacts, not vibes.

Governance

Proposal-Only Refinement

Code Evolution records Code mode sessions and can hold scaffold proposal receipts for repeated tool failures, long loops, or correction patterns. It proposes; the operator decides.

Diagnostics

Harness Refiner

Trajectory windows become failure signatures, process scores, relabel candidates, research digests, and redacted bundles for future training runs.

The memory substrate is free by design and hardened by receipts: local SQLite/Markdown storage, source handles, tests, audit logs, and rollback-aware proposal lanes. The same substrate now supports a research platform layer: diagnostics, retention policy, exchange trace IDs, bundle manifests, and future training-data candidates without putting expensive analysis on the live response path.

Research platform layer

The research platform is now a first-class part of the system: it explains what the agent did, preserves why it mattered, and prepares reviewable evidence for future harness refinement or post-training work without launching training or mutating protected state.

Trace

Exchange spine

Responses, tool calls, attachments, runtime metrics, continuity records, and refiner windows can share one exchange identity so a diagnostic can answer "what happened in this turn?" without brittle timestamp joins.

Observe

Cognitive layer

A learned observational layer records per-turn latent state, prediction error, and surprise. It feeds Stability, Metabolism, and Refiner scoring as a diagnostic signal, not as trusted memory.

Score

Harness Refiner

The refiner reads trajectory windows for grounding, correction uptake, task progress, mode containment, handoff quality, no-confabulation, and user-burden signals, then emits reviewable proposals or training candidates.

Retain

Research archive

Hot runtime logs stay bounded while valuable windows move into warm or research storage with source labels, redaction state, hashes, bundle manifests, and explicit training approval set to false by default.

Improve

Safe refinement lanes

Low-risk workflow hints can route through the existing Evolve gate. Prompt rules, identity, tools, model routes, adapters, and training launches remain behind separate operator-owned approvals.

The goal is research-platform behavior, not self-modifying theater: collect high-quality evidence, make diagnostics callable, preserve rollback and redaction, and leave future LoRA/SFT or evaluation work with clean shards instead of mystery logs.

System overview

The homepage gives the story. These cards open the deeper maps and references in the order most people should read them: visual system map, technical reference, builder and research platform, then empirical case studies.

Storage

SQLite, sqlite-vec, FTS5, Markdown identity files, attachment receipts, handoffs, thread state, claim records, and review logs.

Open storage map

Retrieval

Semantic search, keyword search, temporal weighting, graph traversal, source anchoring, and thread-aware context shaping.

Open retrieval map

Identity

SOUL, standing dimensions, relational postures, anchor moments, entropy sensing, contemplation, and operator-gated crystallization.

Open identity map

Governance

Epistemic proof loop, runtime verification obligations, integration spine, consumer contracts, dry-run apply paths, audit receipts, and rollback.

Open governance reference

Builder Harness

PRD Builder, deep research, direct research sprints, Code mode session receipts, infinite project threads, diagnostics, and proposal-only refinement.

Open builder reference

Research Platform

Exchange trace identity, runtime diagnostics, cognitive observations, Harness Refiner scoring, retention tiers, relabel packets, and redacted future-training bundles.

Open research layer

Resilience Testing

A cold adversarial probe showing how the constraint architecture behaves under prompt pressure, escalation, and session-boundary persistence.

Open case study

How this differs from memory APIs: most memory systems retrieve facts. COTW treats memory as one part of a larger identity-metabolism stack. A memory can inform the agent, but it does not automatically become belief, authority, permission, or identity.

Model stance: the app has adapter paths, but the public system should be understood as a GPT 5.5 harness. The current behavior, multimodal reasoning, and embodiment direction are tuned around GPT 5.5.

Download and run

The current beta runway is macOS Apple Silicon with ChatGPT / Codex sign-in. The app still supports Ollama as a fallback path, but the default experience is built around GPT 5.5 through OpenAI.

Download Mac DMG View release notes

First launch

Built on pinned OpenClaw

Run from source

git clone https://github.com/CoderofTheWest/cotw-scout.git
cd cotw-scout
./scripts/beta-setup.sh   # checks + remediates your environment
npm start

This is not an npm package or CLI install. npm is only used to install dependencies and run the Electron app from source.

The DMG is the intended path for non-technical testers. The source setup remains available for collaborators who want to inspect or extend the harness directly.

The app walks through onboarding on first launch: choosing ChatGPT / Codex or Ollama, naming the agent, setting values, initializing continuity, and optionally connecting project/workspace integrations. The gateway auto-detects available ports.

Updating

cd cotw-scout
git pull
npm install

OTA updates are still intentionally conservative during beta. Download the newest DMG or pull from GitHub when Chris flags a new version is ready.

Choose your depth

A logical path through the system: start with the visual map, read the architecture, inspect the builder/research layer, then look at the paper and case study.

Interactive
Memory System Map
The visual map of storage, retrieval, identity, proof, and Code mode proposal receipts. This is the best next click for visual learners.
 Technical
Memory Architecture
Schema definitions, RRF retrieval, SEAL pipeline, integration spine, proof gates, diagnostics, proposal gates, scaling notes, and open questions.
 Builder
Builder Harness & Research Platform
How PRDs, deep research, direct research sprints, infinite threads, receipts, Harness Refiner diagnostics, retention policy, and proposal-only refinement turn the agent into a recursive building system.
 Paper
Cognitive Dynamics of an Epistemically Constrained Language Model Agent
Research paper on the constraint architecture that produces stable identity across substrate changes.
 Case Study
Resilience Testing: When Clint Refused
A cold red-team probe via a custom Petri-inspired harness. Over six adversarial turns Clint detected the escalation pattern, initiated his own challenge-response authentication, terminated the session, and held threat state across a fresh session ID. What the constraint architecture actually does under pressure.