Incubating With AI Leverage — High Peak Studio

Incubation used to be a headcount game. Today it’s an orchestration game: the founders who wire up agents, data, and workflows into compound loops will ship three ventures in the time it used to take to scope one PRD. This playbook shows you how to turn AI leverage into compounding output—without burning trust, capital, or your own attention.

Why AI leverage changes incubation economics

Incubation economics used to be linear. You staffed a pod, bought time, and hoped scope tolerated the people you hired. AI leverage breaks that link. With a handful of orchestrated agents and tight checks, one founder can explore 20 theses, prototype five, and push two to revenue—concurrently.

Speed alone is not the point. What matters is the change in the unit of work. A “unit” is no longer a sprint’s worth of tickets; it’s a repeatable loop that translates a market signal into a production artifact, then back into a better loop. That loop is the asset. Agents are just the muscles.

We’ve seen this firsthand. In our studio, a single conductor with six role-templated agents took an idea from memo to paid pilot in 11 working days. The output wasn’t just a demo. It was a build script, a deployment pipeline, a corpus of support content, a pricing page, and a pilot agreement—all generated, critiqued, and revised by an orchestrated system with guardrails.

The Compound Output Model

Here’s the framework we use and teach: the Compound Output Model. It’s a way to design incubation so every cycle produces two things: immediate artifacts you can ship, and durability that makes the next cycle cheaper and better. You win by compounding both.

Think of your system as creating three categories every day:

Value Loops: Closed loops that translate inputs (signals, data, prompts) into shipped artifacts (code, content, contracts) with feedback captured into the system.
Durability Multipliers: Assets that don’t decay with time or load—domain libraries, test suites, runbooks, datasets, templates, brand primitives, and pre-negotiated legal shells.
Velocity Amplifiers: Automation that makes the next loop faster—agent roles, prompts, evaluation harnesses, deployment scripts, scaffolds.

In healthy incubation, these three reinforce each other. A value loop turns sales calls into product changes and content updates. Those updates create durable docs and tests. The tests power better agents and safer automation, which compresses the loop time. That compounding is your advantage against bigger, slower shops still managing tickets.

Value Loops

A value loop has six parts: source, transform, assemble, evaluate, ship, learn. You capture a signal (support thread, analytics spike, founder hunch). You transform it into candidate artifacts (spec, draft, patch). Agents assemble those into a coherent deliverable. Evals run. You ship a version. Then you record what happened: what got used, what broke, what converted.

Close the loop by writing the learning back into prompts, checklists, and datasets. Don’t trust human memory. Treat every loop as a generator of training data for the next pass. If an agent wrote an onboarding email that got a 38% reply rate from ops managers, the copy and the metadata around the audience belong in your corpus.

Durability Multipliers

Durability is a studio’s compounding capital. Most teams produce artifacts that evaporate: ephemeral Slack debates, ad hoc scripts, untracked spreadsheets. Replace those with assets that get better with use: canonical glossaries, reusable microservices, legal clauses that survive different customer types, battle-tested prompts with eval scores attached.

When in doubt, ask: does this survive rotation of the human who made it? Can a new agent or new teammate use this tomorrow with almost no context? If yes, you’ve built durability. If not, you’ve created velocity debt.

Velocity Amplifiers

Agents, prompts, and pipelines are the force multipliers. But raw agents aren’t leverage—they’re liabilities until you apply structure. Velocity amplification comes from predictable roles, strict interfaces, and automatic gates. Your goal is to make the standard path the fast path.

Amp examples: a “SpecCritic” agent that red-teams PRDs against user jobs and legal landmines; a “PatchComposer” that can convert failing tests into candidate patches with provenance notes; a “Narrator” that turns diffs and changelogs into release notes and sales enablement content. Each amplifier should publish its contracts (inputs, outputs, evals) so your graph stays trustworthy.

Compound output is not doing more things; it is building a machine that makes the next thing cheaper, safer, and closer to revenue.

The Orchestra and the Conductor: Agent architectures that ship

We’ve tried every agent fad. The pattern that ships is boring: define roles, bind them to a graph, and enforce gates. Leave emergent magic for ideation; put the rest on rails.

