Move From Autonomous Agents to Autonomous Teams

Most agent frameworks today are focused on building autonomous agents.

You create an agent, give it a goal, connect it with tools, and let it execute.

That model is useful, but it is also limited.

Real work is rarely done by isolated individuals. Software teams do not work as one person with many tools. They work as teams of people with different roles, different context, different responsibilities, and different ways of collaborating.

The same should be true for AI agents.

At Mozaik, we believe the next step is not just better autonomous agents.

The next step is autonomous teams.

The Limitation of Isolated Agents

An autonomous agent can reason, call tools, and produce outputs.

But if we want to build more serious systems, one agent is usually not enough.

We need agents that can specialize.

One agent can research.
One agent can write code.
One agent can review.
One agent can test.
One agent can observe the whole process and ask for human approval when needed.

But for this to work, agents need more than tool access.

They need to collaborate.

And collaboration requires awareness.

Right now, in many frameworks, agents are still mostly isolated executors. Even when multiple agents exist, they often communicate through centralized orchestration logic, not through a real collaborative environment.

That is the problem we want to solve with Mozaik.

Why Mozaik Is Built Differently

Mozaik was designed from the beginning around an event-driven foundation.

Instead of thinking about agents as isolated functions, Mozaik thinks in terms of participants inside an agentic environment.

Participants can observe what is happening around them. They can listen to events. They can react to function calls, inference events, semantic events, and other internal signals.

This foundation is important because collaboration does not start with direct communication.

Collaboration starts with awareness.

Before agents can work together, they need to understand that something is happening in the environment.

Mozaik already provides the foundation for this through its reactive architecture.

Participants are not blocking each other. They can react asynchronously. They can observe streams of activity. They can respond to events produced by other participants.

This is what makes Mozaik different.

It is not just an agent executor.

It is a foundation for building agentic systems where multiple participants can exist, react, and coordinate in parallel.

From Observers to Collaborators

The current Mozaik architecture already allows participants to observe each other through events.

But observation is not enough.

If we want to build autonomous teams, participants need to become aware of each other in a more structured way.

That means each participant should expose basic information about itself:

name
role
description
capabilities
available tools
participant id

In practice, this is just a lightweight profile each participant exposes:

participant-profile.ts

interface ParticipantProfile {
  id: string;
  name: string;
  role: string;
  description: string;
  capabilities: string[];
  tools: string[];
}

For example, an environment could contain:

research agent
coding agent
reviewer agent
human participant

Each participant should be able to know who else is available in the environment.

Not by holding direct object references.

Not by creating tight coupling between agents.

But through lightweight participant profiles.

This keeps the event-driven architecture clean, while introducing the missing layer for collaboration.

Introducing Participant Awareness

The first step toward autonomous teams is participant awareness.

When a participant joins the environment, other participants should be able to receive information about it.

For example:

participants.ts

onParticipantJoined(profile)

onParticipantLeft(profile)

This allows every participant to build an internal understanding of the current team.

A coding agent can know that a reviewer agent exists.
A research agent can know that a writing agent exists.
A human participant can observe the whole system.
A team lead agent can coordinate work between multiple specialized agents.

This is the beginning of real multi-agent collaboration.

Direct Messaging Between Agents

Awareness alone is still not enough.

Once agents know who exists, they need a way to communicate intentionally.

That is why the next step is direct messaging between participants.

Mozaik already has the foundation for sending messages. The next improvement is to expose this as a tool so agents can use it naturally.

For example:

send-message.ts

sendMessage({
  to: "reviewer-agent",
  message: "Can you review this implementation?",
});

This is a very important shift.

Instead of agents only reacting to broadcast events, they can intentionally communicate with specific participants.

That means agents can ask for help, delegate work, request review, share findings, or coordinate next steps.

This moves us from autonomous agents to autonomous teams.

Events Are the Nervous System. Messages Are the Collaboration Layer.

One important design decision is that we do not want to remove or replace the current event-driven model.

External hooks like function call events, semantic events, and context item events are still important.

They are useful for:

tracing
logging
streaming UI
approval flows
interception
system-level awareness

These events are the nervous system of the environment.

They let participants observe what is happening.

But direct messages are different.

Messages are intentional communication.

They are the collaboration layer.

This separation is important.

Events should describe what is happening.
Messages should describe what one participant wants from another participant.

By keeping these two concepts separate, Mozaik can support both reactive observation and intentional teamwork.

The Future Is Teams of Specialized Agents

Most agent frameworks are still focused on building individual autonomous agents.

But the future is not one giant agent doing everything.

The future is teams of specialized agents working together.

Just like human teams, agent teams need:

roles
awareness
communication
coordination
delegation
review
feedback loops

Mozaik is moving in that direction.

Because of its event-driven foundation, Mozaik is in a strong position to become one of the first frameworks built specifically for autonomous agentic teams.

Not just agents that execute tasks.

But agents that work together.

The Next Chapter for Mozaik

This feature is the beginning of a bigger direction.

We want Mozaik to support environments where agents can be organized as real teams.

Participants should be able to join, leave, discover each other, communicate, and collaborate while still preserving the clean event-driven architecture.

The goal is not to make agents more complex.

The goal is to make collaboration natural.

Autonomous agents were the first step.

Autonomous teams are the next one.

And Mozaik is being built as the foundation for that future.

Star on GitHub:

github.com/jigjoy-ai/mozaik

Miodrag Vilotijević

Co-founder @ JigJoy

Building the future of agentic systems

With tools and technology we already have, we can build much more valuable systems than most projects today. We can write software that is a pleasure to use and a pleasure to work on; software that doesn't box us in as it grows, but creates new opportunities and continues to add value for its owners.
— Eric Evans