MiroFish: an undergrad builds 700,000 AI agents in 10 days — this open source project predicts the future and explodes on GitHub

MiroFish : an undergrad builds 700,000 AI agents in 10 days — this open source project predicts the future and explodes on GitHub

🔎 10 days, 700,000 agents, 42K stars

In March 2026, an undergrad student published a multi-agent prediction engine built in ten days on GitHub. The result: 700,000 AI agents with distinct personalities, memories, and social connections, unleashed in a digital world that simulates Twitter and Reddit.

MiroFish reached #1 GitHub Global Trending in a matter of hours, raking in 42,000+ stars and 4 million dollars in funding within 24 hours backed by Shanda Group (Chen Tianqiao). The project claims "scarily accurate" predictions regarding financial markets, elections, and public opinion.

Except we've already seen this kind of promise before. The question isn't whether the technology is impressive — it is. It's whether the predictions hold up, or if it's a new algorithmic mirage dressed up as a revolution.

The essentials

• MiroFish is an open source multi-agent simulation engine that builds a high-fidelity digital world from real-world data (news, financial signals, political discussions).
• Each agent possesses a generated personality, persistent memory, and its own behavioral logic. The system simulates platforms like Twitter and Reddit to observe the emergence of social dynamics.
• The project reached 42K+ GitHub stars, #1 Global Trending, and raised 4M$ in 24h — but critical voices question the actual validity of the predictions produced.
• A community fork, MiroFish-Offline, allows for complete self-hosting with Neo4j and Ollama, without cloud dependencies.

Recommended tools

How MiroFish works — the architecture broken down

MiroFish does not make predictions in the classical sense. It builds a digital world, injects agents into it, and observes what emerges. Prediction is a byproduct of the simulation, not a direct calculation.

The architecture breaks down into three distinct phases, documented on the GitHub repo and analyzed by Beitroot.

Phase 1 — Graph Building (extraction and injection)

The system extracts "seeds" from the real world: news articles, political posts, financial signals. These seeds are transformed into nodes of a knowledge graph via GraphRAG.

Each seed receives an injection of contextual memory. This is not simple indexing — the system creates semantic relationships between events, entities, and sentiments.

Phase 2 — Environment Setup (persona generation)

This is where MiroFish diverges from classical approaches. Each agent receives a procedurally generated persona: age, profession, cognitive biases, political affinities, education level, initial social network.

The personas are not random. They are calibrated to reproduce the real demographic distributions of the population being studied. An agent is not an LLM with a system prompt — it is an entity with persistent internal coherence.

Phase 3 — Simulation (emergence and consensus)

The agents interact on simulated platforms (Twitter-like, Reddit-like) with temporal memories. They read posts, react, modify their opinions, and form clusters.

The swarm-generated consensus emerges from these interactions. It is this consensus that constitutes the "prediction" — not a direct output from a model.

This emergence-based approach is fundamentally different from a better autonomous AI agent that would reason alone on a problem. Here, it is the digital crowd that produces the signal.

700,000 agents in 10 days: vibe coding as a method

The story of its creation is almost as interesting as the product itself. According to ABHS, an undergrad student built MiroFish in 10 days via what is now called "vibe coding" — coding by massively delegating to AI.

The previous project by the same creator, BettaFish, had already reached #1 on GitHub Trending with a multi-agent tooling focused on public opinion. MiroFish is an extension of this: where BettaFish instrumented, MiroFish simulates.

The 700,000 agent figure is not theoretical. It is the peak reached during demo runs, with each agent running with its own memory session and behavioral logic. In practice, production runs use between 10,000 and 100,000 agents depending on the complexity of the scenario.

What is striking is the development speed. Ten days for a production-grade multi-agent simulation system with a knowledge graph, persistent memory, and dual-platform simulation. Vibe coding changes the game regarding what a single individual can produce.

What are predictions really worth?

That's the crux of the matter. House of Ethics publishes a critical analysis that asks the right question: simulating social dynamics, is that predicting?

The simulation bias

A MiroFish agent is an LLM with a persona. An LLM reproduces the biases of its training data. Therefore, a swarm of 100,000 LLM agents systematically reproduces the biases of its training data — not those of the real population.

The simulation can be internally coherent without being externally calibrated. The agents can form stable opinion clusters, realistic information cascades, compelling polarization dynamics — and be systematically wrong about the actual outcome.

The comparison with Polymarket

Polymarket aggregates real bets with money on the line. Economic incentives create a bias-correction mechanism. MiroFish has no correction mechanism — the agents have nothing to lose.