Role-templated swarms

Start with five canonical roles. We use: Scout (research and signal capture), Architect (design, decomposition, acceptance criteria), Builder (generation and refactor), Critic (evaluation and test synthesis), and Narrator (documentation, sales collateral, change comms). Humans can play any seat. LLMs play most seats most of the time.

Each role gets a template: a set of goals, constraints, tools, and output schemas. For example, the Architect outputs a “Decision Dossier” with: objective, constraints, solution sketch, alternatives considered, trade-offs, and tests the Critic must satisfy. These templates become your stable interface—so you can swap models or tools without breaking flow.

Critical-path graphs and gates

Don’t run agents free-form. Map a directed acyclic graph of tasks from signal to ship. Insert gates where failure is costly: legal exposure, customer promises, data migrations. Gates are enforced by automated evals plus a human signoff threshold. If the evals pass and risk is low, the system ships. If not, it escalates to a human with a clear diff and proposed remediations.

A simple example: a “Feature-to-Release” graph could go PRD → SpecCritic → Builder → TestSynth → PatchComposer → RegressionSuite → Canary → Narrator. Gates sit after SpecCritic (strategy/legal), RegressionSuite (reliability), and Canary (real-user impact). Everything else runs as fast as the models can think.

Memory that matters: transient vs durable

Agent memory is where studios lose months. Split memory into transient context (conversation-level), project memory (issue tracker, decision docs), and durable corpora (versioned knowledge bases with eval tags). Use vector stores for recall, but treat them as indexes, not truth. Ground your agents in small, curated sources of record.

We keep three stores: Contracts (APIs of your own services and third-party dependencies), Canon (domain knowledge, style guides, prompts, legal shells), and Telemetry (what shipped, to whom, with what results). Agents read Canon and Contracts; evals write to Telemetry. Humans review Canon diffs weekly like code.

Operating System: The 5/50/500 rhythm

To make AI leverage real, you need an operating rhythm that forces compounding. We use the 5/50/500 rhythm: 5-minute interactions, 50-minute craft blocks, 500-minute sprints. It’s a cadence that balances vibe coding with gates and outcomes.

5-minute interactions

Every input to the system must be compressible into a 5-minute interaction. That includes a founder’s hunch, a customer quote, or a bug report. Use a prompt form that captures objective, constraints, stakes, and example of done. The system should respond with a plan, not a blob—proposed graph, artifacts to create, risks to check.

Example: “A prospect asked if we can redact PII in their PDFs before indexing.” In five minutes, the Architect proposes: add a pre-index filter, list supported PII types, select a proven redactor library, write tests with synthetic PII, add a toggle to the UI, and update the privacy page. The Critic attaches risks: false negatives, latency, and legal posture.

50-minute craft blocks

Reserve 50-minute blocks for deep work by agents and humans. Pick one loop and drive it from plan to gate. In that time, the Builder should generate code or content, the Critic should generate tests and run evals, and the Narrator should assemble docs. You end with artifacts ready for a gate, or a clear kill decision with learnings written to Canon.

These blocks are where vibe coding shines. Pair a human with a Builder in a shared workspace, let the human set intent and constraints, then riff. Keep tools that mirror that rhythm: structured prompts, local run harnesses, and one-click evals. If you can’t get to a gate in 50 minutes, your loop is too fat or your gates are too strict.

500-minute sprints

Weekly, allocate roughly 500 minutes (one day) per active venture to ship something customer-visible. That could be a pilot, a pricing test, a webinar, or a new integration. The rule: the sprint ends with an artifact that a stranger can react to, and the reaction becomes data in Telemetry.

Set two numbers for the sprint: throughput (how many artifacts shipped) and fidelity (how well they met their acceptance tests and evals). Review Canon diffs. Cull messy prompts. Kill loops that produce noise debt. Your pace becomes sustainable because quality checks are part of the rhythm, not an afterthought.

Examples: three ventures incubated with AI leverage

These are not hypotheticals. They’re scenarios we’ve run or advised, with conservative numbers. The names are ours; the patterns are portable.

ForgePilot: a developer automation CLI from memo to MRR

