A founder looking for their first customers usually has neither the budget for an agency nor the time to do everything by hand. With fog, they run one agent per growth task from their coding agent, review the deliverable and move on to the next decision.
fog (Founders Growth agents) is the open source stack of AI marketing agents that swanbase publishes under the Apache 2.0 license. Version 2.0.0, released on November 14, 2026, includes thirteen agents covering market research, first users, SEO, landing pages, prospecting, carousels, ads, short videos, founder posts, publishing, a weekly report and a monthly sprint. Every agent runs in Claude Code, Codex, Cursor, Gemini CLI and any coding agent that can read files and run commands. The code is on GitHub, the official site is fog-agents.com and the technical guide lives in the Marketing Agents Playbook.
This article covers what an AI marketing agent is in 2026, how fog structures each agent, how scripts check the model's work and how to get started.
Why we built fog for founders
Early-stage founders are good at building and late to selling. Marketing gets pushed to "after launch", and an agency costs more than the runway allows. Generic prompts then fill the gap with confident copy full of made-up customers, unsourced numbers and quotes nobody ever said.
We wrote fog for swanbase around the opposite rule: one agent per growth task, with code that checks every agent. The stack packages the methods we teach the startups we support into a form you run yourself. It is open source so other founders can read it, modify it and fork it.
What an AI marketing agent is in 2026 (a working definition)
A folder your coding agent reads
In fog, an AI marketing agent is a folder of files that your coding agent reads and executes. You don't run a bot or a cloud service. Here is how an agent is structured:
agents/
└── market-signal/
├── AGENT_MARKET_SIGNAL.md ← the workflow: inputs, steps, checks, deliverable
├── README.md ← setup, optional tools, examples
├── config.example.json ← per-project settings
├── skills/ ← methods, in Agent Skills format (SKILL.md)
├── scripts/ ← Python scripts that count, check and render
├── assets/ ← rubrics, templates, JSON schemas
├── references/ ← API docs and background reading
└── examples/ ← fictional runs that show the output
Open the repository in your coding agent and type in plain language:
Run the market-signal agent. Market: freelance invoicing tools for designers.
The coding agent reads the workflow, asks any missing questions in a single message, works through the steps, runs the scripts and writes the deliverable to your project folder. The same folder works in Claude Code today and in Codex tomorrow, with no changes.
Agent, chatbot, prompt, skill: four different jobs
| Concept | Form | Output | When to use it |
|---|---|---|---|
| Prompt | One sentence | Varies | One-off question |
| Chatbot | Open-ended conversation | Varies | Brainstorming, exploration |
| Agent | Written workflow (AGENT_ |
Same format on every run | Repeated task with a defined deliverable |
| Skill | Reusable method (SKILL.md) | Block loaded at a given step | When a method serves several steps or agents |
With an agent, you ask for "this deliverable, in this shape, every time", whichever tool runs it.
Anatomy of an agent file
Every AGENT_<NAME>.md in fog follows the same contract, in the same order. The format was settled on swanbase's internal agents before the code was opened up.
- Step 0: context. The agent identifies the project, loads the shared context written by project-context, reads the project memory and announces which tools it will use. It then asks every missing question in a single message, each with a default value.
- When to run. One to three sentences a founder can read in five seconds: before you write your copy, when traffic drops, before you pay for ads.
- Inputs needed. The list of inputs, required or optional, with the value used if you don't answer.
- Tools. The capabilities the agent needs (web search, scraping, screenshots...) and the free fallback for each one.
- Workflow. Numbered steps. Each step points to a skill or a rubric and ends with a verifiable "Done when" criterion: a file that exists, a command that exits cleanly, a count.
- Checks before delivery. The shared checks, in a fixed order: scripted copy review, evidence verification, JSON file validation, visual render review, a fresh-eyes review and a log entry.
- Output, location and failure modes. The skeleton of the deliverable, its path in your project and what to do for each failure. A missing API key triggers a fallback and never stops the run.
A founder opening any agent file finds the same parts in the same place. The Marketing Agents Playbook walks through each part with examples.
Vertical agents vs a mega-agent
Many agent stacks pile fifty skills into one giant agent, with every tool loaded into the same context. The model loses track.
Each fog agent does one task, with only the context that task needs. It fits in a single session, the model stays focused and you can switch tools without rewiring anything.
To chain several tasks, fog goes through files. Agents never call each other: each one reads, from your project folder, the files the others have written. market-signal delivers verified quotes that cold-outreach-builder, static-ads-builder and carousel-builder reuse. first-users-hunter delivers a CSV of prospects for cold-outreach-builder. If a file is missing, the agent works on its own. And when you want to chain everything toward a goal, growth-sprint runs the agents in order, checks each result on disk and only comes back to you for human decisions.
Our Claude Code vs Cursor comparison shows how your choice of tool affects how much context you can handle.
The 13 agents in the fog stack
The site groups the thirteen agents into five families. Each agent page has two buttons that copy the install prompt and the run prompt.
Setup
project-context. Run it first, once. From your website URL, the agent extracts your brand guidelines (colors, fonts, logo variants), then writes your business context: offer, audience, tone. Every piece of evidence (customer, number, testimonial) keeps its source, date and consent status. The other twelve agents read from this folder.
Demand and first users
market-signal. Run it before you write copy or code, then regularly to track your market. The agent stores a corpus pulled from Hacker News, Reddit, Stack Exchange, forums and app reviews. A script counts mentions and checks every quote word for word against its source.
first-users-hunter. Run it after validation, when you want ten real conversations this week. The deliverable has one row per person who asked for what you're building, with the dated signal, proof they still post and a first message written for them.
cold-outreach-builder. Run it for your first 50 to 200 conversations. The agent builds a sourced file on each prospect, opens every first message with a true, dated fact, checks the sequence with a script and tracks replies from one run to the next. It delivers a CSV that any sending tool can import, and it never sends anything itself.
Visibility and conversion
seo-audit. Monthly, or when traffic drops. The agent crawls the served HTML, reads Search Console and Google results, and measures your citations in answer engines along with your E-E-A-T signals. A topic registry blocks duplicates and suggests new topics. In writing mode, the agent drafts the article in your tone, renders its visuals in your colors, adds internal links and delivers everything as a patch for your site's repository. It then tracks the published page at 14, 28 and 56 days.
landing-page-analyzer. Before you pay for traffic, or after a launch. The agent audits the page against a 340-criterion rubric organized around LEVER (cost, trust, usability, understanding, motivation), measures the page in the DOM and walks through the form without submitting it. Every finding links to its evidence, and every fix comes out as a before/after render, then as a patch.
On-brand content
carousel-builder. For a LinkedIn or Instagram carousel that teaches something. Six art directions and 3 to 20 slides, each measured and reviewed, delivered as PDF, JPEG and MP4. Rendering runs through HTML, CSS and Playwright, with no paid API.
static-ads-builder. For your Meta ad creatives. The agent first reads the previous period's results, prepares concepts for each funnel stage, then renders 1:1, 4:5 and 9:16 visuals locally with the exact copy and your real logo. Your best-performing ad becomes the base for five single-variable tests. An image model only comes in for a photo background, after two budget approvals.
short-video-builder. For a talk, pitch or interview filmed in landscape. The agent produces 9:16 short videos with local transcription, hooks taken word for word from the footage, a full review before rendering, face tracking and word-by-word captions.
founder-content-writer. Turns your notes, a voice memo, a call or a talk into LinkedIn and X posts in your style. Every post points back to a passage in your source material, and the agent checks every number against your evidence list. The agent publishes nothing.
Publishing, measurement and planning
content-publisher. When a deliverable is ready. The agent writes one version per network (LinkedIn, X, Instagram, and optionally Threads and Bluesky), checks each platform's limits with a script and queues everything. Only a person can approve a post. By default, sending stays simulated; you can connect Zernio, a local command or a webhook.
growth-pulse. Once a week. The agent uses scripts to compute your numbers from Plausible, Umami, GA4, Search Console, social networks and your revenue, checks every figure in the report and proposes three AARRR experiments for the next sprint.
growth-sprint. When you have a goal for the month, such as "15 first conversations". You approve a plan, then the agent chains the other agents inside your session. The paid API budget stays at 0 by default.
The repository also includes _template-agent, the skeleton you copy to build your own agent.
The Marketing Agents Playbook has the long version, with line-by-line examples.
Your tools, with a free fallback
Marketing agents need to act: search the web, read a page, take a screenshot, generate an image. fog doesn't hard-wire any API. Each agent asks for a capability, and you pick the provider in your project's tools.json file:
| Capability | Example providers |
|---|---|
web_search |
Exa, Serper, Brave, Tavily, your coding agent's built-in search |
scrape |
Firecrawl, Jina Reader, curl, built-in web reading |
serp |
Serper, SerpApi, DataForSEO |
screenshot, page_speed |
Playwright, PageSpeed Insights, Lighthouse (free) |
image_gen |
fal, OpenAI, Gemini, or your own tool using the agent's prompts |
email_finder |
Hunter, Dropcontact, Apollo, or your own enrichment |
Every capability also accepts builtin (your coding agent's built-in tool), manual (you paste the information in) or none. At the start of each run, the agent announces its tool plan. A missing tool lowers the quality of the result, and the report lists it in its Limitations section.
The CLIs from cli-skills (exa, firecrawl, gsc, perplexity) remain available as the default toolbox for anyone who wants the providers the stack was built with.
Deliverables are written to your project folder as <project>/<agent>/<name>-<YYYYMMDD>.md, with a JSON file alongside for downstream agents. Version them in Git and compare them month over month. No platform holds your data.
Scripts keep the model in check
In fog, the model writes a spec, a script builds the deliverable, then a check loop verifies the result. Five rules follow from that.
- No evidence, no output. Customer names and testimonials come from your evidence list or a source URL. A claims check and a writing check block everything else before you ever see the draft.
- Scripts do the counting. Mention counts, growth figures, word limits, layout measurements and quote matching all run through Python. The report can only cite numbers the scripts produced.
- You stay in control. Agents prepare, and every send or expense goes through you. A post requires approval typed by a person, and every paid call waits for explicit confirmation.
- Fresh eyes review the work. A sub-agent with no session history scores the deliverable against a rubric. A second pass by the session that produced the work doesn't count as a review.
- fog learns your taste. Every run is logged, and every draft you reject becomes a rule for the next run.
Each agent also has its own tests, which run offline with no API key. The validate_stack.py script checks the repository's consistency on every push.
How to build your own agent (a 4-step method)
Step 1: copy _template-agent
The repository ships with this skeleton. It sets the structure every agent follows: workflow file, README, config.example.json, at least one skill, assets and a references/ folder.
cp -r agents/_template-agent agents/my-new-agent
Step 2: fill in the workflow contract
Write each section of the contract in order, from Step 0 through failure modes, with a "Done when" criterion at every workflow step. Any method longer than about fifty lines moves into a skill. The Marketing Agents Playbook covers each part in detail.
Step 3: hand the math to scripts
Anything that can be counted, measured or compared goes through a script: the model writes the spec, and the script produces and checks the result. Add an offline test for every script.
Step 4: validate and run it on several cases
Run python3 scripts/validate_stack.py from the repository root, then run the agent on a range of cases in at least two coding agents. If the shape of the deliverable varies, tighten the template. If the content is still weak, make the workflow more precise.
Portability rules
An agent is portable when it behaves the same way in Claude Code, Codex, Cursor and Gemini CLI. The fog template enforces a few strict rules:
- No tool-specific functions. No
mcp__*, noclaude-*, no call that only exists in one tool. Shell, Python andtools.jsoncapabilities are enough. - No required API. Every external call goes through a capability with a free fallback: a local program, a built-in tool or manual input.
- No absolute paths. The agent works from your project root, using POSIX paths.
- Deliverables live outside the agent folder. They are written to
<project>/<agent>/, so agit pullupdates the agent without touching your files.
Once an agent breaks these rules, it only runs in one tool.
fog vs the alternatives (agency, SaaS, DIY)
| Criterion | Freelance agency | Marketing agent SaaS | DIY (from scratch) | fog |
|---|---|---|---|---|
| Monthly cost | Agency fees | Subscription | Founder's time | Your coding agent, optional APIs |
| Auditable | No | No (black box) | Yes | Yes (readable markdown and Python) |
| Script-verified numbers | Depends on the agency | Rarely | Depends on your code | Yes, in every deliverable |
| Modifiable | No | Limited | Yes | Yes (fork it directly) |
| Portable across tools | N/A | No | Depends on the implementation | Yes |
| License | Contract | Subscription | Yours | Apache 2.0 |
We list more tools for founders on our free tools page.
How to get started now
- Clone the repository:
git clone https://github.com/tns-research/fog-agents.git, then open the folder in your coding agent. - Run project-context:
Run the project-context agent for https://your-site.com. The agent saves your brand and business context and offers to write yourtools.json. - Pick the agent you need right now: market-signal before you write, landing-page-analyzer before you pay for traffic, seo-audit for your next article.
The fog-agents.com site presents each agent with its inputs, deliverables and ready-to-copy prompts. If you build an agent that could join the public stack, submit it as a pull request on GitHub.
FAQ
What exactly is an AI marketing agent?
In fog, an AI marketing agent is a folder. It holds an AGENT_<NAME>.md workflow file, markdown skills, Python scripts and deliverable templates. Your coding agent (Claude Code, Codex, Cursor, Gemini CLI...) reads the workflow, runs the scripts and writes the deliverable to your project folder. There is no server or proprietary SDK to maintain.
What is the difference between an agent, a chatbot and a prompt? A prompt is a one-off instruction. A chatbot replies over an open-ended conversation. An agent follows a written workflow with inputs, numbered steps, checks and a fixed-format deliverable, so it produces the same shape of result on every run, whichever tool executes it.
Do I need to know how to code to use fog? You only need to know how to clone a Git repository and open a folder in your coding agent. From there, you run each agent in plain language. The scripts need Python 3, and the rendering agents also need Playwright and ffmpeg. Editing an agent or building your own means reading markdown and a little Python.
How much does fog cost? fog is free and licensed under Apache 2.0. No paid API is required: every agent has a free fallback. You pay for your coding agent (a Claude or ChatGPT subscription, for example) and for any third-party services you choose to connect, such as Exa, Firecrawl or fal. Any spending always requires explicit confirmation.
Which coding agents does fog work with? fog works with Claude Code, Codex, Cursor, Gemini CLI, GitHub Copilot, Grok, Mistral Vibe and Amp, plus any tool that can read files and run shell commands. The agents never call a function that only exists in one tool.
How long does it take to get started?
Getting started takes one repo clone and one sentence: Run the project-context agent for https://your-site.com. Without an API key, the agent uses your coding agent's built-in web search and web reading. You can add your keys later if you want faster providers.
Why is fog licensed under Apache 2.0? You should be able to read, verify and modify any agent that prepares your marketing decisions. Apache 2.0 allows commercial use, modification and forking, as long as you keep the notices in the NOTICE file.
Does fog replace a marketing agency? For a founder looking for their first customers, fog covers the work people often hand to an agency: market research, prospecting, SEO, landing page audits, carousels, ads, short videos and a weekly report. The agents prepare the work, and you stay in control of every post and every expense. Once you are managing a team or large ad budgets, a marketing team is still worth having.
We build fog at swanbase, the growth marketing accelerator that supports European startups in Paris and remotely, by application. To go further, read the fog page, our roundup of open source alternatives for AI agents and our definition of Claude Code.
