In short
- agent
- A part that performs one task and passes the result on.
- approval gate
- The gate between Judge and Launcher. Nothing is published without your approval.
- REWORK
- The loop back from Judge to Scribe. If Judge rejects, Scribe rewrites, until it is right or a human decides.
- rollback
- The way back. Any published change can return to the previous version.
Who does the work?
Agents, each with one task. They hand off to each other, and that is deliberate: a part that does only one thing is a part you can check. Below is who runs today and what each one delivers.
Running today — 13 of 13
| Agent | What it does | What you see from it |
|---|---|---|
| Radar | spots what changed | the measurement |
| Pathfinder | picks the route | the fixtips, in order |
| Curator | finds and verifies the sources | a verified source list |
| Appraiser | weighs what existing pages are worth | a triage: what comes first |
| Scribe | writes the fix | the fixlist, ready to place |
| Judge | approves or rejects | a verdict, with the reason |
| Sentry | keeps watching | the proof: before and after |
| Scout | watches the competition | an intel report |
| Tuner | tunes the technical side | meta, schema, redirects, sitemap |
| Launcher | executes | put live, after your approval |
| Failsafe | rolls back | the previous version, restored |
| Herald | builds the campaign | content ready to post |
| Poster | publishes to the channels | scheduled or posted |
Planned, not live yet — 0 of 13
| Agent | What it does | What you see from it |
|---|
How does work move through the pipeline?
Left to right, with two feedback loops. A condition splits the flow: with no gaps it goes straight to Sentry, which keeps watching. With gaps, it runs the full chain.
The canvas below replays one run. It is not the only representation on this page, and that is deliberate — the table above is the readable version. What a crawler cannot read does not count for us, and that includes our own animation.
What happens when an agent gets it wrong?
Then it goes back. Judge reviews what Scribe wrote; on a rejection it returns to Scribe through REWORK, with the reason attached. That loop runs until it is right or a human decides it is enough.
If something has already been published and still goes wrong, there is Failsafe: back to the previous version. A system that can publish without being able to roll back is not a system, it is a gamble.
Who decides what gets published?
That does not depend on which agent it is, but on what it does. Of our 13 agents, 9 run on their own, 2 ask for your signature first, and 2 do both — free to create, never free to show. The policy hangs on the action, sits in the code with its reason, and an action without a policy asks for approval rather than staying silent.
The line runs through one question: anything you can quietly undo runs by itself — anything another human being sees does not. No risk score, no slider from 1 to 10. A schema field on your own page sits wrong for ten minutes and nobody saw it. A post on your company page is seen, shared and screenshotted before you take it down. And rolling back always runs by itself: asking permission to repair something broken is making the mistake twice.
Every step leaves a trail: who approved what, when, and exactly what changed. And if you would rather not sign yourself, we take it over — inside the scope you agree, with the same way back. That is the third answer; the market has two, and they are switching approval off or putting it on your desk.
What are you still doing by hand today, and who takes it over?
Seven pieces of work sitting on someone's desk today, and for each one who takes it over here. The names on the right are not categories but the agents themselves — you can find them in the table above, with what they deliver and what they may do without asking.
The bottom row is the important one, and it is where we part company with the rest of the market. Elsewhere it reads zero hours a month and fully autonomous. Zero hours means nobody is looking any more — that is not a promise but a risk in the wrapping of one. Ours reads who signed off, when, and how you undo it.
| What has to happen | Who does it here |
|---|---|
| Querying every engine one by one, then again, because once tells you nothing | Radar |
| Pasting the answers into a spreadsheet and turning them into a chart | Radar → Sentry |
| Working out which gap to close first, and being able to explain why | Pathfinder → Appraiser |
| Finding a source that backs it up, and checking that it says what you think | Curator |
| Writing the text and the schema yourself — and being the one who approves it | Scribe → Judge |
| Filing a ticket for whoever has to put it live, and waiting | Tuner → Launcher |
| Coming back weeks later to see whether it did anything, with the same questions | Sentry → Failsafe |
| What you are left with at the end of the month — a folder of exports, and no way to say whether it was your work or the model answering differently that week. | Who signed off, when, for what reason — and one button to undo it. |
Which agents are not running yet?
These. They are listed because a pipeline with a visible gap is easier to understand than a pipeline with a piece quietly cut out. What you see here comes straight from the code: an agent moves to the left-hand list the moment its backend exists, and not a day earlier.
Frequently asked questions
Why doesn't each agent have its own page anymore?
Because nobody searches for "Radar" or "Scribe" — those are our names, not a customer's question. Twenty-three near-identical pages differing only in a name get devalued by search engines and models alike, and that reflects on the whole domain. One strong page answers the question people actually ask.
Can an agent publish something without me knowing?
No. The approval gate sits between Judge and Launcher and only you open it. If you release a category in advance, that is your choice and it is on the record, with the date and who gave it. And anything published can be rolled back.
Which models run behind the agents?
We do not say, and that is a choice rather than mystery. What we do say: each agent has a skill written for that one task, and the Judge runs on a different brand than the Scribe. A model reviewing its own work approves too much.
What if the agents disagree?
Then Judge wins, and it goes back to Scribe with the reason attached. If the loop keeps spinning, it stops and lands with a human. A system that negotiates with itself forever is a system that never ships.
Why are the agents that aren't running yet on this page?
Because otherwise the pipeline has a gap you cannot explain. They are listed separately, labelled as such, and they appear in no promise. The moment their backend exists they move to the other list by themselves — that list comes from the code, not from a document.
Read on
Free, no account and no card.