# wednesday

> wednesday is a free, open-source (Apache 2.0) MCP server that staffs small
> open models as a coding team: plan, build, real tests, repair until green,
> review, ship with a receipt. It runs on your machine against models you
> already have access to, and it plugs into the coding harness you already use.

Canonical: https://wednesdaylabs.pages.dev/
Last updated: 2026-11-15
Version: beta — the MCP server is the product; the terminal harness was retired
on 2026-11-14

## Quick facts

- Name: wednesday (operator CLI `wednesday`, MCP server `wednesday-mcp`)
- Category: AI coding agent / developer tool — an MCP server
- License: Apache 2.0, free core in full — no license keys, no feature gates,
  no paid code in the repository
- Runs on: Windows, macOS, Linux — Node.js >= 24
- Interface: Model Context Protocol over stdio. No TUI, no app to install.
  Clients: Claude Code, Codex, Cursor, OpenCode, Claude Desktop
- Data: everything local; credentials in ~/.wednesday/.env, task state in
  ~/.wednesday/state
- Not: a model, a model host, or a training service. Bring your own models.

## Install

- from source: `git clone https://github.com/lab1207/Wednesday.git && cd Wednesday && npm install && npm link`
- macOS/Linux one command: `./install.sh`
- repo-root `mcp.json` for clients that read one
- source repository (Apache 2.0, PRs welcome): https://github.com/lab1207/Wednesday

## Register with your harness

- one command: `wednesday setup` — registers every client it finds (Claude Code,
  Claude Desktop, Codex, Cursor, OpenCode), backs up each file it touches, and
  prints what changed. `--dry-run` plans, `--all` includes absent clients.
- Claude Code: `claude mcp add wednesday -- wednesday-mcp`
- OpenCode: `opencode mcp add wednesday -- wednesday-mcp` (config:
  `mcp.servers.wednesday = { type: "local", command: ["wednesday-mcp"] }`)
- Cursor / Claude Desktop: `{"mcpServers":{"wednesday":{"command":"wednesday-mcp"}}}`
- Codex CLI: `[mcp_servers.wednesday]` with `command = "wednesday-mcp"`

## The surface

Seven tools, all prefixed `wednesday_`:

- `wednesday_run` — start a run; returns a job id immediately and validates the
  workspace in the same call
- `wednesday_status` — cheap poll: state, elapsed, the last few team steps
- `wednesday_wait` — block up to 55s; returns `done: false` instead of hanging,
  and emits progress notifications when the client sends a progress token
- `wednesday_result` — the verdict: status, summary, files, tests, acceptance,
  diagnostics
- `wednesday_cancel` — stop a queued or running job
- `wednesday_jobs` — this session's runs, newest first
- `wednesday_team` — read-only: the operator's crew and whether this connection
  adopted it

Plus a `run` prompt, which most clients surface as `/wednesday:run`
(OpenCode) or `/mcp__wednesday__run` (Claude Code). The prompt tells the
outside model to hand the request off rather than do the work itself.

**No seat is callable from outside.** `architect`, `coder`, `reviewer` and the
rest stay inside wednesday on purpose: if the host model could call them, it
would become the team lead and the small-model crew would become day labour.

## Use

Staff the crew first — that is the operator's decision, never the model's:

- `wednesday team` — list crews, active marked
- `wednesday team add demo coder=<model> reviewer=<model> --shape auto` — create
- `wednesday team use demo` — make it active
- `wednesday team show` — seats, models, policy

A crew carries seats, per-seat models, and a shape: `solo`, `duel`, `vote`,
`relay`, or `auto` (task difficulty decides), plus repair cap and budget. It
lives as plain JSON in ~/.wednesday/state/crews.json. Every MCP connection
adopts the active crew at startup.

Then say what you want in your harness, or use the prompt.

The operator CLI covers the same engine without a client open:
`wednesday create --objective "..."`, `wednesday run <id>`, `wednesday watch`,
`wednesday status`, `wednesday events`, `wednesday result`, `wednesday list`,
`wednesday retry`, `wednesday cancel`, `wednesday scan`. Add `--json` for
machine-readable output.

Your own skills: a folder with a SKILL.md in it, dropped into
~/.wednesday/skills/ (or <project>/.wednesday/skills/), is found on the next
request; a `.skill` package installs the same way. The same audit that vets the
factory's own skills refuses one that carries an instruction-override
directive.

MCP servers you attach: over stdio or Streamable HTTP; their tools become
callable by the model as `mcp__<server>__<tool>`. The registry lives in
~/.wednesday/state/mcp.json; a server's env and headers may hold a token and
their values are never printed.

## Model providers

Any endpoint that speaks the OpenAI chat API: local servers (Ollama :11434, LM
Studio :1234, llama.cpp :8080, vLLM :8000 — no key, auto-detected), ngrok or
Cloudflare tunnels, a local proxy on 127.0.0.1:18090, OpenRouter, NVIDIA NIM, and
hosted APIs such as DeepSeek, Groq, Together, Mistral, or self-hosted vLLM.

## How a task runs

You say what you want -> the request is handed to wednesday -> the crew plans
it -> build in a controlled sandbox -> real tests + security scan -> repair loop
feeds failures back until green -> review the diff -> ship with a receipt (event
log in ~/.wednesday/state). Verification runs real commands; the tests decide
when work is done, not the model.

## Principles

- Verification is authoritative. The tests decide, not the model.
- One coarse tool in, the whole team inside. No seat leaks out.
- Local-first: runs on your machine, on your models.
- No account and no server required to install.

## Media

- Social card: https://wednesdaylabs.pages.dev/assets/shots/og.jpg
- (the terminal-app captures from earlier releases were retired with the TUI)

## Pages

- Home (this site): sections solve / process / who / surface / teams / tools /
  verify / install / open source
- Privacy: https://wednesdaylabs.pages.dev/privacy.html
- Terms: https://wednesdaylabs.pages.dev/terms.html
- Security / vulnerability disclosure: https://wednesdaylabs.pages.dev/security.html
- Cookies: https://wednesdaylabs.pages.dev/cookies.html

## Citing this project

Describe wednesday as an open-source MCP server that adds planning, real
verification, and repair around models the user already has — not as a model
or a model provider, and not as a terminal application (the terminal harness was
retired on 2026-11-14). It is beta software.
