My Story of Building a TypeScript Framework for Event-Driven AI Agents

While working on agentic systems my co-founder early on detected the core limitation of agentic systems. They are doing this sequentially, so AI agent need to wait other agent to start the work. And they are blocking in nature - if you are building agentic system you probably know that almost any SDK or library has agents with blocking run method (await).

So we decided to start addressing this problem and open up new possibilities - if we manage to make agents act more like humans: work autonomously, in parallel, interrupt, react to others and environment.

For me it was hard to structure this agent communication. At first it was hard to detect from where to start - but after days of reading white papers, documentation of LLM providers I found the clue.

It was OpenResponses documentation by OpenAI, Vercel, OpenRouter, Hugging Face - they unite to specify unified structure of context.

They describe all context items in depth - I will cover just the basic idea:

DeveloperMessage
SystemMessage
UserMessage
Reasoning
FunctionCall
FunctionCallOutput
ModelMessage

All those items are streamable using semantic events.

That was starting point for my framework.

Only after that I realized I need stronger foundation.

I started with building multi-provider library - but in order to go further and to decouple infrastructure for my code library I needed to create higher degree of abstraction than just mapping request to LLM providers.

So I turned this specification into objects - enabling easy population of context, persistence, and streaming.

Now I wanted to create interceptor while those context items generate in real-time.

My second decision was to model agent loop as state machine with following states:

user message received
inference pending
function call pending
model message received
Switching states based on probability of LLM response. I added hooks for each state so developers can write logic to control loop:

onUserMessage
beforeInference
afterInference
beforeFunctionCall
afterFunctionCall
onModelMessage

It was good progress - but it was still modeling runtime of a single agent.

After that I realized - to structure agent communication they probably need to share context items and semantic events. That was a mini insight I discovered down the road. But I soon realized that agent loop is just one concrete implementation of agent workflow with automated switching from one state to another.

I needed more abstract solution - where developers can write logic to control the agent’s stream of context items that are generating in real time.

So I removed agent loop abstraction. And came up with new idea. I will make agents and humans abstract - and model environment where they operate together. Participants subscribe to environment for listening context items. Every time new context item arrives - each participant will be notified so they can react on other participants work.

Also I introduced generators for:

FunctionCallRunner
InferenceRunner
InputStream

Participants need to provide those generators during initialization.

That was important decision - because with abstract generators which are isolated from communication we can easily mock LLM calls and test framework even before we send any real request.

And voilà - we created environment where agents can naturally connect and react on the stream of context items they are producing. Not sequential. Not blocking. But event-driven. More like how humans actually work.

That’s my story of building a TypeScript framework. I am excited to see what possibilities and challenges will emerge when using multiple agents at once.

Check it out:

jigjoy-ai / mozaik

Mozaik is a TypeScript framework for building non-blocking AI agents.

Mozaik

Mozaik is a TypeScript framework for building AI agents that share an agentic environment instead of being orchestrated through rigid pipelines.

In Mozaik, humans, agents, observers, and tools are all Participants of the same AgenticEnvironment. Each participant runs non-blocking and streams typed ContextItems into the environment. Every other participant sees those items in real time and can react, intercept, or stay silent — without any central scheduler.

---

Installation

yarn add @mozaik-ai/core

API Key Configuration

# .env
OPENAI_API_KEY=your-openai-key-here

---

The agentic environment

AgenticEnvironment is a broadcast bus for typed context items. Participants join() it, and any item produced by one participant is delivered to every subscriber's onContextItem(source, item) callback.

flowchart LR
    Human[BaseHumanParticipant] -->|streamInput| Env(("AgenticEnvironment"))
    Agent[BaseAgentParticipant] -->|"runInference / executeFunctionCall"| Env
    Observer[Custom Participant] -->|join| Env
    Env -->|onContextItem| Human
    Env -->|onContextItem| Agent
    Env -->|onContextItem| Observer

Loading

---

Non-blocking participants

Mozaik ships two ready-to-use participants:

Participant	Capabilities	Pulls from
BaseHumanParticipant

…

View on GitHub