Building a multi-agent system sounds simple on a whiteboard. Give one agent a task, let another handle the next step, add a reviewer, connect a few tools, and you have an agentic workflow.
It gets more complicated when those agents need to operate at the same time.
A sequential workflow can force agents into a fixed order: one finishes, another starts, and everyone downstream waits. That model is easy to reason about, but it can become restrictive as the system grows and agents need to react to new information independently.
Mozaik takes a different architectural approach. It is an open-source TypeScript framework for building reactive agents inside an event-driven environment, where agents can work concurrently, respond to events, and coordinate without requiring a central workflow to define every interaction.
And now there is a practical way to try this architecture.
JigJoy, together with daily.dev and Hyperskill, is organizing the Mozaik Hackathon 2026, a free online hackathon focused on building concurrent AI agents.
TL;DR
Building more agents doesn't automatically make a multi-agent system better. The way those agents communicate, react, and depend on one another can have a bigger impact on how the system behaves as it grows.
Mozaik approaches this problem with an event-driven architecture designed around reactive, non-blocking agents. Agents join a shared AgenticEnvironment, receive events, and decide how to react to them.
Here’s what makes the Mozaik Hackathon 2026 worth a look:
- Concurrent AI agents: Multiple agents can work at the same time and react to events as they arrive.
-
Event-driven architecture: Agents, humans, observers, and tools participate in the same
AgenticEnvironment. - Non-blocking execution: Inference and message delivery can continue in the background without holding up other participants.
- Loosely coupled agents: Agents can operate more independently, making them easier to reuse across projects and applications.
-
TypeScript-based: Mozaik is an open-source TypeScript framework available through
@mozaik-ai/core. - Hands-on learning: Participants build a multi-agent system while exploring agent loops, reasoning-model context, and loop engineering.
- $1,000 cash prize pool: $500 for first place, $300 for second, and $200 for third.
- Free and online: Developers can participate from anywhere without paying an entry fee.
The hackathon takes place on September 5–6, 2026, with a livestream kickoff on September 4 and winners announced on September 13.
If you've been experimenting with AI agents, this is a chance to move past simple API orchestration and explore how concurrent multi-agent systems can be designed.
Table of Contents
- Sequential vs. Concurrent Multi-Agent Systems: What Changes With Mozaik?
- How Mozaik’s Event-Driven Architecture Enables Concurrent AI Agents
- Getting Started With Mozaik: A TypeScript Runtime for Concurrent Agents
- Mozaik Hackathon 2026: Build a Concurrent Multi-Agent System
- What Can You Build With Mozaik?
- Why Developers Should Join the Mozaik Hackathon
- Frequently Asked Questions
- Final Thoughts
Sequential vs. Concurrent Multi-Agent Systems: What Changes With Mozaik?
When developers first build a multi-agent system, a sequential workflow is often the easiest model to understand.
Imagine a research application with five specialized agents:
- A researcher collects information.
- An analyst examines the findings.
- A critic looks for weaknesses.
- A writer turns the results into an answer.
- A reviewer checks the final output.
The workflow might look like this:
Researcher
↓
Analyst
↓
Critic
↓
Writer
↓
Reviewer
Each agent has a clear responsibility, and each stage can pass its output to the next one. For tasks where every step depends on the previous result, this approach makes sense.
The problem appears when agents don't need to wait for each other.
Suppose the researcher finds three useful sources. The analyst could begin examining the first source while the researcher continues collecting information. A critic could inspect an early finding while the rest of the research is still underway. An observer could monitor the work continuously and react if something looks wrong.
A fixed sequence makes those interactions harder to express because the workflow is built around who runs next, not around which agent should react when something happens.
That distinction is central to Mozaik.
| Sequential multi-agent workflow | Mozaik's concurrent model |
|---|---|
| Agents follow an ordered execution path | Agents react to events as they arrive |
| One stage commonly waits for another | Multiple agents can work concurrently |
| Orchestration logic defines the workflow | Participants define their own reactions |
| Adding an agent can require changes to the workflow | New participants can join the shared environment |
| Long-running work can hold up downstream stages | Non-blocking inference allows other activity to continue |
| Agents can become tightly connected to a specific workflow | Agents can operate more independently |
The goal isn't to make every AI workflow concurrent. Some tasks really have dependencies that require an order.
Mozaik is useful for the cases where multiple agents need to observe the same activity, react independently, and continue working while other agents are still processing.
That changes how you design the system.
Instead of starting with a chain such as:
Agent A → Agent B → Agent C
you can think about the system as a shared environment in which several participants respond to events:
┌── Research Agent
│
├── Planning Agent
│
Event ──────────────┼── Coding Agent
│
├── Review Agent
│
└── Observer
The agents still have different responsibilities, but their relationship doesn't have to be encoded as one rigid pipeline.
This also affects agent independence and reuse. When an agent's behavior is based on the events it receives and the handlers it implements, that agent can be easier to move into another application or combine with a different set of participants.
For example, a review agent could be used to evaluate generated code in one application and research findings in another. The surrounding participants can change without requiring the reviewer to become part of a completely different orchestration chain.
That is an important part of Mozaik's approach: concurrency and interoperability are connected to the architecture itself.
The framework gives agents a shared environment where they can collaborate while allowing their individual behavior to remain separate.
And that leads to the next question:
how does Mozaik make this possible under the hood?
How Mozaik’s Event-Driven Architecture Enables Concurrent AI Agents
Mozaik builds its concurrent multi-agent architecture around an AgenticEnvironment.
The environment is shared by humans, agents, observers, and tools. Each participant can emit events, while other participants can listen for the events relevant to their role and decide how to react.
Those events can include plain-text messages, typed ContextItems representing model interactions, and streaming SemanticEvent<T> chunks produced during inference.
The key architectural decision is that participants don't have to wait for a central scheduler to tell them what happens next.
They join the environment, register the handlers they care about, and react when relevant events arrive.
a name="agenticenvironment-a-shared-event-driven-layer">
AgenticEnvironment: A Shared Event-Driven Layer
The AgenticEnvironment acts as the communication layer between participants.
A human can send a message into the environment. An agent can receive it through onMessage(). The agent can then start inference, which can produce reasoning, model messages, or function calls. Other participants can observe those events and decide whether they need to respond.
The flow looks more like this:
Message
↓
Agent reacts
↓
runInference()
↓
Model events
├── Reasoning
├── Function call
└── Model message
↓
Other participants react
There is no requirement that every participant complete its work before the environment can continue processing other events.
That matters because model inference is not instantaneous. A slow model call should not turn the entire multi-agent system into a waiting line.
Non-Blocking Inference Keeps Agents Moving
Mozaik's runInference() capability is designed to be non-blocking.
A reactive agent can receive a message, add it to its ModelContext, and start inference:
async onMessage(message: string): Promise<void> {
this.context.addContextItem(
UserMessageItem.create(message)
);
runInference({
model: "gpt-5.5",
context: this.context,
caller: this,
environment: this.environment
});
}
The important detail is what happens after runInference() is called: the handler returns while the model continues running.
The agent doesn't have to stay waiting for the inference result before the environment can handle other activity. The same participant can respond to another event, while other participants can continue processing their own events.
When inference produces new ContextItems, those items are sent back through the environment. The agent can react through handlers such as onReasoning, onFunctionCall, and onModelMessage, while other participants can observe corresponding external events.
So the underlying pattern becomes:
Event
↓
Reaction
↓
Inference or tool call
↓
New event
↓
Another reaction
Here, Mozaik's reactive agent architecture differs from a workflow that simply executes one function after another. The system can keep responding as new information appears.
Participants Keep Agents Loosely Coupled
Mozaik also separates the participants from the overall application flow.
The base BaseParticipant class provides the foundation for participants, while handlers such as onMessage, onFunctionCall, onReasoning, and onModelMessage allow each participant to implement only the behavior it needs.
That means a participant doesn't have to know the entire application.
A planner can focus on planning.
A researcher can focus on research.
A critic can focus on evaluation.
An observer can monitor events.
They can all participate in the same AgenticEnvironment without requiring one central controller to contain every interaction between them.
This is also what makes the architecture useful for reusable AI agents. If an agent's behavior is defined around the events it understands and the actions it can perform, the same participant can potentially be introduced into another environment with a different combination of agents.
Adding a critic, observer, or specialist can therefore become a matter of composing participants and defining their reactions, instead of redesigning one large workflow every time the system changes.
For developers building AI agent orchestration systems, that is a meaningful change in how the architecture can be structured: the environment provides the shared communication layer, while each participant owns its own behavior.
And this is the kind of architecture the Mozaik Hackathon gives developers a chance to build themselves.
Getting Started With Mozaik: A TypeScript Runtime for Concurrent Agents
Mozaik is written in TypeScript and is available as the @mozaik-ai/core package.
For a new project, installation starts with:
npm install @mozaik-ai/core
You can also install it with Yarn or pnpm:
yarn add @mozaik-ai/core
pnpm add @mozaik-ai/core
The framework resolves the model provider from the model name passed to runInference(). Provider credentials are configured through environment variables, such as:
OPENAI_API_KEY=your-openai-key-here
ANTHROPIC_API_KEY=your-anthropic-key-here
GEMINI_API_KEY=your-gemini-key-here
DeepSeek models can use the OpenAI-compatible chat-completions endpoint with OPENAI_API_KEY and OPENAI_BASE_URL configured for DeepSeek.
For TypeScript projects, Mozaik's documentation recommends a modern moduleResolution setting, such as bundler, node16, or nodenext so package imports resolve cleanly.
Mozaik Hackathon 2026: Build a Concurrent Multi-Agent System
The Mozaik Hackathon is about giving developers the freedom to try out new things with AI agents that work together. It's a chance for them to build something real using Mozaik and see what they can create.
It is fully online and free to enter, and you do not need previous Mozaik experience.
When you sign up, you get a bunch of helpful stuff like documents to read, a template to get started, and a quick intro to get you going before everything kicks off. Plus, the organizers will guide you through the process, so the weekend is not simply a contest where you are handed a framework and left alone with it.
The goal is also educational. You are expected to build something, but the process gives you a chance to understand what is happening underneath an AI agent system: how agents receive events, maintain context, call models and tools, react to outputs, and coordinate with other participants.
Who can participate in the Hackathon?
The hackathon is open to developers anywhere in the world.
You can enter on your own, and the organizers will help solo participants find teammates. You can also bring your own team. The website currently says that team-size limits will be announced soon.
You also do not need to arrive as a Mozaik expert. The event is designed to introduce the runtime to participants before the build weekend begins.
That makes the hackathon relevant to developers who already build AI applications as well as those who are just starting to explore AI agents and multi-agent architecture.
Mozaik Hackathon Timeline: September 4–13, 2026
The main build happens over the weekend of September 5–6, 2026, but the event starts with an introduction on September 4 and ends with the winners' announcement on September 13.
Here is the timeline currently provided by the organizers:
| Date | Event | What happens |
|---|---|---|
| September 4, 2026 | Livestream kickoff | Introduction to Mozaik and the public release of the hackathon brief |
| September 5–6, 2026 | Build weekend | Participants build their concurrent multi-agent systems with Mozaik |
| September 6, 2026 | Submissions close | Submit your repository and short demo by the evening |
| September 13, 2026 | Winners announced | The judging period ends and the winners are announced |
You do not need to travel anywhere, find a physical venue, or rearrange your weekend around an in-person event. You can build from wherever you are and communicate with the organizers and other participants through the event's online channels.
What Can You Build With Mozaik?
Once you understand the event-driven model, the interesting part starts: deciding what you want your multi-agent system to do.
The Mozaik Hackathon does not give developers a long list of predefined tracks. There is one open brief, and the core requirement is simple:
build a working system where several agents run at the same time, share state, and coordinate with one another.
That leaves plenty of ideas for creativity.
You could build a research system where multiple agents investigate different parts of a problem simultaneously, with one agent checking the findings as they arrive. You could create a coding team where a planner, implementation agent, tester, and reviewer respond to changes as the project develops.
You could also go beyond familiar developer workflows. Think about customer-support agents that monitor conversations together, autonomous research teams that exchange findings, content systems where writers and fact-checkers react to new information, or monitoring agents that watch another agent's activity and step in when something needs attention.
A project with five agents that only execute one after another won't demonstrate the concurrent-agent architecture as clearly. A smaller system with three agents that genuinely react to shared events and influence each other's work can demonstrate the architecture much better.
The best way to approach the project is to define these three things before writing the code:
What is the shared goal?
Give all participants a reason to collaborate.What can each agent observe and react to?
This is where Mozaik's event-driven model becomes important.What happens when agents work at the same time?
Your architecture should make concurrency visible in the actual behavior of the application.
That last point matters because the hackathon is specifically looking for systems where concurrency is genuine, not a sequential pipeline presented as a multi-agent application.
Why Developers Should Join the Mozaik Hackathon
Building a multi-agent system from scratch forces you to understand things that can easily stay hidden when you work with higher-level abstractions.
You have to think about agent state, events, context, model inference, tool calls, communication, reactions, and concurrency. You start seeing an AI agent as an actual software component with inputs, behavior, state, and outputs.
That is exactly the kind of experience the Mozaik team wants participants to gain.
You can learn by building alongside other developers
Hackathons are also useful because the learning does not happen in isolation.
The organizers plan to support participants through Discord, including announcements, team formation for people entering solo, and a place to ask questions throughout the weekend.
If you run into a problem with your architecture, need clarification about Mozaik, or simply want to discuss an approach with other builders, there is a shared space for it.
And because the event is open-ended, you are not limited to reproducing one official demo. You get to make architectural decisions yourself and see what happens when you apply the concurrent-agent model to a problem you care about.
There is a real incentive, too
The hackathon offers $1,000 in cash prizes:
| Place | Cash prize |
|---|---|
| 🥇 1st | $500 |
| 🥈 2nd | $300 |
| 🥉 3rd | $200 |
There are also additional prizes and discounts shown on the event page, including subscriptions from the event partners.
But for developers interested in AI engineering, the bigger prize is the opportunity to leave the weekend with a working multi-agent application and a clear understanding of how concurrent agents can be designed.
That is a useful project to have in your portfolio, especially as AI applications move beyond single-agent interactions toward systems where several specialized agents collaborate.
Register for the Mozaik Hackathon 🔥
Frequently Asked Questions
What makes Mozaik different from other AI agent frameworks?
→ Mozaik is built around a concurrent, event-driven architecture where agents don't have to wait for one another in a fixed sequence. Agents can react to events independently, allowing multiple participants to work at the same time while remaining loosely coupled and reusable across different projects.
Do I need experience with Mozaik to join the hackathon?
→ No. The Mozaik hackathon is open to developers without prior Mozaik experience, and participants receive documentation, a starter template, and a primer before the event. The hackathon is also free and fully online, so you can participate without paying an entry fee or traveling.
What will I build during Mozaik hackathon?
→ You'll build a working multi-agent system around an open brief, with the core requirement that multiple agents genuinely run concurrently and coordinate with one another. Possible directions include a research swarm, a self-reviewing codebase, a live operations room, or a system for parallel hypothesis testing.
When does the Mozaik hackathon take place, and is it free?
→ The Mozaik hackathon takes place online on September 5–6, 2026, and it is free to enter. The livestream kickoff is scheduled for September 4, while submissions close on the evening of September 6.
What prizes can Mozaik hackathon participants win?
→ The hackathon offers $1,000 in cash prizes: $500 for first place, $300 for second place, and $200 for third place. Additional prizes include daily.dev Plus subscriptions, Hyperskill Premium subscriptions, and Mozaik Cloud Premium subscriptions, while every participant receives discounts on Mozaik Cloud and Hyperskill Bootcamps.
Final Thoughts
A lot of today's AI agent development still revolves around deciding what happens first, what happens next, and which agent receives the previous agent's output.
That approach works for many tasks. But as systems become more autonomous, there is another way to think about coordination:
Give agents an environment where they can observe events, react independently, and collaborate as the situation changes.
That is the idea Mozaik is bringing to multi-agent development.
Its event-driven architecture, non-blocking inference model, participant system, and shared environment give developers a foundation for experimenting with agents that can work concurrently without every interaction being hard-coded into one sequential workflow.
The Mozaik Hackathon is a chance to take that idea out of the documentation and build something with it.
You do not need to arrive with a finished architecture or years of multi-agent experience. You need a problem worth solving, a willingness to experiment, and an idea for how multiple agents can contribute to the same goal.
If you have been curious about what happens when AI agents can work together without waiting for each other at every step, September 5–6 is a good weekend to find out.
| Thanks for reading! 🙏🏻 I hope you found this useful ✅ Please react and follow for more 😍 Made with 💙 by Hadil Ben Abdallah |
  
|
|---|
Top comments (4)
I still don't have a big knowledge about working with AI agents yet; I'm learning that, but I'll still give this one a try. I need some cash these days 😂 I'll pick one of the project ideas you mentioned.
Thank you so much!
Yeah, it's a great opportunity to win some cash 😅 And it's totally fine if you're still a beginner at working with AI agents; the organizers will support participants through Discord, so don't worry. Just sign up and enjoy your weekend.
Really enjoyed reading this, Hadil. I liked how you explained the difference between simply connecting multiple agents in a sequence and building a system where agents can actually react independently and work concurrently.
The part about event driven architecture and non blocking inference was especially interesting. The example makes it much easier to understand why a rigid pipeline can become limiting when several agents need to observe the same activity and respond to new information at the same time.
The hackathon itself also sounds like a great opportunity to experiment with this architecture in a practical project. I’m curious to see what people build with Mozaik during the event.
Great work, Hadil. Looking forward to seeing more of your AI agent content.
Thank you so much! I’m also curious about the hackathon. It will be really interesting. Hopefully we’ll see some creative ideas come out of it!