How Three Contributors Shipped Mozaik v3.11 to v3.13 in Two Weeks

Three developers found Mozaik, read the code, disagreed with zero of the architectural decisions, and started shipping.

That sentence still feels unreal to write. We never believed this would happen. You build something in a room alone, you argue with yourself about port interfaces at 2 AM, you push commits that nobody will read — and then one morning, someone opens a PR that proves they read all of it. They understood. They cared. Not because you paid them. Because the architecture spoke to them the way it spoke to you.

That is the article. Everything below is context.

The open source phenomenon

Someone reads your code on a Tuesday night. By Wednesday morning they are in your Discord, asking about how the event bus delivers context items to subscribers. By Thursday they have a PR open. By the weekend, the feature is merged and the test suite is green.

That is the phenomenon. People who have never met, spread across timezones, connected by nothing except a shared obsession with event-driven architecture and Domain-Driven Design — suddenly shipping together at 3x the speed and accuracy of any team we have ever been part of.

We talk about bounded contexts and port interfaces in Discord. We argue about whether an aggregate should emit an event or return a value. We sketch hexagonal boundaries on whiteboards that only exist as text messages. And then someone pushes a commit that makes the entire conversation real.

This is what open source is supposed to feel like. Not a contribution graph. Not a PR count. A shared room where people who care about the same things find each other and build something none of them could build alone.

@kisshan13 and @danndav showed up on Mozaik. Not with typo fixes. With domain-layer tests, error isolation, structured output across three providers, and infrastructure integration suites. They read the architecture, understood the hexagonal boundaries, and contributed code that respected them. That does not happen by accident. That happens because the architecture was worth respecting.

@tcsenpai showed up on baro — our parallel coding agent built on Mozaik. Within days: a full semantic memory system (Vectra + ONNX embeddings), an OpenCode/Codex backend, adversarial review passes, and hardened error handling. The parallel agent architecture in Mozaik gave baro a structural advantage that attracted someone who wanted to build on solid ground — not on a wrapper around fetch.

People joining your project because they love what you build. Not for clout. Not for a line on a resume. Because they see the same future you see and want to make it real. We never thought we would experience that. It is the most beautiful thing in open source — and it is happening to us right now.

What we built together

Versions 3.11 through 3.13 landed in two weeks. Here is what changed and why it matters.

Four providers. One interface.

OpenAI, Anthropic, Gemini, DeepSeek — all reachable through a single Endpoint port:

endpoint.ts

interface Endpoint {
  infer(request: InferenceRequest): Promise<InferenceResponse>;
  stream(request: InferenceRequest): AsyncIterable<SemanticEvent<unknown>>;
}

No provider-specific glue in your agent code. The runtime resolves the right adapter. You write business logic. The infrastructure does infrastructure things.

Parameter-driven inference

Before v3.13, running inference meant constructing an entire object graph that had nothing to do with your intent. You had to initialize a FunctionCallRunner, an InferenceRunner, a ModelContext, configure a GenerativeModel instance with tools and streaming flags, create the AgenticEnvironment, wire everything together, join, start. Forty lines of ceremony before your agent could think a single thought:

before-v3.13.ts

import {
  AgenticEnvironment,
  ModelContext,
  OpenAIInferenceRunner,
  DefaultFunctionCallRunner,
  Gpt54,
} from "@mozaik-ai/core";

// Init the function call runner with tools
const functionCallRunner = new DefaultFunctionCallRunner([...tools]);

// Init the inference runner
const inferenceRunner = new OpenAIInferenceRunner();

// Create model context
const context = ModelContext.create("my-agent");

// Create and configure the model
const model = new Gpt54();
model.setTools([...tools]);
model.setStreaming(true);

// Create the environment
const environment = new AgenticEnvironment();

// Create the agent with all dependencies
const agent = new MyAgent(
  inputSource,
  inferenceRunner,
  functionCallRunner,
  environment,
  context,
  model,
);

// Join and start
agent.join(environment);
environment.start();

Every one of those lines is plumbing. None of them express what your agent is trying to do. The developer is doing the framework's job.

Now — one call:

after-v3.13.ts

// That's it. One call. The framework resolves everything.
runInference({
  model: 'claude-4-5-haiku',
  tools: myTools,
  streaming: true,
  structuredOutput: mySchema,
  context: this.context,
  caller: this,
  environment: this.environment,
});

That is the entire interface. Pass a model name as a string. The application layer resolves the GenerativeModel, the Endpoint, the InferenceRunner, the FunctionCallRunner, the ModelRuntime — all of it. You describe what. The framework handles how.

