Philosophy

Synthex isn't trying to make a single agent smarter. It's trying to make a team of agents work the way a senior engineering team already works — with explicit roles, peer review, traceable artifacts, and quality gates that don't bend.

This page is an excerpt. The full essay lives at

and is the canonical source. Quote the original, not this summary.

#Software is built by teams, not authors

The mental model that's quietly shaped most "AI coding" thinking is the lone author: one person, one editor, one prompt. It's the wrong model. Real software is built by teams that specialize, disagree, document, and review each other's work. The artifacts they produce — PRDs, plans, ADRs, code reviews, retros — exist because no single person can hold the whole system in their head.

Agentic delivery should inherit that shape, not flatten it. A single agent good at everything is weaker than a coordinated set of agents each good at one thing, talking through structured hand-offs and reviewing each other's output.

#Roles before tools

Synthex starts from roles, not from features. There is a Product Manager because requirements need someone to own them. There is an Architect because cross-cutting decisions need a single voice. There is a Tech Lead because the build phase needs orchestration. The reviewers exist because nobody — human or model — should merge their own work without a second pair of eyes.

The roles map onto a set of agents, but they aren't defined by the agents. They're defined by the artifact each role produces and the contract each role honors with the next role downstream. Agents are the implementation; the roles are the structure.

#Traceability is the contract

The bargain Synthex makes is simple: every artifact points to the artifact upstream of it. A plan task points to a requirement. A code change points to a task. A decision points to the context that prompted it. A retrospective points to the outcomes that motivated it.

When the chain holds, you can audit any change in the system. Why does this code exist? — because of this task. Why does this task exist? — because of this requirement. Why does this requirement exist? — because of this user, this problem, this success metric. The chain is either continuous or it's broken; there is no ambiguous middle.

This is also what makes parallel agentic work safe: each parallel branch carries its own provenance, so even when many things happen at once, every individual change is explainable after the fact.

#Quality gates that don't bend

The single failure mode that kills agentic delivery in practice is slow erosion of standards. Each individual exception seems reasonable; the cumulative effect is a codebase nobody trusts.

Synthex treats the gates as non-negotiable:

• Every [T] acceptance criterion has a linked, passing test before the task closes.
• Every [H] acceptance criterion has explicit user approval before merge.
• Every code change passes code review and security review.
• Every pre-commit hook runs. None are skipped.

The gates can be tuned — severity thresholds, reviewer rosters, cycle caps are all configurable — but they cannot be bypassed. The point is that the contract is the contract. The system stops working the moment it isn't.

#Read the full essay

This page summarizes the argument; the canonical version lives at AJ Brown's blog and goes deeper into the lineage of the ideas, the trade-offs Synthex consciously accepts, and the specific failure modes the model is designed to avoid.

→ Agentic Software Delivery, in full

#Next

• The lifecycle — the five-phase loop that puts the philosophy into practice
• Quality gates — how the contract is enforced
• The marketplace — how Synthex is distributed and structured