The Seventh Analyst: The Agent That Reads the Other Six

Forwarded to you? I am Heath. I build go-to-market systems and put AI to work in sales, the right way, then I write down exactly what I built, what broke, and what it moved. One story per week, receipts only. This one is about the difference between an AI system that automates and one that compounds.

The reflex: build the agent, let it run, move on

Every team putting AI to work reaches for the same move. Build an agent, point it at a job, let it run, move on to the next one. Stand up six of them and you have a team of analysts that never sleep. It feels like progress because the work is getting done. More output, more accounts scored, more of everything, faster.

I did exactly that. At a company I was at I built six analysts, each doing a real job across the product and CRM data, and I let them run. The system was busy. It was also wrong in ways I could not see, because nothing was watching. When I finally went back and rebuilt the scoring model, the loop found that 45% of the old list had a near-empty signals leg. The analysts had been ranking accounts on almost nothing and doing it with total confidence. Six jobs done fast, the same flaw repeated on every run.

The block was never how many agents I had. It was that not one of them ever learned. An agent that never reads its own misses does not get better with volume. It gets more confident. The exhaust of the system, every override and every gap, went nowhere and died there. It was memory the system threw away.

The AE feels this as "the score keeps flagging the wrong accounts." The CSM feels it as "the health signal missed the churn again." The marketer feels it as "the model still cannot tell intent from noise." Same reflex every time: a system that runs, and never once looks back at what it got wrong.

The reframe: the audit trail is the training set

An AI system is not a stack of agents. It is a stack of decisions, and every decision leaves exhaust. The move is not to build a seventh agent that does a seventh job. It is to build the one agent whose only job is to read what the other six got wrong and turn it into a rule they cannot break twice.

An agent that never learns does not get better. It gets more confident. The seventh analyst is the one that compounds.

Same move, other seats. An AE reruns a scoring model and never asks which signals actually moved a deal, so the model never sharpens. A CSM logs a churn the health score missed and moves on, so the score misses the next one the same way. A marketer watches a campaign misread intent and never feeds the miss back, so it misreads it again. The number of agents is never the thing. Whether one of them reads the others is.

How the best teams frame it

I am not the first person to argue that a feedback loop is the difference between a tool and a system. The operators and engineers building this at scale mostly agree on where the leverage is, and it is not the number of agents. It is whether the misses get read and fed back.

SOURCE

Yash Sechdeva / Salesforce Engineering, "Closing the Loop: How to Build Self-Improving AI Systems with Automated Feedback Loops"

What it argues. The signal a system needs to improve already exists inside its own review trail, and almost every team throws it away. The fix is to mine the repeated misses, synthesize them, and feed them back into the generator automatically, with a human still approving each change before it lands. Done right, the loop even self-limits: as the system learns, the misses thin out and the changes get smaller.

My take. This is the exact thesis, built by a different team on a different artifact. The insight I keep coming back to is theirs: repeated misses are not comments, they are undocumented requirements. The seventh analyst is the thing that reads them.

SOURCE

GTM Strategist, "GTM 3.0: humans, agents, and multi-agent workflows"

What it argues. The next stage of go-to-market is not one clever agent, it is many agents working as a coordinated system with humans in the loop where judgment matters. The design question moves from "what can one agent automate" to "how do agents hand off, check each other, and stay accountable to a person."

My take. Extend. A multi-agent workflow without a meta-layer is just more agents. The coordination the piece points at only compounds if one of the agents is watching the others and the human owns the change.

SOURCE

Apollo, "Who is an AI GTM engineer? The revenue systems architect"

What it argues. The emerging GTM role is not a prompt writer, it is a systems architect who designs, wires, and maintains the revenue machine. The value is in the architecture and the upkeep, not in any single automation that runs once and rots.

My take. Agree hard. The reason my first six analysts stalled is that I built agents, not a system. An architect builds the loop that keeps the machine honest after launch. That loop is the whole job.