Thesis: developers hate yak-shaving for CI/CD and env setup. We incubated ForgePilot as a CLI that introspects a repo, proposes a CI pipeline, generates config, and opens a PR with tests and docs. The wedge: support for monorepos and polyglot stacks where off-the-shelf templates fail.

Day 1: the Scout harvested 30 public repos with complex CI. The Architect built a decision dossier outlining minimum-viable integrations (GitHub Actions, GitLab CI), risks (secrets handling, flaky tests), and success metrics (pipeline pass rate, time-to-first-green, PR merge rate). The Builder generated a Go binary skeleton and an initial Action template. The Critic synthesized tests by simulating broken pipelines and secret leakage scenarios. The Narrator drafted the README and a two-page sales one-pager for team leads.

Day 4: we had a working prototype on five languages with evaluators that measured: pipeline generation accuracy, diff minimality, and reproducibility. The gate required 90% detection of existing jobs, zero plaintext secret instances, and green CI on three seed repos. We missed the first pass due to flaky matrix configs; the Builder refactored using heuristics learned from Telemetry.

Day 9: we onboarded three design partners. Agents created per-repo adapters, wrote migration notes, and turned Slack feedback into failing tests. The Narrator turned changelogs into weekly updates. Our first MRR came on Day 11: a team paying for “PR concierge”—the system’s agent ran nightly diffs, proposed optimizations, and explained trade-offs.

Artifacts produced in two weeks: a CLI binary, six reusable evaluators (secrets, matrix, caching), 22 prompts with scores, an onboarding guide, a pricing page, and a lightweight DPA. These durability multipliers made every subsequent repo cheaper. The compounding was obvious: each new integration added tests and patterns the system reused.

LumenLedger: AI-driven ledger reconciliation for fintech ops

Thesis: mid-market fintechs reconcile millions of transactions with CSVs and human heroics. We incubated LumenLedger as a recon engine with explainable matching, anomaly surfacing, and audit-ready notes. The risk wasn’t building matches—it was trust, compliance, and edge-case provability.

Week 1: the Scout mined public PSD2/PCI guidance and anonymized bank CSV schemas. The Architect designed the core graph: ingestion → schema normalization → feature extraction → match proposals → human-in-the-loop → audit trail. Gates at PII handling, match explainability, and export immutability. The Builder generated schema adapters and a match proposal engine using LLM+feature rules. The Critic built evals on synthetic datasets with seeded anomalies and class-imbalance traps.

Week 2: we onboarded two sandboxes. Agents built a consent ledger and a redaction filter with test coverage. The Narrator shipped docs explaining match rationales with plain-language evidence (“Rule match: description token overlap 0.87, date delta 0, amount delta 0.00; learned match: merchant alias mapping validated by 17 prior matches”). Legal shells for DPA and SOC2 prep were templated into Canon.

Week 3: first pilot. A risky assumption failed: some merchants polluted descriptors. The system hit the explainability gate and escalated. Within 50 minutes, the Architect proposed a “learned alias book” with human approval, the Builder wrote it, the Critic seeded tests with adversarial noise, and we resumed. Because the gates and loops existed, we didn’t derail; we upgraded durability.

By Week 4, we had 96.3% match rate on the pilot corpus, 98% of matches with explainability artifacts, and zero PII leaks in Telemetry. Sales collateral wrote itself: the Narrator turned eval dashboards into value proof. This would have taken quarters with ticket-driven teams; with agents and gates, we compressed the cycle without compromising control.

GroveCart: ecommerce ops co-pilot that closes tickets, not opens them

Thesis: Shopify brands drown in repetitive support (order status, returns, missing items) and ops (supplier ETA, restock alerts). We incubated GroveCart to resolve tickets automatically across Shopify, 3PL, and helpdesk, then escalate with full context when needed.

Day 1: define the loop: ingest ticket → retrieve order/3PL state → propose resolution → simulate → ship response → learn from rating. Gates: refund policy adherence, fraud risk, tone guide, and helpdesk SLA. The Builder generated connector stubs for Shopify, Gorgias, and ShipBob. The Critic built evaluators for policy alignment and bad-actor patterns. The Narrator wrote macro templates and a brand voice style guide.

