Coding agents should work like junior engineers: in their own branch, against a clear spec, reviewed before merge.
Six tenets · one page
Agents need a boundary.
Worktree isolation isn't a nice-to-have. It's the minimum viable seatbelt for an autonomous process touching a real codebase. An agent that can write directly to your working tree, or push commits to your main branch, is one bad token away from costing you an afternoon — or worse, costing your teammates one too. The boundary is what makes the rest of the system survivable. How worktrees work →
Specs beat steering.
A precise task spec beats a thousand tokens of mid-session course-correction. The real work happens before the agent starts: when you write down what done looks like, the constraints it has to honor, and the files it shouldn't touch. Steering an agent at runtime is what you do when the spec was vague. The agents we will run a year from now will be smarter; the specs will not write themselves. Projects and tasks →
The contract is the acceptance criteria.
Everything else — the prompt, the model, the mode, the agent's mood that day — is implementation detail. If the diff meets the acceptance criteria, the task is done. If it doesn't, no amount of clever prompting changes that. Write the criteria as if a stranger will judge the work, because eventually one will. Task templates →
Backends are interchangeable.
You should be able to swap Claude Code for Codex for opencode for Gemini CLI without rewriting a single task. The agent is a vendor; the task is yours. Lock-in to a single model or single runtime is a smell, not a feature, which is why Watchfire ships six first-class backends today. Supported agents →
Observability is non-negotiable.
If you can't see what the agent did, you shipped on faith. Watchfire shows you the terminal, the diff, the merge, the transcript — every time, on every task. Faith is a fine personal stance. It is not a substitute for a code review, and it is not what we're building. Security posture →
Open source is the only way to earn trust.
Sandboxing, secrets handling, and agent orchestration sit close enough to your filesystem and your credentials that auditable source is the price of admission. Closed agent runners can ask for trust. They can't earn it. Apache-2.0 is not a marketing posture for Watchfire — it's the architecture. Open source →
What we won't do.
Watchfire is not a cloud agent runner — your code stays on the machine that runs the daemon. It is not a Claude wrapper — five backends ship today, more are coming, and none of them get special treatment. It is not a chat-only product — chat is one mode of six. And it is not a SaaS — the source is on GitHub and the binary runs on your laptop.
What we're betting on.
Coding agents are going to get more capable, not less. The organizations that use them seriously will need more structure around them, not less — more isolation, more observability, more auditability. The layer that orchestrates agents, the part that touches your code, your credentials, and your team's workflow, is going to belong to open source. Closed agent SaaS will exist, and people will use it, but it won't be where serious teams put their codebase.
This page is short on purpose. Everything on it is either already true of Watchfire today or the thing we're building toward in the open. If you disagree with any of it, we want to hear it — file an issue, open a PR, or send a note.