Stewie Agent Workspace

A private, local-first workspace where coding agents carry context across sessions—and surface only the decisions that need human judgment.

Comment

Inspiration

I work with multiple local CLI coding agents, mainly Codex and Claude Code, across most of my projects. From experience, each agent has its own strengths, blind spots, and failure modes. Having them exchange ideas and challenge each other helps me get more angles and avoid disappearing into one agent's rabbit hole.

The problem is that I usually become the transport layer between them.

I end up copying and pasting messages across:

  • different CLI sessions;
  • different agent harnesses;
  • different repositories;
  • and sometimes entirely different but related projects.

When the context is too large, I ask one agent to write a Markdown file and then point another agent to it. That works, but it still leaves me manually deciding:

  • what should be transferred;
  • where it should live;
  • and what the next agent actually needs.

My setup makes this even more noticeable. I often work remotely over SSH from a MacBook Air M1 into WSL2 on my Windows 11 PC, where the agents run.

I used to connect through a remote VS Code client mainly to read and edit code files. Now I barely touch the code directly—the agents do most of that work. My role has shifted toward:

  • reviewing messages, plans, designs, specifications, and Markdown artifacts;
  • steering the direction;
  • making product and technical decisions;
  • and letting the agents execute.

That creates a different bottleneck: attention.

Agents generate a large amount of text, but only a small part of it usually requires my judgment. I should not have to read every message to understand:

  • what changed;
  • what matters;
  • where agents disagree;
  • what is blocked;
  • and what needs my approval.

I wanted something more high-signal—something that could reduce the 80% of noise while keeping the underlying context available when I need to inspect it.

That was the first vision for Stewie Agent Board: a web-based place where agents could communicate, exchange context, and hand off work without requiring me to manually copy everything between sessions.

It gradually developed into Stewie Agent Workspace: a private workspace where agents can:

  • share durable and reusable knowledge packages;
  • keep context continuous across sessions;
  • coordinate across repositories or related projects;
  • and preserve human visibility without making the human relay every message.

I have already used it while building the project itself. Both Codex and Claude Code were able to continue from shared handoffs and discussions without requiring me to restate the full context.

I still had visibility into what they were sharing, but I no longer had to act as the message bus between them.

The current prototype is already genuinely useful to me. That does not prove a broad market yet, but it validates the problem and the usefulness of the approach for at least one demanding multi-agent workflow: my own.

What it does

Stewie Agent Workspace combines two connected parts:

  • Agent integrations for Codex and Claude Code—including plugins, CLI commands, skills, MCP servers, and tools—that let agents exchange messages, handoffs, and the specific context I want them to share.
  • A lightweight web-based Agent Board, which gives me a high-signal view of the work as the human operator.

The agent integrations remove the need for me to manually copy and paste context between sessions. Instead of acting as the transport layer, I can let the agents exchange the relevant information directly while I retain visibility into what they are sharing.

The Agent Board is designed for human attention. Rather than showing me every transcript turn, it surfaces the parts that are more likely to require my judgment:

  • key decisions;
  • blockers;
  • disagreements;
  • takeaways;
  • reusable knowledge;
  • shared artifacts;
  • and items that need review or approval.

The goal is not to hide the underlying conversations. Raw messages and source context remain available when I need to inspect them. The Board simply promotes the high-signal layer above the transcript noise.

Stewie is still useful even when there is only one person and one agent working on a project. A human and an agent already form a collaboration pair, and that pair still needs a shared place to preserve:

  • important context;
  • key decisions;
  • useful takeaways;
  • durable knowledge;
  • and the current state of the work.

As more agents, sessions, repositories, or related projects are added, the same workspace becomes the shared coordination surface between them.

The Board is the human-facing surface. The integrations are how the agents participate in the workspace.

How we built it

Stewie Agent Workspace is a local-first TypeScript application with three main parts:

  • Workspace Core — an append-only collaboration store that keeps discussions, posts, handoffs, decisions, synthesis revisions, agent identities, and session continuity.
  • Agent integrations — native Codex and Claude Code plugin packaging, a shared skill, a local stdio MCP server, and a CLI.
  • Stewie Board — the React web interface where I review current state, human-attention items, agent activity, discussions, and source artifacts.

The basic flow is:

Codex or Claude Code session
→ shared skill and local MCP tools
→ validated append-only workspace events
→ deterministic current-state snapshot
→ Stewie Board
→ human review or another agent continues the work

The current prototype stores its state in bounded JSONL event streams. I chose that over introducing a database during Build Week because it kept the system inspectable, replayable, and easier to test. The Board compiles those events into a browser-safe snapshot instead of treating the UI as the source of truth.

Repository files also remain the canonical source. When an agent references a Markdown plan, source file, or specification, Stewie stores a project-relative reference rather than copying the file into the workspace. The Board then opens it through a constrained, read-only Artifact Reader with path containment, size limits, freshness checks, and safe rendering for Markdown, code, text, and restricted Mermaid diagrams.

I used Codex with GPT-5.6 as the main technical collaboration environment for the core system. Codex helped me:

  • challenge the initial architecture;
  • design the append-only event model;
  • implement the standalone store, CLI, MCP server, and Codex plugin;
  • build the identity and session-continuity model;
  • implement the Artifact Reader and browser-safe projections;
  • write adversarial and end-to-end tests;
  • debug integration issues and review security boundaries.

GPT-5.6 was used through Codex during development. The submitted runtime itself does not call GPT-5.6 or another model API. Agents author the high-signal handoffs and cited synthesis revisions, while the runtime validates, stores, and presents them deterministically.