Day 3: a closed-beta merchant processed 184 tickets with GroveCart on simulation-only. 68% achieved policy-compliant resolutions automatically; 22% flagged for human approval; 10% escalated with a context pack. Telemetry recorded time saved per ticket, refund leakage risk, and customer CSAT proxies.

Day 7: we flipped to live on a subset. Refund leakage dropped 13% due to the Critic’s adversarial prompts that caught “friendly fraud” patterns. Macros and playbooks became durability multipliers. Integrations and prompts became amplifiers. We didn’t scale headcount for volume; we scaled loops and the assets behind them.

Common failure modes and counter-arguments

There are good reasons to be skeptical. Most “agent” demos are theater. Let’s address the arguments and show mitigation that actually works in an incubation setting.

“Agents hallucinate; we can’t trust them.”

Yes, they do, when you let them. Trust is not achieved by picking a bigger model; it’s designed via constraints, retrieval, and evaluation. Bind agents to small, curated contexts; require structured outputs; and run evals that punish confident nonsense. Put hallucination-sensitive steps behind gates and offer escalations with diffs, not blobs.

We reduce hallucinations by: grounding in Canon and Contracts only; templating outputs with JSON schemas; scoring with discriminators trained on your domain; and rejecting answers that fail self-consistency checks. In LumenLedger, explanations read like evidence because the system is required to cite features and prior matches. If the evidence doesn’t exist, the gate trips. That’s design, not faith.

“Speed ≠ strategy.”

Also true. Speed without strategy is just entropy. But incubation is not a board strategy offsite; it’s a sequence of cheap bets driven into the market quickly. The Compound Output Model forces strategy into the loop because every artifact must tie to an acceptance test and a customer reaction. It’s a ratchet: you can change direction fast, but you don’t spin.

We encode strategy into Decision Dossiers and gates. If a feature can’t state which job-to-be-done it addresses and how we’ll measure success in a week, it doesn’t pass the Architect gate. If we can’t produce a sellable artifact in 500 minutes, we kill or shrink the loop. Speed protects strategy by making bad bets cheap.

“Noise debt and entropy will drown us.”

This is the most valid risk. AI-native teams can drown in artifacts. The fix is boring hygiene: version Canon, require diffs, rotate curators, and set retention policies. Don’t index everything; index only the blessed sources. Make “delete” a celebrated action.

Set budgets for Telemetry and vector stores. Agents shouldn’t read the whole world; they should read the smallest slice that makes them right. Weekly, run a “Canon Cleanup” where you purge duplicative prompts, merge playbooks, and archive outdated facts. Pay down noise debt like real debt—with discipline and explicit rituals.

Toolchain that doesn’t fight you

Your stack should accelerate the rhythm, not impress Twitter. Opinionated picks and patterns matter. Here’s what we’ve stabilized on for incubation speed with control.

Interface layer: contracts over chat

Stop “talking” to agents. Call them. Use a layer that enforces function-like contracts with JSON schemas, timeouts, and retries. Let agents handle text; let your orchestrator handle structure and state. Add an interaction DSL for vibe coding when you want to riff, but persist the plan and the artifacts, not the vibe itself.

Patterns we like:

RunOps-style runners that execute graphs locally and in CI with the same semantics.
Prompt templates with variable slots and test fixtures; prompts live in Canon with versioning and eval scores.
Structured outputs for all agent responses; validators auto-reject malformed outputs and re-ask with narrowed context.

Data layer: the canon, the contracts, and consent

Use a small, curated vector database for Canon and Contracts. Tag every chunk with provenance, version, and last-verified date. Build a feature store for evaluators and discriminators; those features are your studio’s secret sauce. For anything that touches customer data, implement consent logging and redact before index by default.

We prefer boring, proven pieces: Postgres for truth, an S3-like store for artifacts, a vector index layered on top, and a search interface with guardrails. Make adding to Canon a PR with review. If you wouldn’t accept a code PR with that level of sloppiness, don’t accept a prompt or a policy PR.

Governance: evals, red teams, and kill-switches

