How SimSwarm Differs from MiroFish and MiroShark
SimSwarm's intellectual lineage traces through two earlier projects — MiroFish and MiroShark — but today's engine does not bundle or depend on either of them. SimSwarm is a native, MIT-licensed rewrite that reimplements the ideas it found valuable in its own architecture, carrying over none of the upstream framework or structure — though a few specific algorithms (belief-update heuristics, AMM market math) were ported, as the engine source notes. This page explains where it came from and what actually changed.
The lineage
MiroFish is the original swarm-simulation engine (AGPL-3.0). It models agents posting and
reacting across two social platforms (Twitter + Reddit), stores its interaction graph in a
hosted graph service, and is built on the CAMEL-AI / OASIS agent framework with a Flask
server that spawns a subprocess per simulation backed by per-run SQLite. Agents are
effectively stateless between rounds. SimSwarm's earliest versions wrapped MiroFish directly
as an AGPL submodule under vendor/.
MiroShark (github.com/aaronjmars/MiroShark) is an AGPL-3.0 fork of MiroFish that added the features SimSwarm cared about most: a belief-state system (per-agent stance, confidence, and trust), sliding-window round memory with LLM summarization to survive long runs, a prediction-market platform with a bridge coupling market prices and social sentiment, a self-hosted graph database, and task-level model routing (a strong model for reasoning, a cheap one for bulk work). SimSwarm migrated onto MiroShark's concepts during its second phase.
SimSwarm is the current native engine — a from-scratch rewrite (roughly 90% new code) that
keeps the ideas validated by MiroShark (AMM market math, belief-update heuristics, effective
prompts) while discarding the inherited framework and structure. A few proven algorithms were
ported directly — the engine source marks where (for example, belief.py and the market
modules carry "Ported from MiroShark" headers) — but SimSwarm no longer bundles or depends on
the AGPL upstream and is published under the MIT license.
At a glance
| Dimension | MiroFish | MiroShark | SimSwarm |
|---|---|---|---|
| License | AGPL-3.0 | AGPL-3.0 | MIT |
| Relationship | Upstream origin | Fork of MiroFish | Native rewrite — no shared framework/structure (some algorithms ported) |
| Runtime | Flask server + subprocess-per-sim + per-run SQLite | Same (forked) | Async Python library — await engine.run(config) inside the GPU pod |
| LLM loop | CAMEL-AI / OASIS framework | CAMEL-AI / OASIS framework | Direct vLLM /v1/chat/completions calls — no framework layer |
| Agent state | Stateless between rounds | BeliefState (stance/confidence/trust) | BeliefState, reimplemented natively (see Beliefs & Stance) |
| Long-run memory | Full context each round | Sliding-window LLM summarization | Bounded round memory in the core loop |
| Environments | Twitter + Reddit (hard-coded) | + prediction market + bridge | Pluggable environments — social, market, economic, custom (see Environments) |
| Cross-environment | Independent platforms | MarketMediaBridge | First-class cross-environment bridge |
| Scenario sweeps | — | — | Built-in ScenarioSweep over parameter combinations |
| Model routing | Single model | Task-level dual-tier | Tier/role routing (fast loop vs. smart offline) |
The columns describe each project's design, not a benchmark. SimSwarm does not bundle or depend on MiroFish or MiroShark at runtime.
What the rewrite changed
Three problems with the MiroShark-based engine (~37K lines across ~130 files) drove the rewrite:
- Opaque LLM loop. A heavy CAMEL-AI dependency meant debugging agent behavior required tracing framework internals. SimSwarm calls the model directly, so the entire request/response path is in code you can read.
- Inherited complexity. Two separate hard-coded social platforms, dozens of SQL schema files, prompts scattered across many modules, and an embedding model for feed ranking — much of it inherited from upstream and not load-bearing. SimSwarm collapses this into a small set of focused modules and pluggable environments.
- Architecture limits. Flask + subprocess + per-sim SQLite added IPC overhead, no shared state, and subprocess-spawning complexity. Because SimSwarm pods are ephemeral and run a single simulation, an in-process async library is simpler and fits the product direction (scenario sweeps, economic environments, structured policy inputs).
The result is documented in detail under Engine Internals.
Licensing: why MIT matters
MiroFish and MiroShark are both AGPL-3.0 — a strong copyleft license whose network-use clause requires anyone offering the software as a service to make their complete corresponding source available. SimSwarm reimplements these concepts in its own engine and no longer bundles the AGPL upstream, and is published under the MIT license: you can self-host, modify, and build on it — commercially or not — without copyleft obligations. See Open Source & Self-Hosting.
Acknowledgements
SimSwarm owes its conceptual direction to MiroFish and to MiroShark by aaronjmars. The belief dynamics, prediction-market mechanics, and long-run memory strategy were proven there first, and some algorithms were ported or adapted from MiroShark; SimSwarm's contribution is a native, MIT-licensed engine that makes those ideas easier to run, extend, and reason about.