When Moneycontrol describes the results as "scarily accurate," you have to look at which results, on what sample, and against what benchmark. The public demonstrations are visually impressive. Rigorous statistical validations are, for now, absent from the project's publications.

What the simulation does well

Despite these reservations, the approach has real value. It makes it possible to explore counterfactual scenarios: what happens if a piece of information leaks at a specific time? How does an opinion cluster react to a change in narrative?

It is a tool for awareness of dynamics, not an oracle. The distinction is crucial.

Real-world applications: public opinion, markets, crowd behavior

Public opinion and elections

This is the flagship use case highlighted by Emelia. MiroFish simulates a complete media ecosystem, injects an event (debate, scandal, announcement), and observes how the agents' opinions restructure.

The advantage over traditional polls: near-zero cost, instant results, ability to test multiple scenarios. The downside: no guarantee that the distribution of personas matches the real population.

Financial markets

Agents receive financial signals as seeds and interact with simulated "market sentiments." The swarm consensus can indicate a direction — but here again, real markets have mechanisms (liquidity, regulatory constraints, structural irrationality) that a social platform simulation does not capture.

Crowd behavior

This is potentially the most valid application. Understanding how a rumor spreads, how extremist clusters form, how a narrative shifts — these emergent dynamics are precisely what multi-agent simulation can usefully model.

This approach ties into the work on the best LLMs for AI agents, where the social reasoning capacity of the underlying model determines the quality of the simulation.

MiroFish-Offline : the 100% local fork with Ollama and Neo4j

For the open source community, the real entry point is MiroFish-Offline. This community fork replaces cloud dependencies with an entirely local stack:

• Ollama for local LLM inference. For those already familiar with open source AI agents with Ollama locally, the setup is familiar.
• Neo4j as a graph database for the knowledge graph and relationships between agents.
• Simplified architecture that retains the core of the simulation (persona generation, temporal memory, dual-platform) without external APIs.

The advantage is twofold: total data confidentiality (no seeds sent to a third party) and zero inference cost. The trade-off is obvious — local models are less performant than GPT-5.5 or Claude Opus 4.7 for generating nuanced personas.

For a run of 10,000 agents with a model like Kimi K2.6 Moonshot AI in self-host, you need a serious machine: minimum 64 GB of RAM, ideally a multi-GPU setup. This is not a Raspberry Pi toy.

MiroFish in the AI agent ecosystem — where it stands

MiroFish is not an agent. It's an agent engine — an orchestration layer that creates, configures, and makes thousands of autonomous entities interact.

Difference from classic autonomous agents

An autonomous agent like those found in the meilleurs agents IA autonomes has a goal, a plan, tools. It acts in the real world (web search, code execution, API calls).

A MiroFish agent acts in a simulated world. It has no external tools. Its only output is its social behavior within the synthetic environment. The value is not in the individual agent's action, but in the pattern that emerges from the crowd.

The connection to search agents

The approach is reminiscent of what OpenSeeker-v2 does in the search domain: using multiple agents with different strategies to produce a result that exceeds the sum of its parts. But where OpenSeeker-v2 searches the real web, MiroFish simulates a synthetic web.

The contribution of the OASIS approach (CAMEL-AI)

MiroFish is based on OASIS, a CAMEL-AI framework designed for multi-agent social simulations. OASIS provides the base infrastructure (environment, interaction loop, memory mechanisms) that MiroFish extends with graph building, seed extraction, and the generation of prediction reports.

Detailed technical architecture — what happens under the hood

Based on the analysis of Medium and the repo's documentation, here are the key components.

Knowledge Graph and GraphRAG

The knowledge graph is not static. It evolves throughout the simulation: each interaction between agents creates new nodes and edges. The GraphRAG serves as both storage and a reasoning mechanism — agents can "trace back" through their own social history.

Temporal Memory

Each agent has a temporal memory that naturally degrades. Recent events weigh more than older ones, just like in humans. This mechanism prevents agents from becoming perfect databases and introduces recency bias — a human bias that the simulation specifically seeks to reproduce.

Dual-Platform Simulation

Agents interact simultaneously on two simulated platforms with different cultures (one Twitter-like, short and reactive; the other Reddit-like, longer and deliberative). The same agent can behave differently on each platform — exactly like in reality.

Prediction report

At the end of the simulation, the system aggregates the agents' mental states, opinion clusters, polarization dynamics, and produces a structured report. This report is what is presented as "the prediction".

Data Feeding: The Critical Role of Crawling

A multi-agent simulation is only as good as the data that feeds it. Seeds extracted from the real world determine the quality of the synthetic environment.

This is where tools like Crawl4AI become relevant. A robust web collection pipeline is a prerequisite for MiroFish: it requires fresh news, active discussions, and real-time financial signals.

