CodeBoard

CodeBoard is a local-first workspace for task-oriented multi-agent discussions with a Lead/Helper collaboration model, persistent artifacts, and task-scoped round orchestration.

Why CodeBoard works well in practice

CodeBoard is designed for work where quality depends on structured thinking, not just a single model response.

• It keeps discussion traceable: you can see how the team moved from raw ideas to a final draft.
• It separates roles clearly: helpers explore options and risks, lead consolidates direction and output.
• It preserves context across rounds: follow-ups continue the same task without losing prior reasoning.
• It stays local-first: project data and workflow remain under your control.
• It supports mixed model setups: cloud and local/openai-compatible sources can be used in one workspace.

The main advantage is predictable collaboration: less “prompt roulette”, more repeatable decision quality.

Example workflows

1. Code implementation task

• You create a task like “Build a settings panel with validation”.
• Helpers propose approaches and edge cases.
• Lead produces a final draft that is implementation-ready.
• If needed, you continue discussion with follow-up constraints instead of restarting from scratch.

2. Product decision

• You ask “Should we ship feature A in this sprint or defer it?”.
• Helpers surface trade-offs, risks, and dependencies.
• Lead consolidates into a clear recommendation with rationale and execution direction.

3. Research or open question

• You ask a broad question where uncertainty is high.
• Helpers explore alternative hypotheses and objections.
• Lead narrows the result into a concise final answer you can act on.

Current architecture

• Case -> task hierarchy on Prisma + SQLite.
• Task-centered round engine with phase flow:
  • INITIAL_PROPOSALS
  • LEAD_SYNTHESIS
  • OPEN_DISCUSSION
  • LEAD_REVIEW
  • REVIEW
  • FINALIZED
• Round artifacts (RoundArtifact) for carry-over context and notebook-style notes.
• Task-round scoped chat/events/submissions UI.

Role model

• UI role model: LEAD, HELPER.
• Legacy EXTERNAL records are normalized to HELPER in UI editing flows.
• Lead owns synthesis and final draft; helpers contribute proposals, risks, alternatives, and objections.

Discussion flow in UI

1. Create/select a task.
2. Start discussion round (maxIterations is user-controlled).
3. System runs proposals -> synthesis -> open discussion -> lead review.
4. REVIEW stage surfaces a Lead final draft.
5. User can:
   • Approve (finalize current round),
   • Restart discussion,
   • Continue discussion (follow-up message starts a new round with carry-over context),
   • Cancel discussion (stop active execution).

Agent sources

Supported agent (AI model) sources in UI:

• OpenAI / Codex
• Qwen / Local (endpoint required)
• Custom OpenAI-compatible (endpoint required, API key optional depending on runtime)

HTTP endpoints

Primary task-scoped flow:

• POST /api/tasks/:id/rounds
• POST /api/task-rounds/:id/run
• POST /api/task-rounds/:id/cancel
• GET /api/task-rounds/:id/artifacts
• POST /api/task-rounds/:id/artifacts
• DELETE /api/task-rounds/:id/artifacts/:noteId

Round compatibility/auxiliary endpoints:

• POST /api/rounds/:id/run
• POST /api/rounds/:id/decide
• POST /api/rounds/:id/final-response
• GET /api/rounds/:id/submissions

Case/task/agent endpoints:

• GET/POST /api/cases
• GET/POST/PATCH/DELETE /api/cases/:id
• GET/POST /api/cases/:id/tasks
• PATCH /api/tasks/:id
• GET/POST /api/agents
• PATCH/DELETE /api/agents/:id
• GET /api/cases/:id/events
• GET/POST /api/cases/:id/agent-messages
• POST /api/cases/:id/rounds (compatibility path)

Development

Requirements:

• Node.js LTS 24+ (recommended).

Install/run:

• Install dependencies: npm ci
• Initialize database: npm run db:generate && npm run db:push
• Dev server: npm run dev
• Production build: npm run build
• Lint/tests: npm run lint, npm run test

Windows quick start:

• Run start-codeboard.bat
• Open http://localhost:3000

Notes:

• Dependency versions are pinned by package-lock.json.
• Security override is applied for minimatch via package.json overrides.

Contributing and security

• Contribution guide: CONTRIBUTING.md
• Security policy: SECURITY.md

Built with Codex

CodeBoard codebase was written with codex.

Delivery timeline:

• initial implementation: GPT-5.3-Codex
• multi-iteration middle phase: GPT-5.3-Codex-Spark
• final code polish and stabilization: GPT-5.3-Codex

CodeBoard was iterated with active support from codex across architecture, backend flow, UI/UX behavior, performance/debugging, provider integration, and release hardening.

Key implementation support included:

• discussion loop and phase behavior alignment;
• final draft/approve flow polishing;
• local and OpenAI-compatible source integration;
• board interaction and rendering fixes;
• startup, dependency, and security/audit stabilization.