PL
Agent-based simulation

See what your agents will do before they do it for real

hirelegion.com

Legion runs simulations in which every actor is a separate AI agent - with its own role, goals and language model. Agents talk, negotiate, pressure each other and make decisions. You see every message, every decision and the moment it was made.

The problem

A single prompt won't show you what happens between agents

You test a model in isolation, then deploy it into a system where agents influence each other. That is where behaviour no benchmark shows emerges: coercion, conformity, collusion, decision paralysis.

assumptions.diff
You check model behaviour one prompt at a time
You watch how it behaves in a group - under time pressure and real stakes
You assume agent coordination will “just work”
You see which coordination patterns agents create on their own
An outcome with no history - “the agent decided so”
A full record: who, to whom, what and why - to the second
One run, one anecdote
Repeated runs of the same scenario with results compared
How it works

From scenario to insight in three steps

No need to build your own agent observability stack - you describe the world, Legion runs it and records everything that happens in it.

1

Build the world

Describe the scenario, the actors and the rules. Each actor gets a role written in Markdown and its own model - GPT, Claude, Gemma, QWEN, DeepSeek or a local Ollama. World state (oxygen level, exchange rate, budget) can be computed in Python instead of being left to the model's imagination.

2

Run and observe

A game master drives the scenario while agents exchange messages, make decisions, spawn new agents or leave the game. You can step in as the human in the loop at any moment.

3

Analyse the record

A timeline for every agent, message flow, decisions and token usage. Replay the run step by step, compare a series of runs and export a report.

Example simulations

Runs performed in Legion

Each simulation is a real run with a full record of messages and decisions. Pick a scenario and see what the agents did.

More simulations coming soon
Simulation engine

Mechanics you can't build with a single prompt

What sets a simulation apart from a chat with a model: a changing population of agents, decisions recorded as events and world rules the model can't make up. Working with the app is covered below, under Features.

Different models in one world

Each actor can run on a different model from a different provider. You compare behaviour under identical conditions.

A population that changes

Agents can spawn new agents (create_agent) and irreversibly leave the game (self_destruct).

Decisions as events

Choice points (decide_option) are recorded as separate, measurable events instead of getting lost in conversation text.

Human in the loop

An agent can ask the researcher (ask_human), and the researcher can step into the run and change the conditions.

Hard world rules

Environment state is computed in Python - the scenario's physics don't depend on model hallucinations.

Data-grounded personas

Knowledge bases with semantic search - an actor knows your documents, research and data, not just what the model imagines.

Features

What you can do in Legion

From the first actor to a finished report - all in one browser app. This is what working with a simulation looks like for the person running it.

Set up the scenario

  • Each scenario is its own project: the agent team, input data, results and history in one place.
  • You create an actor from a name, a role description and a chosen model - or start from a ready-made agent template.
  • You add briefs, a description of the world and data that agents can access throughout the run.
  • You attach knowledge bases with semantic search, so personas know your documents and research.
  • One click switches the model for every agent, so you can run the same scenario on a different model.
  • In the test chat you try a model and its tools before handing them to an agent.

Run and steer

  • One-click start - every run begins from a clean state, with no traces of the previous one.
  • Schedules run the scenario for you: once, or repeatedly every few minutes, hours, days or weeks.
  • An instant message to the game master lets you step into the run at any moment.
  • An agent can ask you a question and wait for your answer.
  • You stop the network whenever you want - and it stops on its own when the scenario ends.

Watch it live

  • The agent grid shows who is working, who is waiting for a message and who is missing configuration.
  • Tokens and speed update live, separately for each agent.
  • The tool view shows what an agent is using right now.
  • Message timeline and flow graph: who wrote to whom, how often and the status of every message.
  • Service errors land on a separate list above the grid, so nothing gets lost in the logs.

Analyse and share results

  • Run summary: tokens per agent, tool usage, duration and message count.
  • Run history with date filters and a quick “Today” filter.
  • You replay a run step by step and compare a series of runs of the same scenario.
  • Agent output in folders: preview, download and export of Markdown and HTML files to PDF.
  • You export the simulation report, and agents can email results with PDF attachments.

Work as a team, securely

  • Three access roles: Administrator, Editor and Reader, who can only view results.
  • Any OpenAI-compatible provider, including free local models such as Ollama.
  • MCP integrations give agents external tools and data sources.
  • Runs in your own infrastructure or a cloud of your choice - data doesn't have to leave the company.
  • Light and dark themes and full support on phones.
Use cases

Two kinds of questions a simulation answers

How an AI system will behave before it reaches production - and how the world around you will react before you decide.

Stress-testing model ethics

Dilemmas, time pressure, conflicting goals - see how a model behaves when the stakes are real.

Red-teaming multi-agent systems

Find collusion, coercion and escalation before they show up in production.

Choosing a model for a role

The same scenario across different models shows which one fits the role and which one will fold under group pressure.

Research and teaching

Repeatable experiments with a full record - for universities, AI safety teams and agent-system architects.

To be clear

A simulation is not a forecast

Legion does not predict the future. It shows which behaviours are possible in the world you designed - and where your design has gaps. Insights are only as good as the scenario, which is why every run leaves a full, verifiable trail.

The same engine at work

Agents that make decisions in a simulation can also do real work

Reports, research, documents, emails, recurring tasks - Legion can also run as a production agent team in your organisation.

Let's talk
Paweł Cynkar
Who is behind Legion

Paweł Cynkar

Multi-agent AI systems architect · creator of Legion

I have spent more than 20 years in financial-sector IT - as an engineering team leader, a systems architect and the person responsible for technology strategy. Today I focus on multi-agent AI systems.

Legion is my own system, and I designed and analysed the “Saving Jan” simulation myself. GDPR, DORA and the EU AI Act are standard in my work - which matters when scenarios touch your data and processes.

Describe the scenario you want to simulate

Tell us what you want to test - model behaviour, the resilience of an agent system or a market's reaction. We'll propose how to design it - either as a deployment on your side or as a simulation we run for you.

Fields marked with an asterisk are required.

This site is owned and operated by nevergiveup.dev