Governance is not a slide deck. Bake it into the graph. Every gate should have an evaluation harness that runs quickly and deterministically enough to be meaningful. Maintain a small red-team corpus per venture: adversarial prompts, edge cases, and known-bad patterns. Run them often.

Add kill-switches where it counts: a flag that forces human approval for high-risk actions (refunds over N, schema migrations, public comms during incidents). Couple that with escalation packs that include the proposed change, the diff, the eval scores, and the predicted blast radius. Make it easier to do the right thing than the fast thing—by making the right thing the fast thing.

Hiring and org design for AI-native incubation

AI leverage reshapes roles. Don’t hire “prompt engineers” as a class. Hire orchestrators and craftspeople who can ride the leverage without drowning in the outputs.

Chief Orchestrator

This is your force multiplier. The Chief Orchestrator owns the graph, the gates, and the Canon. They think like a product manager, a release engineer, and a librarian. They prune loops, promote durability, and enforce the 5/50/500 rhythm. They are measured by compound output: shipped artifacts per week that meet gates and produce learnings.

1x engineer with 10x agents

Stop chasing mythical 10x humans. Hire 1x engineers who can manage 10x agents. Their job is decomposition, environment setup, eval writing, and surgical fixes when the Builder stalls. They must be comfortable pairing with LLMs, writing tests first, and refactoring prompts like code.

We pattern our pods as 1-2 human engineers, 1 conductor, and a set of role-agents. That’s enough to ship a venture to revenue. The marginal cost of a new hypothesis is almost zero once the Canon and the graph exist. That’s the compounding dividend.

QA as a product

QA is not a department that shows up at the end. It’s a product—the Critic role and its evaluators—that you build from day one. The best AI-native studios have better evals than anyone else in their niche. That’s where trust and speed meet.

Make evals first-class. Give them names, owners, and dashboards. Tie go/no-go gates to them. Celebrate improvements in eval coverage like new features. If you can’t measure it quickly, you can’t ship it safely at agent speed.

Metrics that matter: throughput, fidelity, lift

If you don’t measure, you’ll confuse motion with momentum. Our metrics are simple and brutal. They guide decisions daily.

Throughput: shipped artifacts per week that clear gates. Count code merges behind canary, content published to the public web, contracts sent to customers, integrations live.
Fidelity: percent of artifacts that pass their evals on first attempt, and time-to-green when they don’t. If fidelity drops, you’re compounding garbage. Fix Canon or gates before you add scope.
Lift: measurable delta versus your human-only baseline. Human minutes per artifact, time-to-first-value for a new customer, win rate in sales cycles, LTV:CAC for the pilot cohort. If lift doesn’t rise as throughput rises, you’re automating busywork.

Track noise debt: artifacts created that never ship or get used. Keep it under control with cleanup rituals and a bias for deletion. Instrument the agent system itself: prompt usage, eval pass rates by agent, and oscillation (how many re-asks before a valid output). These meta-metrics tell you where to invest in better prompts, better context, or different model choices.

Vibe coding without chaos

Vibe coding is real: the creative flow between a human and an agent that unlocks non-obvious solutions. The risk is untracked magic. We keep the vibe but capture the value.

Rules of thumb:

Riff in 50-minute blocks with a clear objective and an exit gate.
Snapshot the session plan and the final artifacts to Canon; don't archive the entire chat.
Extract reusable prompts into templates with evals; delete raw transcripts after 72 hours unless they contain unique insights.
Convert breakthroughs into durability: a new evaluator, a new library function, a new playbook page.

That way the vibe feeds the machine, instead of becoming a private genius tax that the org can’t reuse when the human leaves.

Patterns we reuse

Incubation is pattern work. These named patterns ship.

