DEV Community: Mohammad

MiroFish: The Open Source Swarm Intelligence Engine That Simulates the Future

Mohammad — Fri, 20 Mar 2026 18:29:13 +0000

Imagine being able to run the future before it happens. Not as a statistical forecast or a gut feeling, but as a living simulation where thousands of autonomous AI agents carry individual personalities, memories, and social relationships, and play out scenarios in a compressed digital sandbox. You upload the seed material, whether that is a news article, a policy draft, or the opening chapters of a novel, and MiroFish returns a detailed prediction report along with an interactive world you can continue to question.

That is what MiroFish is. Built by a small team backed by Shanda Group, one of China's oldest internet companies, MiroFish is an open source, self-hosted Swarm Intelligence Engine that combines multi agent AI simulation, knowledge graph construction using GraphRAG, and long-term agent memory. As of March 2026, the GitHub repository has over 32,300 stars and 4,100 forks, putting it among the most watched AI projects of the year.

1. What Is MiroFish?

MiroFish describes itself as a Simple and Universal Swarm Intelligence Engine, Predicting Anything. That tagline sounds bold, but the technical architecture behind it is genuinely distinct from most prediction tools on the market.

Rather than asking a single large language model to predict an outcome, which tends to bake in one model's biases and produce a single opinion, MiroFish populates a digital world with thousands of AI agents. Each agent carries an independently generated personality, backstory, and memory. Those agents then interact, react to injected events, form opinions, and change socially over time. The result is emergent group behaviour that no single agent knows in isolation.

The simulation engine is powered by OASIS, an open source multi agent social simulation framework from CAMEL AI. MiroFish adds a full product layer on top: a Vue based frontend, a Python and FastAPI backend, GraphRAG based knowledge graph construction, Zep Cloud for long term memory, and a Report Agent that brings together findings into a structured document.

The team's stated goal: let the future rehearse in a digital sandbox so every decision wins after a hundred simulated rounds.

2. How the Five Stage Pipeline Works

Stage 1: Graph Construction

You upload your seed material. This can be a data analysis report, a set of news articles, a financial briefing, or a piece of fiction. MiroFish extracts entities and relationships, builds a knowledge graph using GraphRAG, and loads both individual and group memories into the agent population before any simulation begins.

Stage 2: World Building

An Environment Configuration Agent reads the knowledge graph and generates the simulation parameters. This includes which agent personas exist, what the social environment looks like, and what the starting conditions are. Agent personalities are generated to reflect the demographics, power structures, and cultural context embedded in the seed material.

Stage 3: Running the Simulation

The simulation runs on a dual platform architecture for parallel processing. Agents interact autonomously, posting, reacting, debating, and forming coalitions, while the system updates each agent's memory as rounds progress. You can inject new variables mid simulation from a God View interface. Drop in a breaking news event and watch how the social environment responds.

Stage 4: Report Generation

A dedicated Report Agent has access to a full toolset and goes through the post simulation environment to produce a structured prediction report. The report pulls together emergent patterns, majority and minority opinion paths, likely event sequences, and confidence levels.

Stage 5: Deep Interaction

After the simulation ends, the world stays live. You can have a direct conversation with any individual agent. Ask a simulated political journalist their view, probe a simulated consumer about a purchase decision, or question a simulated executive about their thinking. You can also continue the conversation with the Report Agent for further analysis.

3. What Can Actually Be Built With MiroFish?

The possible applications reach well beyond a single industry. Below is a breakdown of realistic use cases at different levels of ambition.

3.1 Public Opinion and Crisis Simulation

Public relations scenario planning: Simulate how a public statement, product recall, or executive announcement will land across different audience segments before it goes out.
Political campaign testing: Model how a policy announcement ripples through different voter groups and surface unintended messaging risks before launch.
Policy review: Government bodies could simulate public reaction to draft legislation before presenting it formally.

The team has already shown this working in practice. Their live demo simulates public opinion dynamics around a real university campus controversy in China, producing a full sentiment report from a social analytics document.

