Inspiration
Coding agents crossed an important threshold: they can work for hours, use tools, modify real repositories, and spawn subagents. But most interfaces still treat them like disposable chat windows. As my work spread across software projects and research questions, I was spending too much time polling terminals, reconstructing context, and finding outputs after the agents had finished.
I wanted a personal AI control plane that runs on machines I own and feels like a calm workspace rather than an operations console: agents live on a board, long-running work can continue overnight, their state remains visible, and their results stay connected to the project that produced them.
What Jaz does
Jaz is an open-source control plane for coding agents. It lets me:
- run multiple coding agents in unified UI (Codex, Claude, OpenCode, Gemini)
- see Codex-native child agents as first-class threads, while keeping them distinct from independently orchestrated external agents;
- schedule Loops that continue work unattended;
- arrange live outputs and interactive artifacts on Boards;
- preserve exportable memory across threads;
- review and ship Git changes from the same workspace; and
- run everything locally or connect to an always-on remote backend.
- agents can spawn child agents across different harnesses
- It supports native Telegram and WhatsApp integrations via QR code scanning
Jaz also supports other coding agents, but Codex and GPT-5.6 are the center of this Build Week submission.
What I added during Build Week
Jaz existed before Build Week, so this submission covers only the work added after July 13 at 9:00 AM PT. My goal was to make long-running Codex work easier to understand, supervise, and trust.
- Made Codex subagents visible. Native Codex child agents now appear as linked threads with their names, tasks, status, and results, while separately launched Jaz agents remain an explicit orchestration surface.
- Made autonomous work easier to trust. Plan Mode now preserves the agent’s explanation while representing proposed plans separately. Desktop completion notifications let me leave tasks running without repeatedly checking the app.
- Made Loops and Boards first-class workspaces. They now have dedicated navigation and overview pages with live board previews and loop status, instead of being buried in the project sidebar.
- Made remote supervision practical. I redesigned previews around isolated capability origins so remote and mobile clients can safely open agent-created development servers without sharing Jaz’s authenticated origin.
- Polished the everyday workspace. I added collapsible project groups, improved Codex theme support, clearer goal-budget semantics, stable generated thread titles, and a more focused visual system.
How I built it
The backend is written in Go. It owns agent sessions, credentials, workspaces, loops, memory, Git tools, and SQLite persistence. It exposes REST and Server-Sent Events to the clients, speaks the Agent Client Protocol to coding agents, and uses the Model Context Protocol for tools and integrations.
The desktop client is Electron, React, and TypeScript, built with Bun and Vite. The client/server split lets Jaz run as a local desktop application or connect to an always-on backend without moving agent ownership into the UI process.
Codex was my primary engineering collaborator throughout Build Week. I used Codex with GPT-5.6 Sol to trace behavior across the Go backend and React frontend, propose bounded changes, implement them, run Go and Bun verification, review diffs, and iterate on failures. GPT-5.6 is also integrated into the finished product: Jaz exposes the GPT-5.6 family as Codex models and carries model-specific reasoning capabilities into each thread.
I retained the product and architecture decisions: which state belongs to the backend, how native child agents differ from external agents, which semantic events the UI must preserve, how authentication material is isolated, and when a simpler contract was preferable to another compatibility layer.
Challenges I faced
The hardest problems were not generating code; they were maintaining correct ownership and state across long-running agent workflows.
A Codex turn may last seconds or days, spawn children, stream repeated tool updates, produce artifacts, pause for user input, or terminate unexpectedly. Jaz must preserve every semantic event the user can see while avoiding redundant transport snapshots. It must allow a process to live for the full duration of genuine work, but release that process as soon as the turn becomes terminal.
Another subtle challenge was separating two similar-looking concepts: a native Codex subagent belongs to its parent turn, while an independently launched ACP agent is a separate orchestration surface. Treating them as the same thing created lifecycle, naming, and UI ambiguity. Making that boundary explicit simplified both the code and the experience.
Remote previews introduced a security challenge as well. An agent-created development server cannot simply be exposed on the authenticated application origin, so Jaz uses isolated capability origins and strips credentials before proxying traffic.
What I learned
I learned that a serious agent product is less like a chat application and more like a small distributed system. The important abstractions are identity, ownership, lifecycle, event semantics, cancellation, resumability, and observability.
I also learned to separate semantic state from transport noise. A user needs every distinct tool call, its input, output, and status; they do not need thousands of timestamp-only snapshots of the same progress frame.
Most importantly, stronger models do not remove the need for product judgment. GPT-5.6 can perform remarkably sustained engineering work, but the surrounding system still needs to make that work understandable, steerable, and trustworthy.
What I am proud of
Jaz is the only AI product I use now. It speeds up my work dramatically and allows to get better outcomes because memory knows how I think and how I work.
What's next
Next I want to finish the remote and mobile supervision path, expand connected-app workflows, make Boards a richer shared surface for agents and humans, and keep tightening the event and process lifecycle so Jaz can run continuously without accumulating hidden operational debt.
Log in or sign up for Devpost to join the conversation.