An AI agent can write an SEO article in about a minute. I've watched mine do it. I've also watched it get things wrong with complete confidence, so speed was never what worried me. What worried me was whether the article was correct, whether anybody was searching for the topic in the first place, and whether the page could even be found once it went live.
So I built a workflow around my AI SEO agent instead of trusting it. I call it the Autonomous SEO Loop. This post walks through the whole thing in plain English, and you don't need to have run SEO before to follow it.
Quick answer: an AI SEO workflow is a repeatable process where AI agents research and write, automated checks verify the numbers, claims and quotes, a second AI reviewer reads the draft cold, and a human approves publishing. Every change runs as a small test, with the expected result written down before it starts.
What does an AI SEO workflow look like?
There are three layers, plus a second reviewer I'll come to.
The AI agents do the actual work: topic research, reading sources, drafting the page, packaging it for release. Underneath them sit small scripts that test anything testable, which in practice means every number, claim, quote and link. Then there's me, because nothing reaches the live site without a yes from a person.
One boundary matters more than the rest. The agents can read the live website but they can't change it. They hand me a ready-to-apply package and I apply it. It sounds fussy. It also removes a whole category of accident.
How AI agents run SEO as a loop of small tests
I don't keep a list of articles to write. The system runs as a loop:
Goal → Look → Guess → Test → Check → Learn, and then round again.
- Goal. I write down what success means, in numbers. That includes what counts as qualified traffic, so a vanity metric can't sneak in and look like a win.
- Look. The agent collects raw facts: search console data (Google's report of which searches showed my pages), what's indexed, what ranks where.
- Guess. The agent writes a statement that could turn out to be wrong: "if we do X, metric M moves in direction D, because R."
- Test. A small change that can be undone. The success line and the measurement window are written before it runs, not after.
- Check. A script confirms the change is really live and hasn't been altered on the way, because a page being shipped tells you nothing about whether it's working.
- Learn. The agent writes down the general rule. "Page X failed" doesn't help next time. "Pages shaped like X fail because Y" does.
Writing the guess down first is the part I'd keep if I had to throw everything else away. Without it, I can look at any set of numbers afterwards and talk myself into a story about them.
How an AI agent writes one SEO article, step by step
An article is one test inside that loop. Each one goes through six stages.
- Pick a topic. Two questions get answered with data before any writing starts. Do enough people search for this? Can it be answered well from sources the agent can actually get hold of? Search volume is a gate, so below the floor the agent stops. How easy the topic is to rank for only breaks ties between topics that already passed.
- Plan first. Before a draft exists, the agent writes down what it expects the article to do, how it'll be judged, and over what time window.
- Gather the facts. The agent fetches the official sources and quotes them. If there aren't enough, it stops. Every number the page will print is calculated by a script, never typed in while reading a table. That covers small words like "only" and "most" too.
- Write for the reader. The page opens with a quick answer in the reader's own words, the headings are the questions people actually ask, and every section ends with a "do this" line. The product gets mentioned once, where the pain is. A direct answer at the top also makes the page easier for AI answer engines to quote, which I covered in my GEO primer.
- Check it twice. The automatic checks run first. Then a second AI agent, in a fresh session with no stake in the draft, reads the page against a fixed bar. Anything wrong goes back to the writing agent, and the checks run again.
- Publish, measure, learn. I publish. A script confirms the page is live, linked from the home page and indexable. The agent tracks it only inside the window it declared, and a miss gets reported as a miss.
How do you fact-check AI-written content?
These are the four checks from the image.
Numbers come from code. One script produces every figure the page is allowed to print. A second script confirms the page doesn't print any number that isn't in that data or inside a quoted source. Even rounding is only allowed if the rounded number was itself computed.
Every claim has a dated source. Any sentence shaped like a claim has to be declared, sourced and dated. If the source is weak, the sentence gets hedged. "The best" isn't allowed without "in our data" next to it.
Quotes get re-checked against the original. A script fetches every cited source again and confirms the quoted sentence is really in there. On its first run, 6 of the 24 quotes it checked were wrong.
A check only counts if it can catch a mistake. At one point my checker reported "125 of 125 passed", which felt great. Then I planted 24 deliberate mistakes to see what it would do, and 19 of them got through. A green result means nothing until you've watched that check fail on the exact thing it was written for, so now every new check gets attacked the same day it's written.
Human in the loop: what the AI agents decide and what I decide
The rule I use for splitting the work: a step belongs to an AI agent only if it needs judgment. Anything that can be checked is a script, and anything purely mechanical is a function. An agent can be argued into things. A script can't, so I have the scripts guard the agents.
| Who | Does |
|---|---|
| The writing agent | Researches, plans the tests, writes the page, prepares the package |
| Automatic checks | Numbers, claims, quotes, links, metadata, sitemap, live verification |
| The reviewing agent | A fresh AI session with no authorship stake, judging against a fixed bar |
| Me | Approve the topic and publish |
Some things stay with me no matter how well the agents behave: publishing, anything permanent or private, changes to analytics or measurement, spending money, creating accounts, and adopting a new strategy.
Everything else the agent decides on its own and reports back, without asking first. If it asks permission for work it's already allowed to do, that gets logged as a failure. For a single article I'm needed exactly twice, once to approve the topic and once to publish.
Three mistakes that changed how I use AI for SEO
The first mistake was letting the writer mark its own work. The writing agent scored its own drafts 4/4/4. An independent reviewer scored the same drafts 2/2/3, and five wrong statements had already slipped past the writer's own checks. That's the reason stage five has two halves, and the reason the reviewer always runs in a separate session.
The second was assuming rank mattered more than demand. I had one page at position 7 in Google, on page one. I had another at position 71, which is page seven, where supposedly nobody looks. The page-seven article was shown in search about 108 times as often: 21.7 times a day against 0.2. Its topic gets about 76,700 searches a month and the other gets about 500. Ranking well for a question nobody asks is worth very little, which is why volume is a gate in stage one and ease of ranking is only a tiebreaker.
The third was fixing the page and moving on. When I catch a mistake now, I want two things back: the fix, and a check that would have caught it. If the agent only patches the page, the same kind of mistake turns up again. So every defect I catch becomes a script, and it gets written down so it isn't repeated.
Is it working? The Google Search Console results so far
The site this loop is growing is Beni, a tool I built that tells you which credit card to pay with on each purchase. The agents write its guides on Indian credit card fees and charges. Here is the whole site in Google Search Console, from 7 August to 19 September 2026.
The purple line is impressions, meaning how many times a Beni page appeared in somebody's Google results. The blue line is clicks. Over those six weeks the site was shown 899 times and clicked once, at an average position of 63.8.
Those are small numbers and I'm not going to dress them up. This is what the first six weeks of Search Console data look like for a new site. What I watch is the shape: impressions started at zero and the best day so far was 18 September, with 166. The first click came the day after, from someone searching "rupay credit card upi charges above 10000", a query where Beni's guide averages position 7. I don't know yet what caused the spike, and one day proves nothing. The loop reads results by the week, not the day.
The second screenshot is the one I find more useful.
This is the table behind the demand-beats-rank mistake above. The guide on international transaction charges sits at position 70.4 and still collected 426 impressions, more than any other page. The HDFC Millennia vs SBI Cashback comparison sits at position 7.0 and got 6. The per-day figures I quoted earlier were measured over a different window, so they won't match this table exactly, but the pattern hasn't changed: about 71 times the impressions from a page ranked sixty-odd places lower.
It's also where the next round starts. This table is the "Look" stage of the loop. On a new site, your own Search Console data is the best topic signal you have, because it shows where Google already places you. So the loop prefers topics where the site already earns impressions, like international charges and RuPay on UPI, over a fresh idea that only looks easy to rank for.
Can you build this AI SEO workflow yourself?
Yes. Nothing in it is tied to one website or one product. Start with a goal that has a number in it and one small test with the guess written down before it runs. Then add the one rule I'd put above all the others: never let the writer mark its own work.
Build the checks as you go, and attack each one on the day you write it. Don't automate a step until you've done it by hand once and you know how it fails.
None of this made the writing faster. The agent was already fast. What I got is a loop that's a little less wrong each time round, and I'll take that over speed.