GenieOS · The loop

Set the objective. Walk away.

Autonomy is the point of an agentic loop, so this page is about how little you have to do. Spawn a campaign bound to a column in your own database and the loop creates, launches, measures, learns and goes again until the number is met. It holds at your checkpoints, reports back as data, and every artefact it writes carries the lineage to prove where it came from.

loop.tsts
// One objective, bound to a column you already have.await spawn_creation({  brief: "Launch the Directory. Your health data finally has a home.",  objective: {    kpi: "users.sources_connected",    target: 400,    by: "2026-09-30",  },  channels: ["email", "social", "pages"],});// → { id: "cr_the-directory", status: "running",//     holds_at: "your checkpoints" }
The surface
  • spawn_creationBirth a campaign with the KPI it exists to move. The loop takes it from there.
  • list_creationsEvery loop that is running, with progress against its objective.
  • read_creationOne loop in full: objective, artefacts, lineage and where it is holding.
  • set_creation_defaultsDecide once how much rope every future loop gets before you spawn one.
  • list_pending_approvalsWhere the loop is paused for a human.
  • decide_approvalRelease it, or send it back with a note. The loop carries on either way.
  • create_webhookResults pushed into your stack as they land, scored against the objective.
  • get_social_post_analyticsPull what any artefact did, per network, on demand.
  • emit_eventFeed the loop a signal from your own product.
  • patch_marketing_strategyWrite what worked back into the standing strategy the next campaign derives from.
lifecycle.tsts
// 1 · Spawn it. The objective is the input.const { id } = await spawn_creation({  brief: "Launch the Directory",  objective: { kpi: "users.sources_connected", target: 400 },}); // 2 · Watch it. One call, every loop.await list_creations({ status: "running" }); // 3 · It holds where you told it to.await list_pending_approvals(); // 4 · You decide. It carries on.await decide_approval({ id: "ap_7c41", decision: "approve" }); // Weeks later:await read_creation({ id });// → { status: "complete", objective_met: true }

The whole lifecycle is four calls.

spawn_creation births a campaign with the number it exists to move. Not an open rate. A column in your own database: sign-ups, activations, sources connected. From that moment the loop creates, launches, measures and learns without another instruction.

Your agent's job collapses to supervision. list_creations to see what is running, list_pending_approvals to see where it is holding, decide_approval to release it. When the KPI says done, the loop reports complete and stops. The exit condition is the objective, not a schedule.

post-deploy.tsts
// The agent that shipped the feature also launches it.// migrations/0042_source_connections.sql just landed,// and the KPI for the launch is the column it created. await spawn_creation({  brief: "Announce source connections. The Directory is live.",  objective: {    kpi: "users.sources_connected",    target: 400,  },});

Where the agent lives

  • Claude Code
  • Cursor
  • GitHub

An agent that lives in your repo.

This is the part no marketing tool can copy, because it does not happen in the marketing tool. Your agent already has the repo open. It wrote the migration that added the column, it reviewed the feature the campaign announces, and with GenieOS in the same context it can set the objective against the exact column the feature was built to move.

Repo, database and marketing stack in one working context. The launch stops being a handover to another team and becomes the last step of the deploy.

creation.measured.jsonjson
{  "event": "creation.measured",  "creation": "cr_the-directory",  "objective": {    "kpi": "users.sources_connected",    "target": 400,    "actual": 368,    "delta_pct": -8  },  "next_iteration": {    "status": "drafted",    "derived_from": "cr_the-directory",    "holding_at": "your checkpoint"  }}

Measures against your production database

  • Supabase
  • Firestore

Results come back as data.

No dashboard to screenshot, no CSV to export. Wire a webhook with create_webhook and the measured result arrives in your stack the moment it lands, scored against the objective the campaign was born with. Pull instead with get_social_post_analytics whenever you want a number on demand, and feed the loop your own product's signals with emit_event.

The measurement is real. Bind a campaign to a column in your own production database and movement in that column is attributed back to it. The payload here is the loop reporting an 8% miss and holding the next iteration at your checkpoint, which is exactly the moment an agent should wake you.

