Emergia

Our Logo

Inspiration

Emergia was inspired by the observation that many important systems—markets, communities, and institutions—are not centrally designed, yet still develop structure, stability, and sudden failure through trust formed in repeated local interactions. Drawing from physical systems where simple rules produce complex behaviour, Emergia abstracts away capital, domain-heavy assumptions, and global coordination to focus on trust as a fundamental mechanism—initially to model financial markets without inherent bias, and ultimately to study how trust forms, decays, and shapes participation over time. This approach evolved into a multi-purpose simulator for trust-based multi-agent systems, applicable not only to finance and social structures but also to systems where trust is implicit, such as interactions between pollinators and their environment, with the goal of observing emergent behaviour rather than predicting outcomes.

What it does

Emergia models agents as physical objects that have existing 'skills' and require other skills that it doesn't possess. This loosely represents a simple bartering system (e.g. a farmer might need a pair of horseshoes, and a blacksmith might require wheat, and hence they each can trade because they each require the skill the other possesses). These agents move around the screen in some random direction, and upon collision with another agent, a trade is attempted. If their requirements match, we then check their trust levels. The trust metric represents the agents trust in the system that they are operating in (e.g. could represent a citizen's trust in the government). So the trade only occurs if both agents meet or exceed their respective trust thresholds (set by the user). These mechanisms, alongside some other agent-to-agent collision rules, are very simple at first sight, but they result in complex emergent patterns that can mirror real life scenarios, given the correct initial conditions.

How we built it

We built our application using the react+next+d3 technology stack for our front-end to provide an intuitive, user-friendly interface alongside dynamic visualisations Our backend, written in Python, uses numpy for data processing along with scipy to optimise agent interactions. These two components communicate via WebSocket to facilitate high volumes of data with low latency.

Challenges we ran into

Wiring our frontend and backend together posed a challenge due to the added complexity of WebSocket connections. Additionally, tuning the ranges for user-input parameters to allow the user to best tune the simulator's emergent behaviour for their specific use-case was a very delicate process that required a lot of iteration. Also we had to strike a balance of choosing which phenomena from the world of physics to incorporate into our simulation to introduce a level of structured randomness, while also not overcomplicating our model.

Accomplishments that we're proud of

Realising our hypothesis of using elastic collisions and a simple trust mechanism to model the behaviour of complex systems such as social networks and macroeconomies. Creating a simulation engine that can handle interactions between thousands of agents performantly

What we learned

We learned that simple physics-based movement and trust rules are enough to create market-like behaviour at scale. As the number of agents increased, local collisions turned into global patterns like clustering and inequality. Small changes in trust or density had much larger effects once the system scaled. Physics naturally limited interactions, making emergence easier to see and measure.

What's next for Emergia

The next phase of Emergia's development will enable more precise parameter adjustments, along with the possibility of expanding its classification categories. This will allow the clusters that emerge to be more accurately defined, for example, by the specific skill sets they represent. Introducing a greater variety of simulation settings will also help to support a broader range of experimental scenarios.