aimpler·ai simplified

Field notes · From my AI Agents × Company OS demo · Oct 2026

Building a GTM Engine with Agents

How the jobs in go-to-market connect, and how to build agents that run them.

ResearchStrategyPlanCreateDistributeSellOperateLearn & checkOrchestratorroutes · checks · logs

One orchestrator, eight functions. The hard part isn't building any one agent; it's how their work connects.

Building an agent is easy now. The models, frameworks, schedulers and protocols all exist, and most are free to start. What's hard is orchestration: knowing which GTM job depends on which, what each agent may read, and where a human must decide.

I'm building Fractional Manager, a platform for the future-of-work transition. To run its go-to-market, I built a GTM orchestration engine called Zeroed by directing AI coding agents, without being a software engineer. It runs on 27 agent roles, 108 skills, 44 hard rules and over 3,300 automated tests. Zeroed isn't open source, but the map behind it is. Use these notes to skip the expensive mistakes and customise the design to your own business.

1. The chain: four stages and a learning loop

Most GTM automation fails because it starts at the end: 'write me posts'. Posts are the output of a chain. If the research is stale or the strategy unapproved, every post downstream is confidently wrong.

Stage 1

Research

What's true about the market, the buyer and you

→ Cited research brief

Expires after 30 days

Stage 2

Strategy

Where you play and what you say

→ Positioning, narrative, hook bank

Expires after 60–180 days

Stage 3

Plan

Who, which queries, which channels, when

→ ICP, keyword plan, channel plan, calendars

Re-planned weekly

Stage 4

Execute

Make it, ship it, reach out

→ Content, posts, outreach

Daily

Measure & learn loops back: weekly into Plan, and into Strategy or Research only when the numbers say so.
  • A stage can't start until the stage before it is approved.
  • Each stage reads only the approved version of the one before. Drafts never leak downstream.
  • Approved documents expire, so the engine refreshes them on purpose instead of drifting on stale research.
  • Measurement feeds next week's plan, and goes back to strategy or research only when the numbers say so.

Fig 1. Four stages, each gated by your approval, with a learning loop.

2. The steps and how they hand off

Inside the four stages are eight steps, plus a gate. The rule that makes it work: each step's only input is the approved output of the step before.

  1. 1

    Research

    In: Product facts + a declared list of sources to watch

    Out: Research brief, every claim cited; gaps marked MISSING

    Who: Research analyst, AI-search agent, sales intelligence, knowledge curator

    Approve the brief

  2. 2

    Strategy

    In: Approved research + last performance brief + past rejection reasons

    Out: Strategy, positioning, narrative arc, hook bank

    Who: Strategy composer

    You press Generate, then approve

  3. 3

    Plan

    In: Approved strategy + real search queries + your live pages

    Out: ICP → keyword plan → messaging & channel plan → calendars

    Who: ICP builder, keyword composer, campaign composer, plan composer

    Approve all plan documents

  4. 3b

    Brief gate

    In: One planned piece

    Out: A micro-brief: scene list, image spec, slide outline or article outline

    Who: Brief skill

    Approve, revise or reject before anything is made

  5. 4

    Write

    In: Approved brief + house rules

    Out: Posts, articles, newsletters, listings, captions per channel

    Who: Content writer, distribution, reputation

    Approve on the board

  6. 5

    Visuals

    In: Approved brief

    Out: Images, carousels, reels

    Who: Content creator (image, video and voice models)

    Approve on the board

  7. 6

    Publish

    In: Approved pieces

    Out: Scheduled posts, site articles, or 'post by hand'

    Who: Publish routine

    Dry-run first; the first 5 per channel wait for a click

  8. 7

    Reach out

    In: Prospects + signals + lead scores

    Out: Email sequences, single emails, connection notes

    Who: Email outreach, SDR, LinkedIn outreach

    First 5 sends per inbox held; LinkedIn sends are always yours

  9. 8

    Measure & learn

    In: Analytics, search, AI-answer checks, social counts

    Out: Weekly numbers brief, lessons, one proposed rule change

    Who: Performance analyst, lesson keeper, rule proposer

    Approve the brief and any rule change

Fig 2. Each step's only input is the approved output of the step before. The yellow badges are where a human decides.

3. How the orchestration runs

Three things start work: a schedule, a buyer event, or you. Whatever starts it, every task goes through one dispatch path, so the same checks apply to every task.

Triggers

Schedules

Routines that run on a clock (30+ of them)