The full type signature for the curious:

inference-params.ts

type InferenceParams = {
  model: string;
  reasoningEffort?: string;
  tools?: Tool[];
  streaming?: boolean;
  structuredOutput?: StructuredOutputFormat;
  context: ModelContext;
  caller: Participant;
  environment: AgenticEnvironment;
  signal?: AbortSignal;
};

We did the heavy lifting so you never have to. That is what a framework is supposed to do. Most "frameworks" just re-export SDK types. This one actually earns the name.

Error isolation — agents that recover instead of crash

@kisshan13 shipped the silent mode flag for tracing parallel agent execution — and then went further. He added dedicated handlers for error isolation across the environment.

Before: one participant throws, the entire environment delivery loop dies. Every other subscriber goes deaf. After: exceptions are caught per-subscriber, wrapped in AgenticError, and delivered through dedicated hooks:

error-hooks.ts

abstract onError(error: AgenticError): void
abstract onParticipantError(source: Participant, error: AgenticError): void

This is not just "nice error handling." This is the foundation for retry logic, circuit breakers, and graceful degradation in multi-agent systems. Agent B fails mid-inference? Agent A finds out through onParticipantError, decides whether to retry, escalate, or proceed without it. The environment stays alive. The other participants keep working.

In a world where every agent framework crashes on the first unexpected exception — agents that recover are agents that ship.

Structured output

Every provider now supports StructuredOutputFormat — name, JSON schema, strict mode. Pass it through InferenceParams, get typed responses back. OpenAI, Anthropic, Gemini — same interface, same behavior. DeepSeek opts out (their API does not support it yet), and the specification flag supportStructuredOutput tells you that at model resolution time, not at runtime failure time.

Tests that prove the architecture

@Lotus015 landed a comprehensive test suite across all three layers — domain, application, infrastructure. Unit tests for the agentic environment, participants, context items, inference runner, function call runner. Integration tests for OpenAI Responses, Gemini GenerateContent, and structured output mapping. The hexagonal architecture pays off here: domain tests need zero infrastructure. Application tests mock ports. Infrastructure tests hit real APIs. Clean separation, clean tests.

baro: what happens when Mozaik agents run in parallel

baro is a coding agent that plans work, splits it into stories, and runs multiple agents in parallel — each on its own branch, each with its own model context. It is built on Mozaik because Mozaik's AgenticEnvironment already solved the hard problem: multiple participants sharing a reactive event space without stepping on each other.

@tcsenpai joined the project and immediately understood the leverage. His commits over the past week:

Semantic memory (Vectra + ONNX) — cross-agent memory that persists across runs. Agents learn from previous sessions without re-reading the entire codebase.
OpenCode backend — a new agentic backend, fully integrated with the provider picker and planner selector.
Adversarial hardening — path traversal fixes, cache limits, prompt injection guards, deterministic IDs, ESM compatibility.

None of this required changing Mozaik's core. The architecture is extensible because it has boundaries — not because it has plugin systems.

How we work

Everything is public. Not as a gesture. As a constraint.

Discord: Real-time conversations about why we build things the way we do. Architecture debates. Design decisions before they become PRs.
Public backlog: You can see what we are working on next. You can tell us what is wrong with our priorities.
Source code: Both mozaik and baro are fully open. Not "source available." Open.

We do not have a roadmap deck. We have a Discord channel where we argue about whether Endpoint should be a class or an interface, and then we ship the answer.

Come build the thing that matters

This is not another wrapper. This is not another LangChain fork with better docs. This is an autonomous, reactive, event-driven agentic system designed with Domain-Driven Design from the first commit. Agents that do not block each other. Agents that react to events in real time. Agents that recover from failure without killing the environment. The most sophisticated agentic architecture being built in public — because architecture still matters.

The people who showed up made it better in two weeks than we could have alone in two months. That is not a platitude. That is the commit history.

Help us build the first real autonomous reactive agentic system.

Star Mozaik on GitHub: github.com/jigjoy-ai/mozaik
Join our Discord: discord.gg/33uMhcerDU — Argue about architecture with us. Tell us what is broken. Ship the fix.
Check out baro: github.com/jigjoy-ai/baro — parallel coding agents that actually work.

AMD has a slogan: "Together we advance."

That is not just their line. That is our philosophy while building Mozaik. No single person builds a real agentic system alone. The architecture matters — but the people who show up and push it forward matter more. Together we advance.

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