3.2 Financial and Market Scenario Modelling

Simulate how a community of simulated investors responds to earnings surprises, central bank announcements, or sector news.
Model narrative spread: how a specific framing of a financial event travels through different agent types such as retail traders, institutional agents, and media agents.
Test investor communication strategies for listed companies ahead of major announcements.

3.3 Narrative and Creative Prediction

In one of MiroFish's most striking demonstrations, the team fed in the first 80 chapters of Dream of the Red Chamber, one of China's great classical novels whose ending was lost to history, and had MiroFish simulate the probable fate of the characters. The output was an emergent narrative extrapolation, not written by an author but evolved through thousands of agent interactions shaped by the characters' established personalities and relationships.

Similar use cases exist for screenwriters exploring plot outcomes, game narrative designers, and interactive fiction studios.

3.4 Enterprise Decision Support

Organisational change: Simulate how a restructure, acquisition announcement, or new leadership appointment will be received internally.
Product launch planning: Model consumer community reaction to a new product before committing to a marketing budget.
Competitive scenario planning: Simulate how a set of representative competitor agents might respond to a strategic move before you make it.

4. Setup Guide

MiroFish offers two deployment paths. Source code deployment is the recommended approach for development and enterprise use. Docker is available for simpler self hosted setups.

4.1 Requirements

Tool	Version	Purpose	Check Command
Node.js	18 or above	Frontend runtime including npm	`node -v`
Python	3.11 to 3.12	Backend runtime for FastAPI	`python --version`
uv	Latest	Python package manager	`uv --version`
Docker (optional)	Latest	Containerised deployment	`docker -v`

4.2 Environment Variables

Copy the example config file and fill in your API keys:

cp .env.example .env

Two API keys are required to run MiroFish:

Variable	Purpose	Provider
`LLM_API_KEY`	Powers all agent reasoning and text generation	Any OpenAI compatible provider
`LLM_BASE_URL`	API endpoint, for example Alibaba Bailian or OpenAI	Configurable per provider
`LLM_MODEL_NAME`	Model name to use, for example qwen-plus or gpt-4o	Configurable per provider
`ZEP_API_KEY`	Long term memory storage for agents across simulation rounds	Zep Cloud, free tier available

Recommended starting point: Alibaba's qwen-plus model via the Bailian platform. The team advises running fewer than 40 simulation rounds initially to keep API costs manageable while you learn how the system behaves.

4.3 Installing Dependencies

One npm command installs everything: Node packages for the frontend and Python packages for the backend, placed in an automatically created virtual environment.

npm run setup:all

4.4 Starting the Services

npm run dev

This starts both the frontend and backend at the same time. The services run at:

Frontend: http://localhost:3000
Backend API: http://localhost:5001

For production use, start with Docker instead:

docker compose up -d

5. API Cost Analysis: The Real Numbers

The most important practical constraint when running MiroFish is LLM API cost. Because the engine runs thousands of agents through multiple simulation rounds, each agent calling the language model to think, react, and update its memory, token consumption is significantly higher than a standard single agent chatbot.

5.1 What Drives the Cost

Number of agents: Each agent makes LLM calls every round. A run with 1,000 agents across 50 rounds means roughly 50,000 LLM calls before accounting for the report generation phase.
Agent memory size: Each agent carries a growing context including its personality, accumulated memories, and current world state. Longer simulations produce larger contexts and higher costs per call.
Report Agent: The final analysis phase runs a thorough multi tool pass over the entire simulated world, which adds a significant block of token usage at the end of every run.
Seed material complexity: Richer input graphs produce larger system prompts per agent, increasing per call token counts.

5.2 Estimated Cost Per Simulation Run

Scenario	Agents	Rounds	Model Used	Estimated Cost (USD)
Quick prototype	50	20	qwen-plus or GPT 3.5 class	$0.50 to $2
Standard analysis run	500	40	qwen-plus	$8 to $25
Full simulation	1,000	100	qwen-plus	$40 to $120
Large enterprise run	2,000+	200+	GPT 4o or Claude Sonnet	$200 to $800+
Budget option	1,000	100	DeepSeek or Gemini Flash	$5 to $20

