The map of 11 agents and two gates

1. The rule

It is not the number of agents. It is how the work hands off between them. A team of 11 agents with no orderly handoff and no gate that stops things is just 11 ways to break content.

• Each agent hands the next one exactly what it needs, not more.
• A control gate stops broken work before it moves on.
• One agent does not approve itself, review comes from a clean context.
• Even the best gate misses sometimes, which is why there is a human eye at the end.

2. Iron rule: State Sync before anything else

Nothing starts before a state sync. The agent first reads what is already published, what is scheduled and what is queued, and only then gets to work. A weak idea gets rejected before it even starts.

• No State Sync, no research, no idea, no production.
• A brief that scores below 7.0 does not become an idea card.
• This check saves hours of production on an idea that would have fallen apart in the end.
• Better to reject early and cheap than late and expensive.

3. The seven creator agents

Seven agents touch the material long before it even reaches a gate. Each one hands its output to the next in line.

• source_scout collects raw signals: comments, conversations, sources.
• trend_analyst filters for hot topics and ranks them by relevance.
• content_master builds the angle and structure of the deck.
• producer actually produces the slides and assets.
• hebrew_copywriter sharpens the copy in spoken Hebrew.
• visual_director owns the scene, the object and the typography.
• guide_cta_operator builds the guide and the CTA that brings it back in a DM.

4. The two gates

After the creators finish, there are two gates. One checks the content, the other blocks a broken publish. They do not create anything, they only stop things.

• editorial_qa: the proofing gate. State Sync, duplicates, Hebrew, positioning, CTA collisions.
• publishing_guard: the last gate. Blocks upload, scheduling and publishing if something is off.
• A gate that fails sends the material back, it does not push it forward.
• Two separate gates because content proofing and publish blocking are two different decisions.

editorial_qa checks:
- Whether a State Sync was done
- Whether there is duplication of a content family or CTA
- Whether the Hebrew is natural and free of errors
- Whether the positioning holds

publishing_guard blocks if:
- There is no live guide URL for the CTA
- Media is not in the right format
- A required target network failed without approval

5. Manager and publisher

The two agents left out of the eleven close the loop: one manages the flow, one puts the work out.

• manager routes the work between agents and keeps the pipeline order.
• publisher takes the material that passed both gates and schedules it for publishing.
• The manager is just one junction, not the whole story. The story is the handoff and the gates.
• The publisher runs only after both gates said yes.

6. How the work hands off between agents

The key is that every stage hands the next one a defined package, not the whole history. That is what keeps the noise down and the pipeline clean.

The handoff chain:
source_scout -> raw signals
trend_analyst -> ranked topics
content_master -> deck angle and structure
producer -> slides and assets
hebrew_copywriter -> sharpened copy
visual_director -> visual scene
guide_cta_operator -> guide + CTA
--- gate 1 ---
editorial_qa -> content approval or return
--- gate 2 ---
publishing_guard -> publish approval or block
publisher -> scheduling
(manager routes the whole way through)

7. The honest lesson: even the gate gets it wrong

Once the automatic control agent, running on Gemini Pro, scored a broken slide between 9 and 10 and missed the flaw. That is why I still check it myself at the end. A human eye at the end is not a failure of the system, it is part of its design.

• A high score from an automatic gate is not proof the slide is fine.
• Read every slide with your own eyes, like a native Hebrew speaker, before sending it out.
• The automatic gate handles 95 percent of the work, the human catches the edge cases.
• Do not build a system that assumes one gate is immune to mistakes.

8. A template for building your own pipeline

Want to build your own agent team? Do not start at 11. Start with the skeleton: a clear handoff, one gate, a human eye.

Minimal skeleton:
1. What blocks a start? (for me: State Sync + brief score >= 7.0)
2. Who are the creators and what does each one hand to the next?
3. Where is the gate that checks content?
4. Where is the gate that blocks a broken publish?
5. Who routes and who puts it out?
6. Where is the human eye that catches what the gate missed?

Add agents only after the skeleton has worked manually twice.