I’m a product designer. The whole job is finding the solution — to a visual problem, a product problem, the friction a user or client actually feels. When working alongside AI made my own practice fragile, that was a real problem. So I designed a solution. The real one runs, live, on this page.
The short version of everything below — what Ed Agent is, why a product designer built it, and what it does when you point it at a real requirement.
Prefer YouTube? Watch it there ↗
A designer’s job is to find the solution — not to add problems, and not to invent ones that were never there.
Problem-solving is the work, whatever the surface: the aesthetic problem, the product problem, the friction a user feels, the risk a client carries. AI didn’t change that job. It changed the material I was solving with.
And the new material was fragile. Hand a task to an agent and the reasoning behind it vanishes; the output can look rigorous and say nothing; a locally perfect step can quietly dig a global pit. Those aren’t hypotheticals — they’re the friction I hit in my own practice.
So I treated it like any other design problem: name it honestly, then build the solution. A way of working that keeps a person’s judgment in the loop, surfaces the right question at the right moment, and refuses to pretend it understands more than it does. That solution is Ed Agent.
The four problems below are stated plainly, not dramatised — a designer names a real problem before solving it, and never manufactures a fake one.
Real friction from real practice. Each is a problem a designer would refuse to ship around — and Ed Agent is the answer to all four.
Defect rates, production incidents, and the reviewer’s role all shift. The question stops being “is it correct” and becomes “should I trust this” — provenance, verification, blast radius, the gap between confidence and evidence.
Without the chain of intent and reasoning, the agent can only guess the project — never understand it. So the intent has to be captured at the door, and an unstated goal named as the first risk, not silently assumed.
Agents are strong on the local move and weak on the whole. The result is the technically-right, business-wrong step — perfectly correct, and quietly digging a pit. Every decision needs tracing back to the goal it was supposed to serve.
AI is fluent in over-defensive work that seems sound and, on a second read, is ceremony — empty catches, grand claims with no numbers. Substance and ceremony have to be told apart, deliberately.
Catching the four is v0.5. A mission-aware red team attacks every build for exactly these failures, and claim grounding tags each load-bearing line Grounded / Ungrounded / Contradicted. But catching isn’t fixing. v0.6 is the loop that fixes them — before a human ever looks.
The four problems above get caught by the assessors. The loop is how the agent then fixes itself — produce → verify → (rollback) → repeat — until it can prove it’s good, or hits a wall it has to escalate. Four guards keep it from running away. Pick a problem a client actually brings, and watch the severity drain.
“You should be designing loops that prompt your agents.”
One shot. No verifier, no floor, no stop condition. It looks done. Whether it’s trustworthy is your problem now.
It scores itself, fixes the worst thing, re-checks, and rolls back any regression — converging to a floor it can prove, then escalating the rest.
Edit freely — the loop scores whatever is here, live. The producer is the deterministic in-harness remediator (the same one the CLI ships).
Every number above is the real, deterministic Ed Agent loop — the same code the CLI runs, ported into this page and verified byte-for-byte against the source. ~0 token: pure functions, no model calls. The producer here is the in-harness remediator (monotone — it can’t overshoot); wire a non-deterministic host LLM in its place and the rollback guard above is exactly what catches it when it does. The model produces; the harness governs.
Not a video, not a mockup. The deterministic brain — the same logic the CLI runs — is ported into this page. Drive a run, audit a diff, red-team an artifact, run the grand-mentor (総監督) review, or call the eds-mcp engine. Everything below computes live.
Type a requirement (or pick one). Ed Agent detects the mission + squad, streams the nine stages, and stops at the FRAME checkpoint if the business intent is missing — the run stays in deliberation until you answer. Then the TRUST checkpoint runs live.
Point Ed Agent at an existing artifact — a diff, a snippet, a design note — and ask “should I trust this?” No build. State the goal and the non-goals and it will flag a technically-right, business-wrong local optimum that violates one.
The grand-mentor · 総監督 review squad. Paste content — a deck line, a case study, marketing copy — and it runs the SOP: blind-score diagnostic, ban AI-tone filler, quantify-or-flag every claim, and no blind praise. The output is the three-part format.
Ed Agent doesn’t just talk about compliance — when the surface is regulated, it calls the real eds-mcp engine to show the numbers: the guardrail components the surface should map to, the regulatory anchors for the jurisdiction, and the WCAG token-contrast pass rate of the system it would ship on.
v0.5. After every build, two deterministic passes run — ~0 token, no LLM calls. The red team attacks the artifact for what the chosen mission cares about (plus universal checks); grounding tags every load-bearing claim Grounded / Ungrounded / Contradicted. Report-only by default — toggle --strict to gate on a critical finding or a non-goal contradiction.
The assessors above are the real, deterministic Ed Agent logic, ported client-side. The eds-mcp figures are a faithful slice of the live engine (v1.17.0).
The console above is the brain you can drive. ed-agent dashboard is the brain you can watch — a local control room that reads straight from the same memory file the CLI writes. See every governed run, what it cost (estimated), what it learned, and tune how it behaves, without the command line. A zero-dependency server on 127.0.0.1 only, serving one page that makes zero external requests — nothing about your runs leaves the machine.
Honest by construction: a control room over discrete runs (not an always-on daemon), token figures that are estimates (not a bill), and an engine that is still the CLI / MCP — this surface only observes and tunes them. Open it with ed-agent dashboard.
The spine is universal; the middle five swap their content per mission. Two deliberation checkpoints sit at phase boundaries — the agent stops and surfaces the questions only a human can answer. Click any node.
Ed Agent does not pretend to understand your business — a harness can’t. It forces the intent to be captured, runs deterministic trust / coherence / substance checks, and puts the right question at the right node. A run is shippable only when both gates are cleared and both checkpoints are closed. Surface the question; never make the call.
The mission is auto-detected from the requirement; the squad — named specialists — swaps with it. Build a feature, run a campaign, draft a contract, ship regulated finance, or review and optimize anything.
The mission picks the squad; the skills pick the depth. Each of the forty skills is a Markdown file — a domain lens (regulated-finance law, accounting, accessibility, reasoning, engineering, coaching) that Ed Agent loads only when a project calls for it, so a build or a piece of research considers the right professional dimensions instead of generic output. Each stays a method with a human — and, where it matters, a licensed professional — in the loop; never a claim of expertise.
Browse and download all forty — the AI Skill Set →
Runs in
Claude
ChatGPT
Codex
Gemini
Antigravity
Cursor
Figma MCP
Grok
DeepSeek
Qwen
Hermes Agent
OpenClaw
Cline
OpenCode
n8n
Dify
Ollama
Hugging Face
NVIDIA
ComfyUI
Monica
Z.aieds-mcp is the other half of Ed Chen’s machine layer: the institutional-finance design system exposed as an engine — 65 component contracts across 14 regulated domains, 88 regulatory frameworks, tokens-first and dual-theme. Ed Agent drives it twice:
① The regulated-finance mission uses it to build — scaffolding compliant, token-correct, accessible UI. ② The optimize mission calls it to quantify a surface under review — mapping guardrail components, naming the jurisdiction’s anchors, and reporting the WCAG token-contrast pass rate.
That is the difference between asserting “accessible and compliant” and showing it. Try it live in the console’s eds-mcp tab.
The same numbers the console returns — pulled from the real engine, not asserted.
For years the work was to remove friction for one user — a human. It still is. But there is a second user in the room now. AI systems hit their own walls: a goal they were never told, a constraint nobody set, a context they can only guess at. The seam between the two — where the machine stops and a person decides — is itself a surface to design. The deliberation checkpoints in Ed Agent are that seam, drawn on purpose. Breaking the barrier between human and machine is just UX, one layer deeper.
And the tool is never the job. A product designer doesn’t owe every problem a Figma file or a wall of code. Some of the best work is a process, a constraint, or a refusal — the deliberate choice not to build.
Because the most common real problem is a manufactured one. Over-thinking breeds pseudo-needs; over-engineering ships ceremony. A designer who actually serves the client subtracts — finds the most reasonable, most cost-effective path, even when that path is less software, not more. That, to me, is what considering the client really means.
The fix for “working with AI made my practice fragile” was not more code. It was designing the judgment seam — the moment the machine surfaces a question and a human makes the call.
And it is built to fight the manufactured problem: the substance scan flags over-defensive ceremony, the coherence check catches the technically-right, business-wrong step. It subtracts pseudo-work instead of generating more of it.
I’m not selling this. I’m the first user of Ed Agent — it earns its keep on my own work before it’s ever a claim. I look at it from two seats at once, and they want the same thing.
The loop is the design. The seam between produce and verify — where the machine stops and a person decides — is the surface I’m drawing. Designing that seam well is what keeps judgment in human hands and kills the pseudo-work before it ships.
I live inside the loop daily. Loop Engineering measurably changed my speed and precision — fewer wrong turns, tighter output, less babysitting. The honest version of that gain is a harness with red lines and a rollback, not a bigger prompt.
Ed Agent and eds-mcp assist the build of real surfaces I ship — the campaign-lane React deployments, the design-system tooling, the docs and SEO layer. Agents ingest, analyse, scaffold and check; design judgment and sign-off stay mine. Velocity, not autonomy — and only on the lanes where that’s honest.
The idea isn’t original, and I won’t pretend it is. Peter Steinberger put the shift into one line — stop prompting agents, design the loops that prompt them. Addy Osmani and Boris Cherny mapped Loop Engineering as a discipline. I stood on that, felt the difference in my own practice, and built a small, honest, deterministic version I could actually trust in regulated work.
A hypothesis, stated plainly: if this friction is real for me, someone else building alongside AI hits the same wall. So it’s open source — when they need it, it’s there. That’s the whole point of a portfolio piece that runs.
Ed Agent is the runnable form of how Ed Chen works with AI in regulated design: a small team plus an agent fleet sustaining many product lines. Agents ingest, analyse, research, produce and review at velocity; design judgment and human sign-off stay with the operator.
Velocity, not autonomy — disclosed, not hidden. The full source is on GitHub.