Team Console

Self-hosted command center for an AI engineering team.

Team Console dispatches AI coding agents against your repositories, runs every change through an adversarial review loop, and records the whole thing in a GitHub-native ledger — all on your own machine, with your own provider accounts.

You describe work in plain language. A dispatcher (the "brain") plans it, an implementer opens a pull request, and a separate reviewer adversarially checks the diff and posts a verdict before anything lands. You stay in the loop the whole time.

---

⚠️ Status: working, built, and open — but not polished

Team Console runs today: clean install → connect a provider → drive it from the browser → real dispatches that open real PRs. It was built and dogfooded on real projects.

That said, it's a big system and there are rough edges and likely bugs. It's shared as-is under MIT. I may keep working on it, I may not — no promises, no support guarantees. Fork it, file issues, send PRs, or just take the ideas. If it saves you time, great.

---

What it does

• Dispatch AI agents against your code. Turn an issue or a chat prompt into a planned task, an implementation, and a pull request.
• Adversarial review built in. A reviewer role runs the tests and judges the diff (APPROVE / NEEDS-EYES / BLOCK) independently from the implementer — ideally on a different model, so mistakes get caught instead of rubber-stamped.
• Bring your own providers. Anthropic and OpenAI via OAuth (subscription) or an API key; Google via API key. Split roles across providers (e.g. build on one, review on another) for cross-model checking. (OAuth is verified for Anthropic + OpenAI; Google/Gemini is less tested.)
• GitHub-native. Work is tracked as issues, branches, PRs, and comments — plus a local SQLite ledger of dispatches, handoffs, and incidents.
• Self-hosted and isolated. Everything lives under ~/.team-console/, separate from your normal setup. Code, prompts, and outputs stay on your machine.
• Free and keyless. No license key, no paywall, no phone-home.

How it works

  you ──▶ dispatcher (brain) ──▶ implementer ──▶ pull request
                                                     │
                                                     ▼
                                      reviewer  ◀── runs tests,
                                  (APPROVE/NEEDS-EYES/BLOCK)   posts verdict

The runner is a local daemon that owns dispatch, worktrees, and the GitHub integration. The dashboard / setup wizard is the browser UI where you connect providers, assign roles, and drive the orchestrator. Each agent runs in its own git worktree, so parallel work doesn't collide.

The brain vault

Team Console has a memory layer — the brain vault — so the team gets better with context instead of starting cold every time.

• The vault lives at ~/.team-console/brain/ and ~/.team-console/memory/, and accumulates learnings, handoffs, and incident notes as the team works.
• On each turn the brain does relevance-ranked recall: it scores stored memory against what you're actually asking and injects only the relevant pieces, instead of dumping a fixed blob. That keeps the context small (low token) and on-topic.
• LIMITED mode is the working default. It needs no Docker and runs the full dispatch + review loop with file-based memory.
• FULL/kernel mode is optional and currently work-in-progress. It clones jewbear66-cpu/tc-brain-kernel and brings up a local Docker stack (Postgres, Redis, embeddings, and brain services), but the brain MCP is not yet wired into the orchestrator/workers. Treat it as contributor-facing infrastructure, not as a finished user feature.

Quickstart

Platforms: macOS, Linux, and Windows via WSL. The install scripts are bash; native Windows (outside WSL) is not supported.

Prerequisites: Node.js 20+ and git. Optional: Docker (for FULL mode), Python 3.11+ and uv (for the bundled hooks runtime). You'll also want a Claude, OpenAI, or Google account to connect as a provider.

Recommended: one-command install

git clone https://github.com/jewbear66-cpu/TeamConsole.git
cd TeamConsole
bash scripts/install-tc.sh

This installs dependencies, builds the runner, sets up the isolated ~/.team-console/ home + hooks runtime, installs the provider CLIs used for OAuth sign-in (the Claude Code CLI and the OpenAI Codex CLI), registers a launcher, and — if Docker is present — brings up the optional kernel.

Manual / development build

To build by hand instead:

git clone https://github.com/jewbear66-cpu/TeamConsole.git
cd TeamConsole
npm install
npm --prefix runner run build
cd runner && npm start          # keyless — no license needed

Connecting a provider: to sign in with OAuth (subscription), that provider's CLI must be on your machine — Anthropic uses the Claude Code CLI, OpenAI uses the Codex CLI (npm i -g @openai/codex). The one-command installer sets these up for you. If you'd rather not install a CLI, paste an API key in the wizard instead.

Then open the setup wizard at http://127.0.0.1:9100/setup, skip the optional license step, connect at least one provider, assign the dispatcher + implementer (and a reviewer), optionally connect a GitHub repo, and finish. The orchestrator chat is where you drive the team.

Health check:

curl http://127.0.0.1:9100/healthz

Configuration

• Port — 9100 by default; override with RUNNER_PORT. Make sure it's free.
• Home — ~/.team-console/ by default; override with TEAM_CONSOLE_HOME (handy for running more than one instance).
• Providers — connected in the wizard / Settings via OAuth or API key. Tokens stay local under the TC home.
• GitHub — optional. Connect a repo (OAuth or a personal access token with repo + workflow) only if you want TC to push branches and open PRs.

Layout

Everything is under ~/.team-console/ (isolated, per the isolation contract):

Path	What
state/tc.db	SQLite ledger — dispatches, handoffs, incidents, sessions, audit log
brain/, memory/	the brain vault (memory + learnings)
tc-brain-kernel/	Docker Compose brain stack (optional FULL/kernel mode; WIP)
worktrees/	per-dispatch git worktrees
logs/	per-dispatch logs + dispatch-events.jsonl
.claude/, .codex/, .gemini/	TC-scoped, isolated provider auth/config

TC keeps its Claude Code config, hooks, and memory inside this tree so a TC session never inherits — or pollutes — your normal agent setup. See ISOLATION_CONTRACT.md.

Packages

• runner/ — Node.js + TypeScript daemon: dispatch, worktrees, GitHub, the orchestrator brain, and the state layer.
• dashboard/ — browser UI for providers, roles, model choices, and dispatch state.
• wizard/ — first-run setup wizard.
• shared/ — TypeScript contracts shared across the workspaces.
• mcp-tc/ — MCP server exposing TC to Claude Code sessions.

Uninstall

bash scripts/uninstall-tc.sh

Removes ~/.team-console/ only — it never touches ~/.claude/, ~/CLAUDE.md, or any other state.

Contributing

Issues and PRs are welcome. Because maintenance is best-effort, the most useful contributions are self-contained fixes with a clear description of what was broken and how you verified the fix. There's no CLA — it's MIT.

License

MIT — see LICENSE.md. All workspaces (runner/, dashboard/, shared/, wizard/, mcp-tc/) ship under the same terms. Team Console runs with no license key; a .tckey is optional and only honored if you happen to have one.