Conductor’s Graph: an explicit DAG from signal to ship with gates, evaluators, and role bindings. Lives in repo, versioned, diffed.
Decision Dossier: a standard artifact from the Architect that captures objectives, constraints, options, trade-offs, and tests. Required before build.
Eval-First Spec: Critic writes evaluators and synthetic datasets before Builder writes code. If you can’t eval it, you can’t ship it.
Context Diet: agents are starved by default; they must request Canon chunks and justify reads. Less context, fewer hallucinations, faster runs.
Escalation Pack: when gates trip, the pack includes proposed action, diffs, eval scores, risks, and a 2-minute human review path.
Telemetry Ledger: every shipped artifact logs metadata—who, what, when, evals, reaction—so Narrator can auto-generate updates and sales collateral.
Kill or Codify: at the end of a failed loop, either kill the idea or codify the learning into Canon. No zombie work.

Choosing models and when to switch

Model selection is an operations problem, not a religion. Start with a capable frontier model for unknowns and drop to cheaper models as you codify Canon and Contracts. The goal is predictable performance at predictable cost per artifact.

Rules we follow:

Use a strong general model for Architect and Critic until evaluators stabilize.
Use specialized models or distilled variants for Builder and Narrator once outputs are templated.
Keep a “spike lane” where a stronger model can be invoked for hard cases, but log why and try to eliminate the need by improving Canon or evaluators.
Benchmark lift per dollar, not raw quality; the cheapest reliable path wins as long as gates stay green.

Switching models is easy if your interfaces are strict. It’s hell if your agents are glued to a chat transcript. Invest in contracts up front and you can arbitrage models all day.

Pricing and go-to-market at agent speed

Shipping faster doesn’t matter if you can’t sell. Use agents to compress GTM experiments while keeping your brand and promises tight.

Playbook:

Have Narrator draft three positioning statements and a one-page landing for each wedge. Gate with a “Clarity” eval comparing against a corpus of clear messaging.
Run price tests as artifacts: live pricing pages with explainers tailored to ICPs. Telemetry collects CTR, demo requests, and self-serve conversions.
Auto-generate sales enablement: release notes translated into talk tracks and objection handlers grounded in Canon and Telemetry.
Instrument churn and activation; convert patterns into onboarding playbooks that agents can run end-to-end.

Because GTM outputs are artifacts with evals and gates, you can iterate without stepping on rakes. Keep legal shells ready and watch tone; nothing kills trust faster than A/B tests that feel like experiments on your best prospects.

Security and compliance without slowing down

You can be fast and safe. The trick is to codify controls into gates and Canon. Don’t bolt them on after the first pilot; build them into your first loop.

Practices we enforce:

Redact and sign: all PII gets redacted before indexing; all actions that touch customer systems are signed and logged.
Principle of least context: agents only see what their role requires; secrets are accessed via short-lived tokens and never written to Canon.
Policy-as-prompts: compliance constraints (DPA, SLA, SOC2 controls) live as prompt fragments and evaluators that block risky outputs.
Incident drills: simulate a data leak or a bad refund. The Escalation Pack should assemble in under 2 minutes with all diffs and logs.

You’ll lose speed if you rely on hero memory. You’ll gain speed if your system knows the rules and enforces them at machine pace.

Finance and portfolio construction under AI leverage

AI leverage changes the portfolio math for a studio. Your cost to test a thesis is lower. Your capacity to run parallel bets is higher. But signaling risk and brand risk grow if you spray and pray.

We use a staged capital model tied to gates:

Explore (one week): two loops to a public artifact; max spend X; kill rate > 60%.
Probe (two to four weeks): three customers touch the product; gates on legal shells and data handling; kill rate ~40%.
Commit (one to three months): MRR and gross margin targets; staffing decision; brand attachment.

Because evaluators and Telemetry exist, you can make decisions with more signal and less narrative. You also know your real unit economics per artifact, which makes marginal bets legible. When it’s time to scale, you’re not “hiring to figure it out”—you’re hiring to pour fuel on loops that are already compounding.

Counter-arguments from operators we respect

Let’s steelman the pushback from thoughtful founders and execs who’ve shipped real products sans agents.

“We tried agents; coordination costs killed us.”

Coordination costs explode when agents share a pool of unstructured context and chat. The fix is to move coordination into the graph and the Canon. Roles read from blessed sources, write structured outputs, and pass through gates. Humans review diffs, not transcripts. The conductor reduces cognitive load because the work product is predictable.

“Eval coverage is a mirage; you can’t eval originality.”

