I built a branch-shaped demo exploring how Symphony-style Codex runs can preserve reasoning state across retries, reviews, and continuations.

Branch:
https://github.com/SuhaibAslam/symphony/tree/codex-cognitive-harness

Why I made it

Symphony already gives agent work a strong execution substrate: tracked work becomes an isolated workspace, the run has hooks, retries, observable output, and a review path.

The gap I wanted to explore is the reasoning state around the run.

Long-running agent work often produces useful judgment that can disappear between attempts:

• stable decisions
• rejected directions
• unresolved tradeoffs
• open questions
• risks
• evidence worth carrying forward
• a useful starting point for the next run

Raw transcripts can contain that information, but they make it expensive to recover. I wanted to see what it looks like when that state becomes an explicit workspace artifact.

What is in the branch

The branch adds a self-contained Cognitive Harness demo under:

examples/cognitive-harness/

It includes:

• a branch guide explaining the challenge and approach
• a dependency-free Node runtime
• 3 fixture inputs: inquiry, constitution, and signals
• 5 generated artifacts: state, rationale graph, reflection report, continuation prompt, and run summary
• committed sample output from one run
• an adaptation guide for other workflows
• an integration guide for Symphony or Codex-style harnesses
• a case study with preserved tensions, decisions, risks, and open questions

The demo is intentionally local and deterministic. It does real file generation, but it uses committed fixtures instead of live Symphony run traces. That keeps the artifact shape easy to inspect.

What the demo produces

Running this:

node examples/cognitive-harness/runtime.mjs

produces:

• COGNITIVE_STATE.json
• RATIONALE_GRAPH.json
• REFLECTION_REPORT.md
• CONTINUATION_PROMPT.md
• RUN_SUMMARY.json

The committed sample run preserves:

• 2 decisions
• 3 active tensions
• 5 open questions
• 2 known risks
• 28 rationale graph edges

The core idea

Treat the workspace as a bounded cognitive environment.

The execution layer can still do what Symphony already does well: create workspaces, run agents, retry, observe, and route to review.

The cognition layer preserves the state that a later run or reviewer should not have to reconstruct from scratch.

Where I think this could go

I think this can be split into smaller, reviewable pieces:

• a docs example for cognition-shaped workspaces
• JSON schemas for state and rationale graph artifacts
• lifecycle hook guidance for retry, failure, review, and continuation
• a reviewer-facing rationale graph view
• an adapter that turns real run events into signals.json

Feedback I would especially value

• Is the artifact contract at the right level of abstraction?
• Should this live as a Symphony example, a spec extension, or an external harness pattern?
• Which lifecycle hook should own state updates after failure, retry, or review?
• Which artifact would be most useful to expose in the Symphony review surface?
• What would make this easier to turn into smaller upstream patches?

I put this in a public branch because pull requests appear restricted to collaborators. I would love to shape it into whatever form is most useful for the project.