defract 1.5 ships an MCP server. a managing agent - claude, chatgpt, or codex - can now drive defract from scope to merge: groom the backlog, kick off a task, approve or send back each implementation phase, inspect diffs, choose stage models, and merge the PR. the same gated, reviewed pipeline you run by hand, now runnable by an agent. local-first, on your own anthropic key.
competitors run agents. defract runs your process. now an agent can run your process for you. the hard part of delegating to an AI was never speed, it was trust: an agent that just writes code runs off the rails. defract's answer is the process a senior team already uses - scope, design, build, specialist review, gated merge - exposed over MCP. a managing agent drives that process on the same code path as the app, so an agent-driven run behaves exactly like a hand-driven one. delegation with a seatbelt, not a blank check.
over MCP, an outside agent can browse, create, edit, delete, promote, re-groom, and link tasks in your defract backlog.
it decides what ships next and queues the work, instead of you hand-feeding one task at a time. point a manager agent at an epic and let it break that epic into groomed tasks, then work them down one by one.
kick off a task and defract runs the full pipeline: story, design, build, review. the managing agent supervises every step.
it answers scope questions, picks the model for each stage, approves or sends back each implementation phase, inspects diffs, and merges the PR once checks pass. a whole feature delivered end to end, with an agent holding the controls you normally hold yourself.
the manager can message a live stage agent or halt it mid-run, the same controls you have in the app.
supervise by exception: let it run, step in only when a diff or a scope answer actually needs a human. nothing happens that you could not have done by hand in the UI.
the MCP server and the UI go through one shared path for every action, so an agent-driven run behaves exactly like a hand-driven one.
there is no second-class automation mode with its own quirks. the gates, the review, and the merge handling an agent gets over MCP are the same ones you see on screen. what you tested by hand is what the agent runs.
the agent proposes, the process disposes. each implementation phase stops for an approve-or-send-back decision, so an agent that drifts gets caught at the next gate, not after it has merged.
a security reviewer, a refactor reviewer, and a generic reviewer judge the work against the original story before anything ships. delegated code clears the same bar as hand-written code.
the managing agent orchestrates, but your code and PTY transcripts never leave your machine, and inference runs on your own anthropic key. no code shipped to a vendor, no markup, no interaction caps.
the MCP path is the same path the UI uses. there is no separate automation engine with its own failure modes, so the behaviour you verified by hand is the behaviour the agent gets.
this is for developers already running claude code and parallel agents who want to delegate whole features or epics to a manager agent and supervise by exception, instead of babysitting every task. point claude, chatgpt, or codex at your backlog over MCP and let it work down the list.
honest note: the MCP server is new in defract 1.5, and you are handing an agent real authority. start with the gates on, approve each phase, and loosen as you build trust. the guardrails are the whole point, and they are what let you actually leave it running.
download defract, connect your manager agent over MCP, and run a feature end to end: gated, reviewed, on your own claude.