These figures are estimates based on current LLM pricing and typical token patterns for multi agent simulations. Actual costs vary based on seed material length, how memory accumulates, and the specific model chosen.

Cost tip: For lower costs, providers like DeepSeek V3 or Google Gemini Flash offer OpenAI compatible APIs at a fraction of the price. MiroFish works with any OpenAI SDK compatible endpoint, so switching is straightforward.

5.3 Memory Costs via Zep Cloud

Long term agent memory is handled by Zep Cloud. The free tier covers early experimentation and lighter usage. For production deployments with persistent memory across thousands of agents in multiple sessions, paid Zep plans start at roughly $50 to $200 per month depending on memory volume.

6. Does It Actually Deliver at This Stage?

This is the fair question to ask. MiroFish is at version 0.1.2, released in March 2026, which is early by any measure. The honest answer has two sides.

6.1 What Works Well Right Now

Structured qualitative prediction: For social, narrative, and sentiment scenarios such as public opinion analysis, public relations modelling, and story extrapolation, MiroFish produces genuinely interesting emergent outputs that are difficult to replicate with a single language model call.
Fast world generation: The automated persona creation and knowledge graph construction from raw input text works reliably and is technically impressive for a project at this stage.
Post simulation querying: Talking directly with individual simulated agents after a run provides a useful qualitative research tool that no conventional forecasting method offers.
Approachable setup: With Docker support and a single start command, getting MiroFish running locally is simpler than comparable academic simulation tools.

6.2 Current Limitations

Prediction accuracy is not yet validated: The simulation outputs are compelling but have not been formally back tested against real world outcomes. There is no published accuracy benchmark at this stage.
Quantitative precision has limits: MiroFish works well for qualitative, narrative driven prediction. For hard numerical forecasting such as exact price targets or vote share percentages, purpose built quantitative models are still more appropriate.
Costs grow quickly at scale: Large scale simulations become expensive fast. The economics make sense for targeted strategic use, not continuous real time monitoring.
English documentation is thin: As a version 0.1 project, most of the detailed guidance and community discussion is in Chinese. English speakers will need to work through the code directly in some areas.
Results vary between runs: Two simulations with identical inputs will not produce identical outputs. This is philosophically coherent but creates challenges for use cases that require reproducibility.

Over 32,000 GitHub stars signal that developers find this genuinely worthwhile. That said, enthusiasm and production readiness are not the same thing. MiroFish today is best described as a compelling research and strategy tool, not yet a fully production ready enterprise platform.

7. The Business Case: Offering MiroFish as a Service

For technically capable individuals and small agencies, MiroFish represents a real commercial opportunity. The open source AGPL 3.0 licence permits hosting and selling managed services built on top of it, though it is worth understanding the copyleft obligations that apply if you modify the core code and distribute those changes.

7.1 The Service Gap

Most enterprises, including public relations agencies, financial services firms, management consultancies, and political campaign teams, do not have the technical capability to set up and operate a multi agent simulation engine. They want the output, not the infrastructure. This creates a clear opportunity for someone to provide a managed service layer around MiroFish.

7.2 Viable Service Models

Model	Target Client	Pricing Approach	Complexity
Managed simulation as a service	PR agencies, strategy consultancies	Per simulation or monthly subscription	Medium
White label instance for enterprise	Listed companies, government bodies	Annual licence plus setup fee	High
Research service bureau	Academic institutions, think tanks	Project based retainer	Low to medium
Creative simulation studio	Game studios, publishers, screenwriters	Per project	Low
Political intelligence service	Campaign teams, policy advisers	Confidential retainer	Medium to high

7.3 What It Costs to Operate

