Beyond the Hype: Building Agentic Models Without AI

The Open-Source Dilemma (And How I Found Mesa)

It was March 2026 when I finally decided to dive into the world of open-source contributions. During my initial research, I discovered a few popular platforms designed to help beginners, like *Up For Grabs, [Good First Issue](https://goodfirstissue.dev/), and [First Timers Only](https://www.firsttimersonly.com/)*.

These websites are great — they scrape GitHub and list open issues in a structured format, allowing you to easily filter by domain or tech stack. However, I quickly hit a roadblock: the context gap. Even if an issue is labeled as beginner-friendly, you still need a baseline understanding of the overarching project to actually solve it. I realized that if I wanted to tackle multiple issues across different repositories, I’d have to learn the architecture of multiple projects from scratch. Honestly, that felt incredibly tedious.

While stuck in this frustrating phase, I stumbled upon Google Summer of Code (GSoC). For those unfamiliar, GSoC is a global, highly competitive program sponsored by Google that pairs newcomers with open-source organizations to work on a 12-week programming project. Instead of jumping between random, disconnected bug fixes, GSoC allows you to deeply understand and build something meaningful for one specific community.

The process of how to actually prepare and appear for GSoC is a whole other story for another day. But while browsing through their list of participating organizations, one particular project caught my eye: Mesa.

Check out my GSoC proposal here

Introduction: Reclaiming the Word “Agent”

Project Mesa is an open-source framework built for Agent-Based Modeling (ABM) in Python. At its core, it allows developers to build complex simulations where individual entities — called agents — make autonomous decisions within a shared environment based on a specific set of programmed rules.

This project immediately caught my eye because of the current tech landscape. We live in an era where words like “agent” and “autonomous” feel like they are entirely owned by Artificial Intelligence. These days, whenever we hear about “agentic workflows,” we automatically assume there’s a Large Language Model or a massive neural network pulling the strings.

But Mesa represents a whole different paradigm. It proves that autonomous, agent-based systems can be implemented without a single drop of AI. Instead of relying on machine learning and probabilistic math, these agents operate on simple, hard-coded heuristics that somehow generate incredibly complex, real-world behaviors. Sounds interesting, right?

But here is where it gets even better. While Mesa thrives on these traditional, rule-based models, it isn’t stuck in the past. If you do want to bridge the gap between classical modeling and modern AI, Mesa recently introduced Mesa-LLM and Meta Agents. This feature allows you to integrate Large Language Models directly into your simulations. It is truly the best of both worlds.

What exactly is Agent-Based Modeling?

At its core, Agent-Based Modeling (ABM) is a computational simulation method where autonomous, individual entities (we call them “agents”) interact within a defined space.

Instead of relying on top-down math equations to calculate system-wide averages, ABM builds worlds from the “bottom up.” By giving each individual agent a basic set of behaviors and decisions, you can watch incredibly complex, real-world patterns naturally emerge from their interactions over time.

The 5 Key Building Blocks of ABM

To build one of these simulations, you really only need to understand five core components:

• Agents: The individual actors in your world (e.g., people, cars, or even cells). They hold specific attributes, memory, and sometimes the ability to learn and adapt from past experiences.
• Behaviors: The strict rules and heuristics that dictate how your agents make decisions and react to other agents.
• The Environment: The virtual space where agents live. As agents move and act, they can interact with and modify this space.
• Interaction Topology: The underlying structure that dictates who can interact with whom. This can be a physical layout (like a grid of city streets) or an abstract web (like a social network graph mapping how a rumor spreads).
• Emergence: The magic of ABM. This is the overarching, macro-level pattern that results from thousands of micro-level interactions. The final global outcome is almost always far more complex than the simple rules you gave the agents.

Under the Hood of Mesa

Mesa is an open-source Python library specifically designed for creating, analyzing, and visualizing Agent-Based Models. Remember how we talked about AI agents relying on massive neural networks and probabilistic math? Mesa takes a completely different approach. Here, agents operate strictly on heuristics — the specific, hard-coded rules that you, the programmer, write.

To understand how Mesa actually works under the hood, you really only need to look at its three core building blocks:

• The Model (mesa.Model): Think of this as the “God” class of your simulation. It is the master controller that initializes the environment, keeps track of all the active agents, and runs the simulation clock (often referred to as steps or ticks).
• The Agents (mesa.Agent): These are the individual actors within your model. When building a simulation, you define their fundamental properties (like their location, wealth, or health) and their behaviors (like moving, interacting, or learning). Most importantly, every agent has a step() function. This function acts as their brain, dictating exactly what action the agent must take every time the simulation clock ticks based on your pre-defined rules.
• The Space (mesa.space): This is the physical or logical environment itself. It is the digital arena where your agents exist and interact, typically defined as a discrete grid (like a city street) or a complex network graph.

Building My First ABM: The Traffic Simulator

After exploring the theory behind agent-based modeling, it was time to build my own minimal ABM using the Mesa framework to simulate something we all dread: highway traffic.

The Architecture & Rules of the Road

To build this simulation, I created a basic highway environment where autonomous vehicle agents navigate from left to right. I didn’t program any complex driving behaviors; instead, they are governed by a few fundamental, hard-coded heuristics:

• The Grid: The environment is a discrete grid (defaulting to 20×5 spaces).
• Initialization: Agents (cars) are dropped into the grid at random coordinates, maintaining a strict rule of only one car per cell.
• The Golden Rule: During every single time step, every car attempts to move exactly one space to the right.
• Binary Logic: The decision-making is completely binary. If the target cell ahead is vacant, the car moves forward. If it is occupied, the car remains stationary.
• The Loop: The grid’s topology is a “torus” (wraparound). If a car drives off the right edge of the screen, it immediately re-enters on the left side, simulating a continuous flow of traffic.

Check out the full code on my GitHub here

The Results: Engineering a Phantom Traffic Jam

So, what happens when we actually run this simulation?

I set up the 20x5 grid — meaning there are exactly 100 available spaces on our virtual highway — and started incrementally adding cars. During the batch run, I tracked two metrics: Throughput (how many cars successfully move per step) and Congestion (how many cars are stuck waiting).

At first glance, the results plotted on the graphs below felt completely counterintuitive. You would naturally assume that putting more cars on a highway means more cars are traveling. But that is not what happens at all.

Comparison graph of throughput, density, congestion

Here is what the data actually revealed:

• The Sweet Spot (0% to 40% Density): When the road is mostly empty, traffic flows beautifully. The green throughput line climbs steadily because almost every car easily finds an empty cell in front of it. The red congestion line stays completely flat at zero.
• The Tipping Point (~50% Density): Right around half-capacity, throughput hits its absolute peak. This is the maximum efficiency of our digital highway — the exact moment we have the highest number of cars moving before the system breaks.
• The Phantom Jam (60% to 100% Density): This is where the graphs look contradictory, but are entirely accurate. Once we cross that halfway threshold, throughput plummets, and the number of stopped cars skyrockets. Why? Because as the grid crowds, the probability of finding a vacant space drops. The cars inevitably start blocking each other.
• Total Gridlock (100% Density): At 100% density, we have 100 cars occupying all 100 spaces. Every single car looks to its right, sees another car, and hits the brakes. Throughput drops strictly to zero.

The Big Takeaway This simple traffic model perfectly demonstrates the magic of Agent-Based Modeling: Emergence. I didn’t write any complex, top-down algorithms dictating how to create a traffic jam, nor did I program a specific density limit. I only gave the agents one microscopic binary rule: move if the space is vacant, otherwise stay still. The massive, system-wide failure of gridlock is an emergent phenomenon that happened entirely from the bottom up.

Amazingly, this basic rule-based model successfully simulated a real-world civil engineering concept known as the Macroscopic Fundamental Diagram of Traffic Flow!

Conclusion: Predicting Real-World Chaos

Seeing how a basic grid of rules can perfectly simulate those phantom traffic jams got me thinking: where else is this actually being used? It turns out, Agent-Based Modeling is quietly running simulations for some of the most critical systems in the world — entirely without the AI algorithms we hear so much about today.

These models predict real-world chaos. Here are a few fascinating ways ABM is utilized:

• Epidemiology: Imagine our traffic agents are people and the grid is a city. Epidemiologists use ABM to model how viruses spread, allowing them to test “what-if” scenarios like lockdowns or vaccination drives before implementing real-world policies.
• Supply Chain & Logistics: Global shipping ports are just massive grids with moving parts. By making agents out of cargo ships, automated cranes, and trucks, companies can spot and solve inevitable bottlenecks long before the holiday rush hits.
• Crowd Evacuation: How do you safely test an emergency evacuation of a 50,000-seat stadium? You can’t. Instead, engineers use ABM. By simulating stadium-goers and programming rules for “panic,” architects can observe emergent bottlenecking and design safer, wider exits.

It’s pretty mind-blowing when you realize that just giving digital entities a few basic instructions can map out the extreme unpredictability of human life.