MiroFish Setup Guide: How I Simulate Startup Launches with 44 AI Agents

This is the technical deep dive behind my AI market simulation post. If you want to run your own MiroFish simulation for a SaaS launch or product idea, this guide walks through the exact stack, prompts, and configuration I use.

The Full Stack: Tools, Prompts & Architecture

Tools Used

Here’s the stack I’m running right now for startup‑style market simulations:

Layer	Tool	Purpose	Cost
Simulation engine	MiroFish	Core multi-agent simulation framework	Open source
Graph memory	Zep Cloud	Knowledge graph + long‑term memory	Free tier
Primary LLM	GPT‑4o‑mini	Ontology generation, report writing	~$0.01/run
Secondary LLM	Gemini 2.0 Flash	Agent personas, simulation turns	Free tier
Frontend	Vite + React	Simulation dashboard UI	—
Backend	Flask + Python	API, simulation orchestration	—
Package managers	uv (Python) + npm	Dependency management	—

MiroFish itself uses GraphRAG, OASIS, and Zep under the hood, and can talk to any OpenAI‑compatible LLM backend.

Mirofish Architecture Overview

Here’s the end‑to‑end flow for a single run:

1. Seed document (.md, .pdf, .csv)
2. Ontology generator (GPT‑4o‑mini) builds structured concepts and entities
3. Zep Cloud GraphRAG extracts entities and relationships and builds a knowledge graph
4. Persona generator (Gemini 2.0 Flash) creates 44 agent profiles
5. OASIS simulation engine runs 10 rounds × 44 agents on a Twitter/Reddit‑style social graph
6. Report agent (GPT‑4o‑mini) synthesizes adoption curves, objections, and narratives
7. Final report exported for humans (you) to read and act on

In MiroFish terms, this roughly maps to: Graph building → Environment setup → Simulation → Report generation.

The Seed Document (Most Important Input)

Your seed document decides how smart and grounded the simulation feels.
Think of it as a market research brief plus narrative context.

Suggested structure:

# [Product Name] — Market Research Brief

## Executive Summary
What the product does, who it's for, what problem it solves.

## The Problem Space
Specific pain points per user segment.
Include numbers, time lost, costs, existing hacks.

## Target User Segments
For each segment:
- Who they are (geo, seniority, stack/tools)
- Their specific pain
- Price sensitivity
- How they discover new tools
- Named personas with brief backstory

## Competitive Landscape
Direct + indirect competitors, pricing,
where they’re strong/weak, switching triggers.

## Product Overview
Core value prop, feature set, pricing model,
onboarding assumptions.

## Key Industry Debates
Controversial topics in your space that agents
will naturally argue about.

The more named personas with backstory you include, the richer the agent profiles Zep + MiroFish can extract from the text.

The Simulation Prompt

You don’t start the simulation with “prove my idea is good.”
You start with a scenario prompt that invites real disagreement and behavior.

Template:

[Product] has just [launched / announced / pivoted].

How do different user segments react?
- Who adopts immediately, and why?
- Who hesitates, and what are their objections?
- What does the dominant narrative look like in
  [Reddit / Twitter / Slack communities] in the first 30 days?
- How do users in [geography A] respond differently
  from users in [geography B]?
- What would need to be true for [conversion event]
  to succeed?

Good prompts are:

• Anchored to a specific event (launch, pricing change, feature deprecation).
• Focused on behavior, not vibes.
• Include a segment or geography contrast.
• End with a conversion‑style question (trial signups, team adoption, etc.).

This prompt goes into MiroFish as part of the “prediction requirement” for the simulation run.

LLM Routing Strategy (Cheap vs. Good)

Don’t use one model for everything. I split it like this:

• High‑stakes, low‑volume → GPT‑4o‑mini
  • Ontology generation (1 call per run)
  • Final report synthesis (1 call per run)
• High‑volume, lower‑stakes → Gemini 2.0 Flash (free)
  • Agent persona generation (1 per agent)
  • Simulation turn decisions (1 per agent per round)
  • Memory / graph retrieval calls

Why: running the whole thing on a small local model or only a 7B often gives shallower reasoning and flatter personas. Agents that should be skeptical aren’t, and cultural nuance gets lost. For anything that might impact your roadmap, the extra cent is worth it.

.env Configuration

A minimal environment configuration looks like this:

# Primary — quality tasks
LLM_API_KEY=sk-proj-...
LLM_BASE_URL=https://api.openai.com/v1
LLM_MODEL_NAME=gpt-4o-mini

# Secondary — high-volume tasks
LLM_SECONDARY_API_KEY=AIza...
LLM_SECONDARY_BASE_URL=https://generativelanguage.googleapis.com/v1beta/openai
LLM_SECONDARY_MODEL_NAME=gemini-2.0-flash

# Memory graph
ZEP_API_KEY=z_...

MiroFish accepts any OpenAI‑compatible backend, so you can also swap in Qwen or other providers later if you want to experiment.

RAM & Cost Reality Check

On my setup, the trade‑offs look like this:

Setup	RAM used	Cost per run	Quality
Local 7B (LM Studio)	4.5–5 GB	$0	Medium
Gemini only	0 MB	~$0	Good
GPT‑4o‑mini only	0 MB	~$0.06	Good
GPT‑4o‑mini + Gemini (hybrid)	0 MB	~$0.01	Best

Local 12B/7B on a MacBook Air is doable but makes the machine sluggish and still doesn’t match the reasoning depth of the hybrid cloud setup. Similarly, if you want, you can try better models than GPT-4o.

Estimated Time Per Run

Rough timings for a ~15K‑character seed doc, 44 agents, 10 rounds:

Phase	Time
Seed doc upload + ontology	1–2 min
GraphRAG build (Zep)	7–10 min
Persona generation (44 agents)	1–2 min
Simulation (10 rounds)	4–6 min
Report generation	30–60 sec
Total	~15–20 min

GraphRAG is the longest step and runs on Zep’s servers — your local machine is basically idle while that happens.

When to Use This Setup

This exact stack works well if you want to:

• Simulate product launches and positioning changes.
• Model campaign reactions across different geos and segments.
• Stress‑test pricing changes or policy decisions.

If you just want to play with small worlds or narrative simulations, you can reduce it to a single model and skip routing. For anything that’s meant to shape real roadmap decisions, I’d keep the hybrid GPT‑4o‑mini + Gemini approach.

Frequently Asked Questions