True, you can’t eval art. But you can eval constraints around the art: coherence, policy adherence, factual footnotes, and regression safety. Keep originality in the 50-minute vibe block, then codify the parts that must not break. It’s like jazz on top of a rhythm section—the rhythm is the eval harness.

“Our domain is too regulated.”

Then you need gates more than anyone. Put policy into Canon, use policy evaluators, and keep high-risk acts behind human review with Escalation Packs. In practice, regulated domains benefit from machine-enforced consistency. Humans make sloppy mistakes; agents don’t deviate when the rules are clear.

How to apply this tomorrow

Here’s a 24-hour plan to move from theory to compound output. Assume you have one founder, one engineer, and access to a solid LLM.

Pick one loop. Choose a thin slice that ends in a public artifact: a landing page with a lead magnet, a CLI that does one thing well, or an internal tool that removes a manual step. Declare the acceptance test and the user reaction you’ll capture.
Stand up Canon, Contracts, and Telemetry. Create three repos or folders. Canon: style guide, glossary, policy, core prompts. Contracts: API specs for anything you’ll call. Telemetry: a simple log schema (artifact, owner, eval scores, user reaction).
Define the Conductor’s Graph. Write a short DAG: Scout → Architect → Builder → Critic → Narrator. Name two gates. Specify inputs/outputs for each role. Keep it in code so you can run it locally and in CI.
Template your roles. For each role, write a one-page template: goals, constraints, allowed tools, and output schema. Seed with one or two prompts. Keep it boring.
Write two evaluators. Start with one quality eval (does this solve the job-to-be-done?) and one safety/compliance eval relevant to your domain. Seed them with five synthetic examples each, including adversarial cases.
Run a 50-minute block. Kick off the loop on a real input. Pair the human with the Builder to push through the first gate. Expect failure; the point is to create Telemetry and learn where Canon is thin.
Narrate and ship. Let Narrator convert diffs into a changelog and a public artifact (blog post, release note, landing page update). Put it in front of a stranger today. Capture the reaction in Telemetry.
Clean Canon. Delete or merge messy prompts. Promote one prompt to a template with an eval score. Add a playbook page for the loop you just ran.
Schedule your 5/50/500 rhythm. Block tomorrow’s calendar with two 50-minute loops and a 5-minute check-in at the start of each hour. Pick a weekly 500-minute sprint where something shippable must emerge.
Iterate model choices. If Architect or Critic outputs are weak, upgrade the model for those roles. Keep Builder on a cheaper model once prompts stabilize. Always record when you switch and why.

If you execute this, you’ll have your first compound outputs within 24 hours: a Conductor’s Graph you can reuse, role templates you can copy, evaluators that will keep you safe, and a public artifact that generates market feedback. Do it again tomorrow. That repetition is the compounding engine.

Advanced tactics once the basics work

When your first loops are stable, add leverage gradually.

Portfolio Canon: extract shared domain and style guides across ventures into a top-level Canon. Now every new venture starts with durability.
Auto-PRs: let Builder create PRs with attached eval scores. Humans review diffs and approve if gates are green. Cuts friction dramatically.
Dynamic gating: increase or relax gate thresholds based on customer tier or artifact impact. Higher stakes require higher fidelity before ship.
Provenance watermarking: tag artifacts with their agent lineage and Canon versions. When something breaks, you can trace it instantly.
Discriminator training: train lightweight classifiers to score agent outputs in your domain. Cheap, high-precision filters save cycles and reduce escalations.
Bench arcs: maintain a bench of semi-built loops you can spin up quickly when a market window opens. Keep them warm with quarterly refreshes.

What not to do

Common anti-patterns will crush your leverage. Avoid them.

Chat sprawl: if your org lives in endless chat with agents, you’ll never scale. Replace chats with structured interactions and saved artifacts.
Prompt hoarding: thousands of unscored prompts are rot. Score, version, and delete aggressively. Promote only the best to Canon.
Gate theater: gates with no enforcement are lies. Wire evals to CI, log scores in Telemetry, and block merges when risk is high.
Model monogamy: sticking to one model because “we standardized” is dogma. Your orchestrator should make it easy to swap for cost or quality.
Hero dependence: if one founder’s vibe sessions are the source of all wins, you’re fragile. Codify or die.

