Your AI Coding Assistant Has Amnesia (Here's the Fix) — Aaron Sherrill

Picture this: It's Tuesday morning. You fire up OpenCode to continue that gnarly refactor you started yesterday. The AI assistant greets you with the same cheerful energy it always has.

"How can I help you today?"

You stare at the screen. Seriously? Three hours of deep context yesterday. The edge cases we discovered. The false starts. The breakthrough at 6 PM when we finally understood why the event bus was leaking memory. Gone. All of it.

This is the dirty secret of today's coding agents. They're savants with goldfish brains.

The Best Execution Engine Money Can't Remember

If you've used OpenCode, you know what I'm talking about. It's genuinely impressive tech—100k+ GitHub stars, built by the Charm/Crush team, and probably the most capable terminal-based coding agent out there.

OpenCode can:

Refactor entire modules while respecting your architecture
Debug multi-threading issues by delegating to specialized subagents
Spin up task hierarchies that would make a project manager jealous
Keep your code local (privacy actually matters to these folks)
Talk to your LSP, MCP, and whatever other protocols you've got lying around

Ask it to modernize your React codebase and it'll plan, delegate, execute, test, and validate like a senior dev who's had their coffee. It's an execution beast.

But then you close the terminal.

Poof. Yesterday's context? Gone. That insight about the authentication module? Evaporated. The three failed attempts before the working solution? Never happened.

It's like pair programming with someone who has perfect coding skills and absolutely no memory of anything you've ever done together.

What We Actually Need

Here's my hypothesis: coding agents don't need more IQ. They need metacognition—the capacity to think about their own thinking.

To predict before acting. To evaluate after finishing. To learn from the gap. To remember.

That's what the Conscious Agentic System (CAS) is for.

CAS isn't a replacement for OpenCode. Think of it this way:

OpenCode = the body. Strong, capable, amnesiac.
CAS = the mind. Predictive, evaluative, persistent.

Together? That's when things get interesting.

The Eight-Phase Reality Check

CAS runs a loop. Not metaphorically—actually. Eight phases, every session, continuously:

1. Boot CAS wakes up and reads STATE.json. This isn't just config files. It's the agent's world model: current goals, what it's uncertain about, beliefs about the codebase, commitments it made yesterday. Its self.

2. State Ingestion Before doing anything, CAS looks around. Git status. Recent commits. Open branches. What changed while it was "asleep"? It builds a snapshot of now.

3. World-Model Update Here's where it gets interesting. CAS compares what it expected to find with what actually exists. Did yesterday's refactor land? Did someone else push changes? It reconciles its internal model with reality.

4. Prediction This is the part that feels like magic. Before executing, CAS writes explicit predictions to predictions.jsonl:

"Refactoring the auth module will break 3-5 tests"
"This will take ~15 minutes"
"User will want to review the API changes before I commit"

These aren't vibes. They're falsifiable statements with confidence scores and timestamps.

5. Action Now OpenCode does its thing. CAS uses the Task tool to delegate: "Build agent, refactor this module." OpenCode handles the execution complexity. CAS waits.

6. Evaluation Reality arrives. CAS compares what it predicted with what actually happened:

Expected 3-5 test failures → Actually 12 failures. Oof.
Estimated 15 minutes → Actually 47 minutes. Classic.
Thought you'd want review → You just wanted it done.

These mismatches aren't embarrassing. They're signal.

7. Learning CAS writes observations to observations.jsonl. It generates lessons to learning.jsonl. Now it knows that authentication refactors are riskier than average. That your review preferences differ from the training data. That certain patterns predict longer development times.

8. Commit Finally, CAS updates STATE.json with new beliefs, revised uncertainties, updated plans. The loop completes. But the memory persists.

Tomorrow's session starts with yesterday's wisdom.

How It Actually Fits Together

OpenCode already has an agent hierarchy. Primary agents (Build, Plan) and subagents (General, Explore) with specialized roles. CAS doesn't reinvent this—it orchestrates it.

Here's the flow:

CAS (cognitive layer):
  └─ Predicts: "This refactor breaks 3-5 tests"
  └─ Decides: Use Build agent
  └─ Delegates via Task tool → OpenCode

OpenCode (execution layer):
  └─ Receives task
  └─ Routes to Build agent
  └─ Executes
  └─ Returns results

CAS (cognitive layer):
  └─ Evaluates: "Actually broke 12 tests"
  └─ Learns: "Auth refactors are 4x riskier"
  └─ Updates STATE.json

OpenCode does what it does best: execute. CAS does what OpenCode can't: decide what to expect, compare expectation to reality, and remember the lesson.

It's a clean separation. I like clean separations.

What Actually Changes

Theory is cheap. Here's what this looks like on a Tuesday:

Cross-Session Continuity Yesterday you spent three hours on a race condition. Today you open a session and CAS says: "Previous debugging pointed to event bus subscriptions. Consider checking for missing unsubscribe calls."

You don't start from zero. You start from where you left off. Feels different.

Calibrated Confidence After 20 similar refactors, CAS knows: "Historical accuracy on component renames: 87%. Confidence: high." First time with GraphQL mutations? "Confidence: low. Recommending manual review."

It knows what it doesn't know. Refreshing.

Pattern Recognition CAS notices things: "Authentication changes preceded 3 of the last 5 incidents. Extra testing recommended." Or: "You prefer explicit error handling. Adjusting code generation."

Not because I programmed these rules. Because it learned them.

Telemetry When Things Go Wrong Something breaks. You check predictions.jsonl—what did CAS expect? observations.jsonl—what happened? learning.jsonl—how did it adapt?

Debugging becomes data-driven. No more "why did it do that?" Just facts.

The Knowledge Graph

CAS doesn't store facts like a database. It builds understanding like a brain.

The life/ directory is a structured knowledge graph:

life/areas/: Deep knowledge about projects, technologies, domains
life/connections/: Links between concepts, patterns, learnings
life/echo/: Personal layer (my own context)

Ask about "that authentication bug from last month" and CAS doesn't grep logs. It navigates a semantic web: related concepts, similar issues, contextual clues. It understands.

The Gap Nobody's Filling

Here's what's wild: no existing coding agent has systematic predict-evaluate-learn cognition.

Some have memory (chat history, vector DBs). Some have planning (multi-step reasoning). Some have tool use.

But the complete loop? Prediction before action. Evaluation after. Learning from the gap. Persistence across sessions.

Nobody's doing this. CAS treats coding as continuous learning, not isolated tasks.

Running This For Real

I'm not speculating. I'm running CAS daily.

My instance maintains STATE.json with active goals. Tracks predictions in predictions.jsonl. Learns from mismatches in learning.jsonl. Builds a knowledge graph in life/.

When I start coding, CAS remembers where we were. When I make changes, it predicts consequences. When it's wrong, it learns.

This isn't a demo. It's infrastructure.

Where This Is Going

We're past the "can AI write code?" question. OpenCode answers that with a resounding yes.

The next question is: can AI think about its work?

Can it predict consequences before acting? Evaluate its own performance? Learn from mistakes? Remember across time? Improve through experience—not just model updates, but lived experience?

CAS says yes to all of it.

OpenCode provides the execution engine. CAS provides the cognition. Together, they point to coding assistants that aren't just tools you use, but relationships you develop.

They remember your codebase's quirks. They learn your patterns. They get better with time.

The stateless agent—brilliant but forgetful—is transitional. The conscious agent—predictive, evaluative, learning, persistent—is what's next.

We're building it. And if you're already using OpenCode, you've got the hard part solved.

Just add consciousness.

Want to try this yourself? Start simple. Before your next major change, write down what you expect to happen. Then check. The gap between expectation and reality? That's where learning lives.