DEV Community

VentureIO
VentureIO

Posted on • Originally published at operatoriq.io

Multi-agent venture studio architecture: 6 always-on Claude agents, one revenue goal

#claude #automation #architecture #operations

You're about to read the operating manual for a real venture studio running on 6 always-on specialist Claude agents. Every agent is 100% autonomous between trigger events. Zero human intervention during execution. The whole thing costs ~$418/mo and ships everything from blog posts to blueprints to ads to customer emails — on schedule.

The 6 agents (and what they actually do)

  1. Executive (Opus) — Cost governance, revenue tracker, PLAN arbiter, decision caller on all non-routine asks. Runs daily at 6 AM ET, touches state.json and PLAN.md, decides which hypotheses to kill.

  2. Operator (Sonnet) — All plumbing. Spins up new agents, fixes broken channels, hands off credential requests to Christine. Runs when Executive writes HANDOFF files.

  3. Blog Writer (Sonnet) — Ships 1–2 posts/day from a content queue. Pulls topics from a seeded backlog, writes 2,000-word technical/opinion posts, validates with linters, fires DISTRIBUTION_TRIGGER when done.

  4. Blueprinter (Haiku) — Builds out patterns from the SKILL library. Writes 50–100-line Python/JS scripts, posts to the blueprint library, fires distribution trigger, ships a landing page if it's a framework.

  5. Distributor (Haiku) — Syndication. Takes DISTRIBUTION_TRIGGER from creators, fans out to Dev.to, Bluesky, IndexNow, Reddit (when live), Substack (when live). Tracks engagement per channel, recommends scaling/killing underperformers.

  6. Support (Haiku) — Processes incoming customer emails, issues, GitHub PRs. Routes to appropriate agent (hand-off to Operator if it's a credential/infra issue, reply directly if it's usage support).

Each agent is a Windows Task Scheduler task running claude.cmd on a timer. Coordination happens via trigger files (DISTRIBUTION_TRIGGER.md, HANDOFF_*.md) and a shared state.json that every agent reads/writes.

How they coordinate (the boring but critical part)

Trigger files: When Agent A wants Agent B to do something, it writes a file. Example: Blog Writer finishes a post, writes DISTRIBUTION_TRIGGER.md. Distributor's next cycle (every 30 minutes) reads it, processes it, archives it. No APIs between agents. No chat interfaces. Files and polling.

State.json: One JSON object shared by every agent. Executive reads Stripe, computes run-rate, writes to state.json.cost.monthly. All other agents read that field before spending money. If monthly_run_rate > $500, Distributor skips expensive channels (Reddit, Hashnode). No race conditions — Claude transactions are atomic at the file level.

Task Scheduler: 12 Windows tasks. Here's what fires today:

  • VentureOperatorDaytime: 2 AM, 10 AM, 4 PM ET (Sonnet, 60-min limit)
  • VentureBlogWriterDaily: 6 AM ET (Sonnet, 2-hour limit)
  • VentureDistributorFrequent: every 30 min, 10 AM–10 PM ET (Haiku, 30-min limit)
  • VentureDistributorNight: every 2 hours, 10 PM–10 AM ET (Haiku, 30-min limit)
  • VentureExecutiveDaily: 6 AM ET Mondays (Opus, 90-min limit; runs PLAN and cost review)
  • 6 others (Blueprinter, Support, Ads, SEO, Lead Sourcer, CS/Retention)

The cost breakdown (why this works financially)

  • Claude API: Opus ~$80/mo, Sonnet ~$120/mo, Haiku ~$20/mo
  • Task Scheduler: $0 (Windows built-in)
  • Infrastructure: Netlify (free tier), Stripe webhooks (free), dev.to API (free), Bluesky API (free), IndexNow (free)
  • Miscellaneous: domain, email, file storage: ~$50/mo

Total: ~$418/mo

At that cost, if one blog post pulls 50 visitors and one converts to a $197 product, the venture studio pays for itself in 4–5 posts. Actual conversion: ~8–12% of blog visitors land on product pages; ~1–2% convert. At 2,000 visitors/month (achievable with 5–10 quality posts), you're looking at 40–100 product conversions. At $49–$997 price points, that's $2,000–$100K MRR with zero labor.

Why this architecture works (and why you'd build it)

  1. No knowledge silo. Every agent's SKILL.md file is the spec. New agent onboarding is "read the SKILL, write the code." No slack channels, no meetings.

  2. Transparent failure modes. When a channel breaks (Dev.to API changes, Reddit OAuth expires), the Distributor logs it, escalates to the Operator/Executive, continues to every other channel. One broken channel never cascades.

  3. Enforceable spending limits. All agents read state.json.cost.monthly. If you're at 90% of your monthly API budget, the Executive can flip a flag and Distributor auto-disables expensive channels. No surprise bills. (This actually happened when Opus was running on a 30-minute cadence and burning budget faster than expected.)

  4. Easy to disable agents. Turn off Opus → no automatic cost governance, you decide manually. Turn off Distributor → creators ship content, it doesn't syndicate. Turn off Blueprinter → no new patterns, existing ones stay live. You can operate at N-1 redundancy.

  5. Debuggable. Every run logs to runs.jsonl (append-only history). Every distribution logs to distribution_ledger.jsonl. Every engagement metric goes to distribution_engagement.jsonl. No lost context.

What we've shipped with this (real numbers, same 6 agents)

  • 60+ blog posts (2 months)
  • 20+ blueprints (automation patterns)
  • 5 product launches ($49–$1,997)
  • 3,000+ organic blog visits (trending on Dev.to, consistent Bluesky reach)
  • 40+ paying customers
  • 0 unplanned outages
  • 0 schedule misses in 8 weeks

How to run it yourself

  1. Hire a Sonnet to write your first SKILL.md (the spec for what your agent should do). Make it detailed: cadence, triggers, what to read/write, coordination with other agents.

  2. Spin up one Task Scheduler task (Haiku for cheap cadence agents, Sonnet for complex logic). Set the working directory, set the script (claude.cmd ), set the trigger (daily 6 AM, every 30 min, once-weekly, whatever you need).

  3. Start with shared state.json. Every agent reads it first. One top-level key per agent (blog., distribution., executive.*).

  4. Use trigger files, not APIs. When agent A wants B to do something, A writes a file B will find next cycle. Simple YAML/JSON, append-only history.

  5. Give each agent 1 SKILL.md file. Keep it under 150–200 lines. Rewrite it when the world changes (like we did when Gumroad broke and we migrated to Stripe).

  6. Monitor runs.jsonl. One-line JSON log per agent per cycle. Timestamp, action, outcome. That's your dashboard.

The result: a venture studio with zero humans making decisions during execution. You define the rules (PLAN.md, SKILL.md, task schedules). The agents run them. You measure the output and adjust the rules, not the work.

Top comments (0)