The MiroFish repo includes basic connectors, but in production, most serious users build their own feeding pipeline. Crawling quality is the number one limiting factor for simulation accuracy.

Underlying Models: Which LLM for Which Agents

The choice of the model behind each agent directly impacts the quality of the simulation. A model with a high agentic score will produce more nuanced and coherent behaviors.

In practice, MiroFish-Offline users with Ollama turn to Kimi K2.6 or GLM-5 (Reasoning) from Z.AI, the best agentic models available in self-host. For cloud runs with 100K+ agents, GPT-5.3 Codex offers a good balance between cost and behavioral consistency.

Hosting and infrastructure

MiroFish is not a SaaS tool. It's a self-deployed framework. The required infrastructure depends directly on the number of agents and the chosen model.

Cloud

For a run of 50,000 agents with GPT-5.4 Pro, the API cost can add up quickly. You need a job orchestrator (typically a Kubernetes cluster), a storage bucket for intermediate states, and serious monitoring — 50,000 simultaneous LLM sessions aren't managed on a laptop.

Hosting like Hostinger is enough for small runs (1,000-5,000 agents) and deploying the visualization interface. For serious production, you'll need to look at specialized GPU providers.

Local

MiroFish-Offline with Ollama + Neo4j runs on a beefy machine. 64 GB of RAM minimum, GPU with 24+ GB of VRAM for the model, fast SSD for the graph. It's a serious developer setup, not a weekend project.

❌ Common mistakes

Mistake 1: Confusing simulation and prediction

This is the fundamental mistake. MiroFish simulates social dynamics. Prediction is a byproduct of the simulation, not its primary goal. Treating the output report as an oracle is a categorization error.

The solution: use MiroFish as a scenario exploration tool, not as a crystal ball. The outputs are trend indicators, not calibrated probabilities.

Mistake 2: Neglecting seed quality

A simulation with biased or outdated seeds produces a digital world disconnected from reality. The garbage in, garbage out principle applies with tenfold force in multi-agent simulation — because bias is amplified by interactions.

The solution: invest in a robust and up-to-date crawling pipeline. Crawl4AI or an equivalent is a prerequisite, not an optional extra.

Mistake 3: Using a model that is too weak in self-host

Running MiroFish-Offline with a small 7B model will produce agents with repetitive and unrealistic behaviors. The quality of the simulation depends directly on the social reasoning capacity of the model.

The solution: aim for an agentic score of 80+ minimum. Kimi K2.6 in self-host is the reasonable baseline.

Mistake 4: Interpreting internal consistency as external validity

If agents form stable clusters and coherent opinions, the simulation seems valid. But internal consistency is a necessary condition, not a sufficient one. A group of LLMs can be coherent and systematically wrong.

The solution: always validate MiroFish predictions against real ex-post data. Never deploy without backtesting.

❓ Frequently Asked Questions

Does MiroFish replace opinion polls?

No. Polls directly measure actual opinion. MiroFish simulates synthetic opinion. Both approaches are complementary, but simulation does not replace empirical sampling. It enriches it by allowing the testing of counterfactual scenarios.

Can you really run 700,000 agents?

In theory, yes, with massive cloud infrastructure and a substantial API budget. In practice, publicly documented runs operate between 10,000 and 100,000 agents. The 700K figure is the technical maximum reached during a demonstration, not standard usage.

Is MiroFish-Offline really usable without the cloud?

Yes, with the right hardware resources. The fork replaces all cloud dependencies with Ollama and Neo4j. The trade-off is in the quality of the personas (less performant local models) and the simulation time (slower local inference).

What is the difference between MiroFish and BettaFish?

BettaFish, the previous project by the same creator, was a multi-agent public opinion analysis toolset. MiroFish goes further by building a complete digital world with social platform simulation and the generation of predictive reports. It is the evolution from an analysis tool to a simulation engine.

Have MiroFish's predictions been scientifically validated?

Not to our knowledge. Public demonstrations are qualitative ("scarily accurate" according to Moneycontrol). As of June 2026, there is no peer-reviewed paper validating the predictive accuracy of the system on a representative sample using a reproducible methodology.

✅ Conclusion

MiroFish is an impressive engineering project — 10 days, 42K stars, a multi-agent simulation architecture that pushes the boundaries of vibe coding. But between the technological demonstration and reliable prediction, there is a gap that neither the GitHub buzz nor the $4M in funding can bridge. Use it to explore social emergence dynamics, not to bet your portfolio on the outcome. And if you want to experiment without cloud dependencies, the MiroFish-Offline with Ollama fork is the best starting point.