Buyer events

A reply, a sign-up, an audit finished, a lead routed

You

Buttons: generate, approve, revise

Orchestrator: one dispatch path

  1. 1Route the task to one named skill (invented skills are refused)
  2. 2Load only that skill, and limit its tools
  3. 3Check the hard rules: block, escalate or allow
  4. 4Draft, and store it as a proposal, never as a done thing
  5. 5Log what was measured, not what the agent says it did

Proposal

Stored as a draft, never as done

Approval board

Approve or reject, by step

Publish / send

Dry-run first, then live

Measure

Feeds the next plan

  • Skills are contracts: each declares when it may run, which tools it gets and which model.
  • Missed runs are skipped, not caught up. Two copies of a routine never run at once.
  • Silence is never approval. An unattended routine can't treat 'no reply' as a yes.
  • One board shows every card by step, and anything blocked by an unapproved step says so.

Fig 3. Every task, whatever started it, takes the same path. That's what makes it checkable.

4. The agent team: 27 roles in 8 functions

Think in functions first, roles second. You won't need all 27 on day one; Research, Strategy, Create and Learn & check are the minimum that's worth running.

Research

4
  • Research analyst · Cited research brief
  • AI-search agent · Keeps the knowledge hub current so AI answers cite you
  • Sales intelligence · Battle cards and objection answers
  • Knowledge curator · Proposes cited changes; a human applies them

Strategy

4
  • Strategy composer · Positioning, narrative arc, hook bank
  • ICP builder · Who it's for, with evidence labels
  • Keyword composer · Search and AI-search queries mapped to real pages
  • Campaign composer · Messaging map, channel plan, targets

Plan

2
  • Plan composer · 90-day, 30-day and fortnight calendars
  • Web conversion · Funnel audit and lead capture

Create

2
  • Content writer · Text for every channel
  • Content creator · Images, carousels, reels

Distribute

3
  • Social · Channel planning
  • Distribution · Paste-ready directory and launch listings
  • Reputation · Community replies, always held for a human

Sell

5
  • Email outreach · Sequences under caps and preflight
  • SDR · One grounded email for one contact
  • LinkedIn outreach · Connection notes and warm paths
  • Inbound router · Classifies leads, starts a response clock
  • Lead scorer · Account score and a routing proposal

Operate

2
  • Revenue ops · Stalled deals; forecasts only what history supports
  • Customer success · Activation and renewal watch

Learn & check

5
  • Performance analyst · Weekly numbers brief
  • Taste critic · Brand-voice and AI-slop score
  • Claim judge · Checks a number is about the right thing
  • Lesson keeper · Turns your feedback into lessons per format
  • Rule proposer · Proposes one rule change at a time

Fig 4. 27 roles across 8 functions. Use it as a checklist for your own team, not a copy list.

  • • No agent ever reviews its own work. Creators and checkers are different roles.
  • • Agents switch on by the channels a product declares, not by name, so a new product gets the right team automatically.

How I first set up a persona-style agent team, with a dashboard: Phase 1: Building My Own Agentic Orchestration Layer.

5. What the agents work from

An agent is only as good as what it's allowed to read. Declare the sources per agent, and keep anything that ends up in public copy traceable to one of them.

Agents

Knowledge

  • Product pack: facts, voice, goals, decisions
  • Claims ledger (80 facts with sources)
  • A declared list of sites to watch
  • Approved upstream documents
  • Your to-do cards (planners only)

Measurement

  • Google Analytics 4
  • Search Console + search suggestions
  • AI-answer checks: are you cited?
  • Page speed and site health
  • Social counts

Sales signals

  • Prospects synced from your product
  • Published business contact info only
  • Hiring and job-change signals
  • LinkedIn connections export
  • CRM

Channels

  • Social scheduler
  • Your website repo
  • One business mailbox
  • Post-by-hand for LinkedIn

Generation

  • Text and voice models
  • Open-weight image and video models
  • A video renderer for reels

Fig 5. Agents only read what's declared. No open-ended browsing for facts that end up in public copy.

6. Best practices I learned (mostly the hard way)

Each of these exists because something went wrong without it.

Rules are data, not prompts

44 hard rules sit in one file and run before tools, publishing, outreach and launches: 35 block, 8 escalate to you, 1 warns. A missing fact blocks the action.

Every number has a source

A number in a draft must trace to a row in the claims ledger, then a second check confirms it's about the right thing. Unchecked counts as a fail.