Even a curator has to concede when the field agrees: nobody who has actually shipped this thinks more agents is the answer. The loop that reads the misses is the moat.

The method: Solve, Stack, Split

SOLVE THE CRUX

What is the real problem, framed as work and not a headcount?

The problem is not "we need more analysts." It is "the system never learns from its own misses." So the first work is memory: make every agent log what it decided and why, every override, every missing field, every enrichment miss. For the AE that is why an account got its score, for the CSM why a health signal fired, for the marketer why a lead read as intent. The decision, and the reason, written down where something can read it later.

STACK THE CONTEXT

What tech and signals turn a pile of logs into a system that improves?

Not a shopping trip. Claude Code runs the six analysts and the seventh that watches them, each logging what it decided and why. Snowflake is the warehouse the analysts read and the audit log writes back to. Deepline runs the enrichment and scoring plays. Amplitude and Salesforce hold the product and CRM data the six read and write. The audit trail is the memory. The corrections fed back are the compounding.

SPLIT · CUT THE DRAG

What low-judgment work goes to the system?

Run the analysts, log every decision, read the trails, spot the repeated miss, draft the tightened rule. Every run, every agent, every week, with no human until there is a change to approve. This is the part that never scaled when a person tried to audit it by hand, and the part AI does perfectly because it is mechanical reading at volume.

SPLIT · KEEP THE JUDGMENT

What stays human?

The approval. The seventh analyst says this rule should tighten, this gap should be flagged, this pattern should be learned. The operator decides whether that change is right before the system mutates itself. Augment, not autopilot. One owner on the loop, and no rule ships without a person signing it.

The workflow: the board that runs it

Solve, Stack, Split is the shape. Here is the actual board, lane by lane: what the agents run, what stays human, and the tool at each step. Once it is wired, the whole thing runs every week and only stops for the one decision that needs a person.

What it moved

At a company I was at, a growth-stage B2B SaaS running a multi-agent qualification system on top of the product and CRM data, this is the exact build I ran. Give every analyst an audit trail, build the seventh to read them, close the loop back into the next run.

The system did not run more agents. It ran the same agents with one watching the rest, so the 45% signals flaw the first version shipped got found, tightened, and fed back before the next run. Accuracy came from the loop reading its own misses, not from adding another analyst.

Both of my receipts are scoring-side. Drop your own workflow in. A CSM points the same build at retention: the audit trail of every health-signal miss, read by a seventh analyst that tightens the churn model each week. A marketer points it at intent: every misread lead logged, and a loop that sharpens what counts as a real signal before the next campaign fires.

WHAT I LEARNED

1. More agents is not compounding. An agent that never learns just makes the same mistake faster, and with more confidence.

2. The exhaust is the memory. Every override and missing field is a training signal if something writes it down and something else reads it.

3. Build the seventh analyst before you build the eighth job. The meta-layer that reads the others is what turns a stack of tools into a system.

4. The system drafts the change, the human approves it. Augment, not autopilot, or the model mutates itself into a corner nobody signed off on.

Run this one this week

Do not build the whole loop. Pick the one analyst or model you trust least. Turn on an audit trail for a single week: every decision it makes, and the reason. At the end of the week, read the misses yourself and write down the one rule that would have caught the most of them. That is the seventh analyst in miniature, done by hand, and it tells you whether the full loop is worth wiring before you spend a month on it.

Two builds that sit next to this one:

• The Win/Loss Backtest · "Before you trust a scoring model, backtest it against the deals you actually won and lost. Measure lift per signal." That backtest is the miss the seventh analyst reads and feeds back.
• The Governance File · "When you automate, your failures go silent. Write them down as enforced gates, not documentation." Same instinct, pointed at the pipeline: the loop that stops a system repeating its worst week.

This is one build from the Build Log. Every week I take one sales or revenue problem, run it through the loop, and show the receipts. If someone forwarded this, the subscribe button is right below. Keep building. Heath.