Component	Option	Monthly Cost (USD)
Server for the backend	4 core, 8 GB RAM VPS such as DigitalOcean or Hetzner	$20 to $60
LLM API budget for client runs	Typically passed through to the client at cost or with a margin	$50 to $500+
Zep Cloud memory	Pro tier for multi client use	$50 to $200
Domain and SSL	Standard web hosting	Around $10
Monitoring	Grafana Cloud free tier or similar	$0 to $30
Total operating overhead	Before LLM API pass through	$80 to $300 per month

With LLM costs passed through to clients, an individual operator could reasonably charge $500 to $3,000 per simulation engagement at current market rates. The hard infrastructure overhead is $80 to $300 per month. The value being charged for is operational knowledge, prompt configuration, report interpretation, and client management, not the server.

7.4 Who This Makes Sense For

AI consultants and digital agencies already working with marketing or strategy clients, where MiroFish adds a distinct capability to an existing service offering.
Strategy consultants who want to bring quantitative social simulation into their work alongside traditional scenario planning methods.
AI developers in markets where local enterprises lack in house AI teams and are looking for vendors who can deliver this kind of analysis.
Freelancers in public relations, crisis communications, or political consulting who want a technical edge that most competitors simply do not have.

7.5 Honest Challenges

Selling simulations means educating buyers: Most enterprise decision makers have never purchased an AI simulation service. Expect a long sales process and significant time spent explaining the approach before any contract is signed.
AGPL licence obligations: Modifications to the core MiroFish code that you distribute must be made open source. Running it as a hosted service does not trigger this requirement, but selling a modified fork does.
Accuracy questions will come up: Clients will ask how accurate the output is. Be prepared with an honest framing about probabilistic and qualitative results rather than hard predictions. This is a tool for widening the range of scenarios considered, not for producing a single correct answer.

Conclusion

MiroFish is one of the most genuinely interesting open source AI projects to appear in 2026. It takes a distinct approach to prediction by using emergent multi agent social simulation rather than asking a single model for an answer, and it packages that approach in a deployable, self hosted stack with a polished frontend.

At this stage it is best suited to qualitative strategic prediction: public relations and crisis scenario planning, narrative extrapolation, social sentiment forecasting, and policy review. The economics work for targeted use cases but not yet for large scale continuous monitoring. English documentation is still maturing and the community outside of China is still forming.

For technical entrepreneurs and AI service providers, the business case is real. Infrastructure costs are modest, the capability is genuinely different from anything most enterprise clients have access to, and buyers in strategy, communications, and finance have both the budget and the kind of problems that MiroFish is built to address. The gap between the open source tool and enterprise ready deployment is exactly where a service provider can create lasting value.

This repository is worth watching. Thirty two thousand stars are not there by accident.

GitHub: github.com/666ghj/MiroFish Website: mirofish.ai Built on OASIS by CAMEL AI

3 Questions Your MVP Needs to Answer

Mohammad — Wed, 04 Jun 2025 13:34:13 +0000

Your MVP isn't a feature-light version of your dream product.
It's an experiment designed to answer 3 critical questions:

Will people use it? Not "do they say they'll use it" in surveys. Do they actually open it, click around, and come back tomorrow?

Will they pay for it? Usage without payment is just expensive entertainment. Even if you're planning to monetize later, test willingness to pay early.

Can you deliver the core value? Strip away everything except the one thing that matters most. If you can't nail that single value proposition, adding features won't save you.

Most founders rush to build before answering these questions. Then they wonder why their "perfect" product sits unused.

Your MVP should be uncomfortable to ship. If it feels too polished, you're probably solving the wrong problem.

What question did your last product experiment answer?

Looking build your MVP? Contact us

Why Serverless Architecture Is the Future of Scalable Apps

Mohammad — Mon, 26 May 2025 14:03:14 +0000

Scalability used to mean provisioning, managing, and scaling servers manually — or at least relying on DevOps-heavy processes. But that’s changing fast.

In 2025 and beyond, serverless isn’t just a buzzword — it’s the new foundation for fast-moving, cost-efficient, scalable applications.

In this guide, I break down:

✅ What serverless really means in 2025
⚙️ How it changes the developer and startup workflow
💸 The real-world pros (and a few cons)
📈 When not to use serverless
🔍 And why we’re betting big on it for future products