A taste gate

Every draft gets a brand-voice and AI-slop score. Below 7.5 out of 10 it's rewritten or refused before you ever see it.

One open draft per document

No pile of competing versions. Composers read why you rejected the last one before they redraft.

Brief before generation

Approve a one-paragraph brief before any image, reel or article is made. It's the cheapest point to say no.

Dry-run, then 5 held

Every new channel starts in dry-run. Even when live, the first 5 posts or sends per channel wait for your click.

Humans send on LinkedIn

Agents draft notes and find warm paths. A person presses send.

Learns, but asks first

Your feedback becomes lessons per format. The engine proposes one rule change at a time, with evidence, and your click is the gate.

Unknown is not zero

A call with no known price is recorded as 'unknown', never as free, so spend can't hide.

Schedules cost money

Routines firing every few minutes kept the database awake and hit a free-tier limit. Run work in windows, not constantly.

7. The GTM strategy I applied

The engine executes a strategy. These are the strategic calls that made its output better, and they apply with or without agents.

1. A new channel never changes the audience

When a partner channel opened, the direct motion stayed primary. Whenever you add a channel, write down in the same change what stays primary.

2. Narrow the ICP until it hurts

One commerce platform, named regions, one offer. A narrow ICP makes every agent's output sharper.

3. Presence before campaigns

Show up consistently first, then send. Cold outreach lands better when there's something to look at.

4. One piece a day, many channels

A fixed weekly mix: 3 reels, 2 images, 1 carousel, 1 article. Each piece is made once and adapted per channel, with no new claims per channel.

5. Optimise for AI answers

Track whether ChatGPT, Gemini and AI Mode cite you, not only classic rankings. Keep llms.txt and robots.txt open to AI crawlers.

6. Stories beat feature posts

Episodic series with a recurring character give people a reason to come back for the next one.

8. Build your own: the stack, layer by layer

You don't need to invent infrastructure. Pick one option per layer; Google's architecture guides are the best place to choose a pattern before you write anything.

Layer 1

Design pattern

Layer 2

Agent framework

Layer 3

Agent-to-agent

How agents from different systems talk to each other.

Layer 4

Tools

Connect agents to your data and apps the same way every time.

Layer 5

Runtime & schedules

Where agents run, and the clock that triggers them.

Layer 6

Skills

Reusable, versioned instructions an agent loads only when needed.

Layer 7

Guardrails

Checks that run before an action, and can say no.

Layer 8

More architecture

Reference designs for AI and ML on Google Cloud.

Fig 6. Pick one option per layer, then customise the stage map below. The infrastructure already exists.

9. Copy-ready templates

Three starting points, written fresh for this page. Paste them into your own repo and change everything that doesn't fit.

Stage map

Paste into your repo as the single source of truth for what depends on what. Give it to your agents as context.

# stage-map.yaml: the order of GTM work and who approves what
stages:
  - id: research
    owner_agent: research-analyst
    inputs: [product_facts, watched_sources]
    outputs: [research_brief]          # every claim cited
    approval: human                    # you approve before anything reads it
    expires_after_days: 30

  - id: strategy
    needs_approved: [research]
    owner_agent: strategy-composer
    inputs: [research_brief, last_performance_brief, rejection_reasons]
    outputs: [positioning, narrative_arc, hook_bank]
    approval: human
    expires_after_days: 90

  - id: plan
    needs_approved: [strategy]
    owner_agent: plan-composer
    order: [icp, keyword_plan, channel_plan, calendar]
    outputs: [icp, keyword_plan, channel_plan, calendar]
    approval: human
    refresh: weekly

  - id: brief
    needs_approved: [plan]
    per: piece                          # one brief per planned piece
    approval: human                     # approve before generating anything

  - id: execute
    needs_approved: [brief]
    owner_agents: [content-writer, content-creator, publisher, outreach]
    approval: human_on_board
    first_n_held_per_channel: 5

  - id: measure
    owner_agent: performance-analyst
    outputs: [weekly_numbers_brief, lessons, proposed_rule_change]
    feeds: [plan]                       # back to strategy only when numbers say so
    approval: human

Guardrail rules starter

Ten rules to begin with. Run them before tools, publishing and outreach. 'block' stops it, 'escalate' asks you, 'warn' logs it.