lineage.tsts
const post = await read_social_post({ id: "po_9f2" });// post.derived_from → "cr_the-directory" const parent = await read_creation({  id: post.derived_from,});// parent.objective → the KPI this post was born to move// parent.derived_from → the campaign before that // Every artefact knows its parent. An agent can walk// the chain from any post back to the objective that// started everything.

Lineage is a data property.

Every artefact carries what it was derived from. Derived is the product's own word: not generated from a prompt, derived from a campaign that already ran and the strategy its result patched. The field is on every record the API returns.

So an agent can walk the chain. From a post to the campaign that produced it, from the campaign to the result that shaped it, back to the objective that started everything. A piece of marketing nobody briefed is still fully accounted for, which is the difference between automation you have to audit and automation you can read.

IN-APP · SUPERVISEWhether the objective is on track, at a glance.
AnalyzeFueld
OverviewEmailSocialPageMessageCampaign

Shipped in the last 30 days

18,402

REACH

24

ARTEFACTS LIVE

412

CONVERSIONS

Lands with attribution

BY CHANNEL

Email

9,140

recipients

Pages

4

live

Social

4

live

Campaigns

16

campaigns

TOP PERFORMERS

  • Your health data finally has a homeCampaign · 3d ago4
  • One place for every metricCampaign · 9d ago4
  • What your numbers were telling youCampaign · 16d ago3
  • The week your sleep changedCampaign · 23d ago4

On track, or not, at a glance.

You can read every number over MCP, and your agents will. But one record reads fine in a response, and forty artefacts across three channels and two weeks do not. Progress against an objective is a shape, and shapes want a screen.

The results view is that screen: reach, artefacts live, and conversions that land with attribution, ranked by the objective rather than by whichever number flatters the channel. Thirty seconds a day is what supervising the loop actually costs.

IN-APP · HAND OVERThe strategy the loop is running, for the person who owns the number.
Campaign strategyFueld

every campaign, before a word is written:

ObjectiveAudienceMessageChannelsDesign

OBJECTIVE

Launch the Fueld Directory — and turn the release into sign-ups.

SUCCESS METRICS

  • Sign-ups from the launch email
  • Sources connected per member

AUDIENCE

Quantified-self runnersPrimaryLongevity optimisers✳ Genie proposed

DELIBERATELY NOT ADDRESSING

Clinical practitionersCasual step-counters

CORE MESSAGE

“Your health data finally has a home.”

One place for every metric, every provider, every insight. The Fueld Directory is live.

CHANNELS

Email· BUILT
Landing page· BUILT
Social post· BUILT

DESIGN

From the Fueld brand system — colour, type and voice applied.

The person who owns the number.

You set the loop running, but somebody owns the KPI, and they are usually not the person with the terminal. The strategy view shows them what the loop believes and why: the objective, the audience, the message and the channel mix, settled before a word of copy exists.

Send them the link. They read the strategy, watch the number, and never need to know what MCP stands for. The loop is autonomous; the accountability stays human.

When this happens

  • WhenA PR merges with feat:

    ThenLaunch posts drafted for every network, held for approval

    • create_social_post
    • list_pending_approvals

  • WhenYou tag a release v*

    ThenA changelog email to everyone still on the previous version

    • compose_template
    • enroll_in_sequence

  • WhenA feature flag reaches 100%

    ThenAn announcement to the cohort that did not have it

    • create_list
    • compose_template

  • WhenA new docs page merges

    ThenA social post, and a line in the next newsletter

    • create_social_post

  • WhenYou set one objective, once

    ThenThe loop creates, launches, measures, learns and goes again, holding at your checkpoints

    • spawn_creation
    • decide_approval

  • WhenA weekly cron fires

    ThenLast week's numbers read, the strategy patched from what worked

    • get_social_post_analytics
    • patch_marketing_strategy

Where it runs

  • Claude Code
  • Cursor
  • VS Code
  • Windsurf
  • Zed
  • GitHub
  • your own backend, via SDK
  • cron

You already have an agent in your editor. Give it your marketing stack and it will ship the launch post for the feature it just helped you write.

Prefer to click? The same thing, in the app.The loop for marketers

Objective set. Objective met.

Join the Beta Connect over MCP