Whether you’re building your next SaaS, API-driven app, or backend-heavy platform — this is worth a read.

👉 Check out the full article here

💬 Curious to hear — are you using serverless in production yet? What stack or provider do you prefer?

How Long Does It Really Take to Build a Web App in 2025?

Mohammad — Mon, 26 May 2025 14:01:12 +0000

Timelines are the most common (and often misunderstood) question in web app development. Whether you're working with a team or a solo dev, setting realistic expectations can make or break your project.

I just put together a detailed guide breaking down the 2025 web app development timeline, covering:

🛠️ Discovery → Design → Dev → Launch
🧩 What affects timelines (spoiler: it's not just code)
📉 Common time-wasting traps to avoid
📅 Realistic time estimates at each stage

Whether you're a founder, PM, or dev building for clients — this guide helps you plan smarter and build better.

👉 Read the full guide

What’s your take — do clients underestimate or overestimate build time?

Got an app idea? Build your MVP in 30 days without burning your budget.

Mohammad — Mon, 26 May 2025 13:59:46 +0000

We just dropped a no-fluff guide on how to go from idea to launch in 30 days—focusing only on what matters.

Step-by-step roadmap
Realistic budgeting tips
Tools & frameworks we actually use
How to avoid scope creep & shiny object syndrome

Perfect for startup founders, product managers, or non-tech entrepreneurs ready to test their idea fast.

📖 Read the full guide: Here

How to NOT kill your startup in the first 6 months

Mohammad — Fri, 23 May 2025 13:44:41 +0000

(aka how to avoid being the startup version of Titanic, big dreams, fancy tech, and one tiny iceberg )

Let me guess:

You're building your MVP.
You’ve got 5 users (3 are your friends).

And you're already planning a microservice architecture like you're Google.

Pause. Breathe. Read this.

We've seen it all. Founders building empires before selling a single lemonade.

Spoiler alert: You don’t need microservices to validate your idea.

You need:

Fast iterations
A simple, stable codebase
The ability to pivot without crying in your backend

So before you spin up 9 services, 3 message queues, and a CI/CD pipeline that looks like NASA built it

Read this: Monoliths-vs-Mircoservice

Go monolith.
Go simple.
Get real feedback.

Then scale like a beast. 🧠🚀

How We Built an MVP Marketplace Platform with a Scalable Hybrid Architecture

Mohammad — Thu, 22 May 2025 21:40:32 +0000

Building Smarter, Not Harder

In today's fast-moving digital economy, launching a marketplace quickly while ensuring long-term scalability is a major challenge for startups and entrepreneurs. At Beitroot, we specialize in MVP development, web app development, and marketplace platforms that empower founders to validate ideas rapidly without compromising future growth. In this blog post, we'll walk you through how we built an MVP for the N8tive marketplace using a hybrid architecture that blends Shopify's powerful e-commerce engine with a custom-built backend.

The Vision Behind the Shopify Powered Marketplace Platform

Platform was envisioned as a modern, vendor-first marketplace that connects sellers and buyers in a seamless environment. The founders wanted the MVP to be launched quickly, support real-time operations, and offer full control over vendor workflows without being locked into a rigid platform structure.

The answer? A hybrid architecture combining Shopify for storefront and e-commerce capabilities with a modular, API-driven backend for vendor management, administration, and platform operations.

Why a Hybrid Shopify + Custom Backend Was the Right Fit

When you're building an MVP for a marketplace, speed, cost, and flexibility are critical. Our approach delivered on all three fronts:

1. Faster MVP Launch

Shopify provided an out-of-the-box e-commerce engine, complete with product management, cart, checkout, and payment gateways. This allowed us to avoid reinventing the wheel and focus on custom features that mattered most to the N8tive brand.

2. Lower Infrastructure Cost

Launching on Shopify meant skipping the high cost and complexity of building a complete e-commerce stack. We invested that saved time and money into custom modules for vendor management, dashboards, and integrations.

3. Seamless Scalability

Our modular backend was designed with microservices in mind. It can evolve alongside the business by adding features like mobile apps, advanced reporting, or even third-party APIs — all without touching the core Shopify setup.

4. Vendor Security & Flexibility

Vendors never interact with Shopify directly. All operations — from onboarding and product uploads to order fulfillment are managed through a secure custom dashboard. This adds a layer of control for the business and improves data integrity.

5. Clear Separation of Concerns

Shopify focuses on the customer experience, sales processing, and payments. Our system manages sellers, internal workflows, and data operations. This ensures clean boundaries and better maintainability.

The Architecture Overview

The MVP was built with three interconnected components:

Shopify Storefront
Custom Vendor Panel
Admin/Operations Panel

These systems talk to each other via RESTful APIs, webhooks, and the Shopify Admin API.

Shopify Storefront

Handles customer-facing UI, catalog, cart, and checkout
Manages all customer orders and payment flows

Custom Vendor Panel

Secure login for each vendor
Allows vendors to manage their own product catalog, inventory, pricing, and fulfillments
Sits on top of Shopify via a middleware layer that handles API calls and validations

Admin/Operations Panel

For the APP internal team to manage users, oversee transactions, monitor performance, and handle customer support
Centralized dashboard that brings together analytics, logs, vendor performance, and more

How the Integration Works: Real-Time Synchronization

The power of this architecture lies in its real-time integration:

Shopify Webhooks notify our backend about changes like new orders, inventory updates, or refunds
Our backend reacts and updates vendor dashboards accordingly
Any vendor changes (e.g. new products or pricing) go through our custom API layer and are pushed to Shopify via the Admin API

This ensures all three systems remain in sync, enabling smooth operation and up-to-the-minute visibility for vendors and admins alike.

Our Tech Stack

Frontend: Next JS
Backend: Node.js + Express
Database: PostgreSQL
Authentication: JWT + OAuth (for vendor and admin roles)
Shopify Integration: Shopify Admin API, Shopify Webhooks
Hosting: AWS

Challenges We Solved

1. Vendor-Specific Pricing and Inventory

Shopify doesn't natively support multi-vendor logic. We introduced a custom layer to segregate product ownership, pricing, and inventory per vendor.

2. Real-Time Order Routing

When an order comes in, our system parses the line items and routes them to the appropriate vendor dashboard, ensuring each vendor sees only their relevant data.

3. Unified Experience

Despite different UIs for vendors and customers, the entire platform operates as a cohesive system. Vendors don't even need to know Shopify is under the hood.

Results: A Successful MVP Launch

Time to Market: 6 weeks from idea to MVP
Cost Savings: ~40% lower infrastructure and dev cost
Vendor Adoption: Onboarded 10+ vendors in the first 2 weeks
Performance: Real-time order processing with <1 sec sync lag

The MVP allowed the founders of the APP to test their idea in a live environment with minimal risk. More importantly, the hybrid system means they can grow and evolve without needing to rebuild from scratch.

Why This Approach Is a Game-Changer for Marketplaces

Most marketplaces struggle between two extremes:

Going fully custom, which takes too long and costs too much
Going with off-the-shelf platforms that offer limited flexibility

Our hybrid approach gives startups the best of both worlds:

Rapid Launch
Robust E-commerce Features
Custom Vendor Operations
Long-Term Scalability

Looking Ahead: What's Next

With a solid MVP in place, the APP is now poised to:

Launch native mobile apps
Introduce tiered vendor subscriptions
Add AI-based product recommendations
Expand into new regions with localized versions

All this will be built on the same foundation — a future-ready architecture designed for performance, adaptability, and growth.

Partner with Experts Who Understand MVP Development

At Beitroot, we don't just build apps. We build platforms that empower businesses to launch faster and scale smarter. Whether you're building a web app, a custom SaaS product, or a multi-vendor marketplace — we're the technical team that makes it happen.

Need a tailored MVP or web app built fast? Visit beitroot(https://www.beitroot.co) or schedule a free consultation.