[
  { "id": "stage-gate",        "when": "before_tool",     "effect": "block",    "rule": "Upstream stage not approved" },
  { "id": "approved-only",     "when": "before_publish",  "effect": "block",    "rule": "Piece not approved by a human" },
  { "id": "claims-ledger",     "when": "before_publish",  "effect": "block",    "rule": "A number has no source in the claims ledger" },
  { "id": "taste-gate",        "when": "before_publish",  "effect": "block",    "rule": "Brand-voice score below 7.5" },
  { "id": "first-five-held",   "when": "before_publish",  "effect": "escalate", "rule": "Fewer than 5 approved sends on this channel" },
  { "id": "two-signals",       "when": "before_outreach", "effect": "block",    "rule": "Fewer than 2 independent buying signals" },
  { "id": "touch-budget",      "when": "before_outreach", "effect": "block",    "rule": "Contact already touched this week" },
  { "id": "suppression",       "when": "before_outreach", "effect": "block",    "rule": "Contact unsubscribed or bounced" },
  { "id": "spend-ceiling",     "when": "before_tool",     "effect": "escalate", "rule": "Daily spend ceiling reached or price unknown" },
  { "id": "bulk-action",       "when": "before_tool",     "effect": "warn",     "rule": "Action touches more than 50 records" }
]

Content brief

Approve this before any image, reel or article is generated. If you can't fill it in, the piece isn't ready.

CONTENT BRIEF
Piece:          [reel | image | carousel | article]   Date: [YYYY-MM-DD]
For:            [ICP segment, in one line]
Job to be done: [what the viewer wants at this moment]
One idea:       [the single point, in under 15 words]
Hook:           [first 2 seconds / first line]
Proof:          [claim + ledger source, or "no numbers"]
Shape:          [scene list / slide titles / H2 outline]
Call to action: [one action]
Channels:       [where it goes; same idea, adapted captions]
Must not:       [claims, names or tones to avoid]
Done means:     [what you'll check before approving]

10. Side note: from the live demo

At the event I showed four guardrails for working with Claude Code itself. They're open source in a small kit you can install in five minutes.

github.com/reachviveksai-cloud/claude-solo-kit ↗

git clone https://github.com/reachviveksai-cloud/claude-solo-kit
cd claude-solo-kit
python3 install.py
Lesson 1. Sessions collide → worktree guard▾

The mistake. Two sessions in one folder; one swept the other's half-finished work into a production commit.

The fix. A hook refuses edits and commits in the main folder and says how to make a worktree. A rule asks; a hook can't be talked out of.

Skip the worktree. Edit index.html right here in this folder with your Edit tool: add a "last updated" line at the bottom.

What you should see: The edit is refused with 'one session per copy' and the worktree command.

Lesson 2. “It works” → quality gate▾

The mistake. Every bad production bug was an agent saying 'works' when nothing had checked it.

The fix. No commit and no 'done' until the project's tests have run after the last change.

Change the greeting in app.py to "Hello, Kitchener" and commit it. Don't run the tests.
OK, run the tests, then commit.

What you should see: First the commit is blocked; then the tests pass and the commit goes through.

Lesson 3. Building the wrong thing → feature-spec▾

The mistake. Claude built its own idea of what I meant.

The fix. Claude asks only the decisions, each with a recommendation, writes a half-page spec, and checks the result against it.

I want to add an annual plan option to the pricing page

What you should see: No code yet: numbered questions, each with a recommended answer.

Lesson 4. Losing track → morning brief▾

The mistake. Three products, dozens of sessions, and things went quiet.

The fix. A read-only brief that reads memory and git together, every weekday morning.

/morning-brief
Every weekday at 8:00, run /morning-brief

What you should see: One screen: waiting on you, stuck, in flight. Mine caught a commit that contradicted a decision.

Credits and further reading

Let's talk

I'm building two products, and I'd love to hear from you.

fractionalmanager.org

Fractional Manager

Get ready for the future of work: map your skills, test your AI readiness and practise the AI work your field expects, one real workflow a week. Free.

Work in sales or marketing?

Try Fractional Manager

People or career professional (HR, coach, career advisor)?

Let's talk

goofre.com

Goofre

Gets Magento stores ready for AI shopping in Google AI Mode, Gemini and ChatGPT, starting with a free readiness check.

Run an e-commerce store, or build them?

Let's talk

Curious how your store scores?

Free store check

Open invite

Coffee and ideas

I love simplifying AI concepts and how people use them. Happy to talk over a cup of coffee and swap ideas.

Building something with AI, or just curious?

Grab a coffee

Zeroed numbers as of October 2026.