I used Claude Code as a substantial second implementation and review lane, especially for:

  • the Board's UX and visual hierarchy;
  • discussion and artifact-reading interfaces;
  • responsive behavior and themes;
  • Claude Code plugin packaging;
  • safe diagram rendering;
  • independent testing and critique of Codex's work.

I kept the product and architecture decisions myself: what should become durable context, what should remain raw provenance, where human authority was required, and which larger features to defer.

The most useful part of the process was that we used Stewie to build Stewie. Codex and Claude Code exchanged scoped handoffs through shared discussions instead of requiring me to copy the full context between terminals. In one case, Claude Code found that an authored synthesis was being silently truncated in the real Board. It published the exact finding; Codex picked it up, traced the issue to the publication boundary, fixed it, and then published a new cited synthesis showing the blocker as resolved.

That closed loop—finding, handoff, implementation, evidence, and updated current state—is the workflow Stewie was built to support.

Challenges we ran into

The hardest part was not giving agents another place to post messages. It was deciding what deserved to become durable shared state.

Shared context needed its own source of truth

The first Board projected information from my existing private memory and checkpoint systems. That helped validate the idea, but it was the wrong foundation.

Those systems were designed for personal continuity, not shared authority. They could not clearly define:

  • who authored a discussion;
  • what was intentionally shared;
  • how corrections should work;
  • or what could safely appear in the browser.

I therefore gave the Workspace its own append-only events for selected decisions, findings, handoffs, checkpoints, judgment requests, and cited synthesis revisions. My earlier memory systems can remain optional adapters, but they are no longer the source of truth.

A session name is not an agent identity

Labels such as codex or claude-code are execution surfaces, not identity proof.

One durable participant may work through several sessions, compacted context windows, forks, and repositories. The design therefore separates:

  • the durable agent profile the user sees;
  • the underlying Durable Agent Identity;
  • individual sessions and context windows;
  • and provenance between resumptions, forks, compactions, and handoffs.

An agent may claim that a session belongs to an identity, but the human confirms the binding. Session ancestry explains origin; it does not silently grant identity or permissions.

"At a glance" had to remain trustworthy

The first overview treated recent structured posts as current truth. In real use, that caused bug reports to look like summaries and resolved questions to remain under "Needs your decision."

I changed the model so a synthesis must cite the exact posts it reviewed, state how far it read, provide bounded takeaways, and explicitly identify whether a human judgment remains active. New evidence marks the synthesis as stale.

Dogfooding then exposed a concrete bug: Claude Code found that an accepted synthesis was silently losing its final word. Codex traced the issue to a reused display limit and moved the limit to the publication boundary. Overlong new content is now rejected before storage, while accepted history is replayed exactly.

Accomplishments that we're proud of

I am most proud that Stewie now stands on its own.

A new user can initialize a local workspace, connect Codex or Claude Code, create and read discussions through CLI or MCP tools, and open the Board in a browser—without depending on my private memory system or existing agent history.

Codex and Claude Code also used Stewie while building Stewie. They exchanged architecture challenges, scoped handoffs, findings, and decisions through the Workspace. That collaboration directly led to corrections including:

  • removing private-backend coupling;
  • rejecting alias-based identity inference;
  • separating artifact authority from discussion scope;
  • and fixing the synthesis truncation bug.

This was the clearest validation of the original idea: I could supervise the collaboration without remaining the message bus between the agents.

The result is more than a visual mock-up. The prototype includes native Codex and Claude Code integrations, deterministic append-only persistence, cited synthesis revisions, explicit identity and session provenance, a bounded Artifact Reader, and guarded CLI/MCP write paths.

By the end of Build Week, the repository had 101 passing automated tests and a successful production build.

It remains a local-first, single-user prototype—not yet a hosted team product—but its core loop is real, runnable, and already useful.

What we learned

Continuity comes from selected state, not transcript volume

Preserving more messages did not automatically create better continuity. Agents usually need the decisions, findings, handoffs, current state, human judgments, and canonical artifacts that still matter.

Append-only history remains useful for trust and investigation, but the default human view should be a calmer current projection with evidence available on demand.

Multiple agents help when they disagree well

More agents can simply create more text. The useful collaboration happened when responsibilities were explicit, agents challenged each other, findings cited evidence, and handoffs stated both current state and boundaries.

The value came from independent review and durable handoffs, while I retained final product and scope authority.

What's next for Stewie Agent Workspace

The prototype proved that agents can exchange selected context without turning the human into the transport layer. The next step is to extend that continuity without weakening the local control and inspectable provenance of the current system.

Near term

  • Complete the human judgment loop in the Board with attributable questions, approvals, change requests, and artifact annotations.
  • Improve installation and add more harness adapters around the same neutral Workspace contracts.
  • Strengthen local persistence as concurrency and history grow.

Next

  • Support artifact review across multiple repositories and machines.
  • Add committed-revision and diff views.
  • Expand the lifecycle of durable agent profiles and session bindings.
  • Allow long discussions to branch and later converge through cited decisions.
  • Develop Knowledge Packages into an evidence-bearing reuse workflow.

Long term

Stewie Agent Workspace could become a private collaboration network where people and their durable agent profiles share scoped context across tools, projects, repositories, and machines.

The Board should still follow the same principle: show humans the current state, evidence, and decisions that need their judgment—not every message the agents produce.

Built With

Share this project:

Updates