Case study integration: compounding across ventures

The real prize is compounding across a portfolio. We’ve seen ForgePilot’s evaluators (secrets detection, minimal diffs) reused in two other tools. LumenLedger’s explainability format improved GroveCart’s refund reasoning. Narrator prompts tuned for technical clarity lifted sales conversion for a billing analytics venture by 18%.

Here’s how to institutionalize cross-venture compounding:

Maintain a shared Canon for cross-cutting concerns: security, legal shells, tone, onboarding patterns.
Adopt a venture template repo with the Conductor’s Graph, role templates, a starter eval suite, and CI hooks. “git clone” your operating system.
Run a monthly “asset exchange” where each venture contributes one evaluator, one prompt, and one playbook page that cleared a real gate. Curate aggressively.
Make cross-venture KPIs visible: throughput, fidelity, and lift normalized by headcount. Let healthy competition sharpen the system.

This is how studios with small teams look big: the compounding isn’t in the Slack channel; it’s in the assets that every new project can start with on day one.

Cultural principles that make leverage durable

Tools and models matter. Culture matters more. Without the right defaults, your compound output decays into noise.

Ship to learn: every loop must end in a public or customer-facing artifact. Private wins don’t compound.
Prefer deletion: deleting out-of-date Canon is a heroic act. Reward it.
Tests are truth: if an idea can’t be expressed as an evaluator, it’s not ready to ship.
No silent changes: every Canon change is a PR with a Narrator-generated summary and examples.
Escalate early: gates trip fast and provide a clean human path. No shame, no blame—just diffs and decisions.

Frequently asked build questions

We get the same tactical questions often. Here are crisp answers.

How big should Canon be? As small as possible while keeping fidelity high. If agents need more than 20-30 curated pages plus Contracts to perform, your Canon is bloated or unfocused.
Do we need RAG? Yes, but keep it scoped and curated. RAG is a scalpel, not a net. Index blessed sources; ban web trawling in production loops.
What about code security? Use restricted sandboxes for Builder runs, static analysis in gates, and secret scanning evaluators. Never let agents write to prod directly; PRs only.
How do we handle long-running tasks? Split into sub-loops with their own gates. Don’t let a single agent hold state for hours; that’s how memory corrupts and context costs spike.
Which language for Builder? The one your team can debug at 2 a.m. Leverage comes from evaluators and gates, not from a fashionable stack.

How to apply this tomorrow: the tactical closer

Tomorrow morning, run this play as written. No vendor roadshow, no three-month platform build. You need a graph, two evaluators, a Canon, and one loop that ends in a public artifact. That’s it.

Write a two-sentence thesis and a one-sentence “done.” Example: “Ops managers hate reconciling invoices to bank deposits. Done = exportable report with 95% matches and explainable notes.”
Create Canon with four pages: glossary, tone/style, legal shell for your domain, and a “What’s in/what’s out” for the loop. Add one prompt template per role.
Define two gates: quality and safety. Quality: passes job-to-be-done eval. Safety: complies with policy. Write five positive and five adversarial examples each.
Implement the Conductor’s Graph in your task runner or CI. Codify inputs and outputs. Log Telemetry.
Kick the loop. If you can’t hit a gate in 50 minutes, you picked too big a slice. Shrink and try again.
Ship something public. A working demo, a landing page with a signup, a GitHub release. Capture reactions. Feed them to Telemetry.
Clean Canon, delete noise, and promote one evaluator improvement. Repeat daily.

In a week, you’ll have a stack of assets you didn’t have before: evaluators, prompts with scores, docs, and a habit of shipping. In a month, you’ll have a venture with revenue or a clean kill and durable learnings. In a quarter, you’ll run three ventures in parallel without hiring a platoon.

Bottom line

Incubating with AI leverage is not about more models; it’s about better loops, stricter gates, and compounding assets. Design for compound output and the rest follows: trust, speed, and market signal. If you can ship value today and make tomorrow cheaper, you’re on the right path.