DEV Community

Cover image for My Story of Building a TypeScript Framework for Event-Driven AI Agents
Miodrag Vilotijević
Miodrag Vilotijević

Posted on Edited on

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:

GitHub logo jigjoy-ai / mozaik

Mozaik is a TypeScript runtime for building and sharing AI agents.

Mozaik

Mozaik is a TypeScript runtime for interoperable AI agents.

npm downloads npm downloads weekly npm version

agent-interoperability

Agent Interoperability

Our main goal is to unlock agent interoperability across projects, so Mozaik is built around three core attributes:

  • Concurrency - Agents work independently without blocking one another.
  • Awareness - Agents understand other participants, events, and their shared environment.
  • Adaptivity - Agents change their behavior based on runtime state and emerging needs.

Together, these capabilities free AI agents from specific harnesses, allowing them to work across projects - so every newly created agent adds value to the entire ecosystem.


Installation

npm

npm install @mozaik-ai/core
Enter fullscreen mode Exit fullscreen mode

yarn

yarn add @mozaik-ai/core
Enter fullscreen mode Exit fullscreen mode

pnpm

pnpm add @mozaik-ai/core
Enter fullscreen mode Exit fullscreen mode

API Key Configuration

Mozaik picks a provider from the model name you pass to runInference, and each provider's SDK reads its credential from the environment. Set the keys for the providers you use:

# .env
OPENAI_API_KEY=your-openai-key-here
ANTHROPIC_API_KEY=your-anthropic-key-here
GEMINI_API_KEY=your-gemini-key-here
Enter fullscreen mode Exit fullscreen mode

DeepSeek models…

Top comments (1)

Collapse
 
raju_dandigam profile image
Raju Dandigam •

Making humans and agents participants of one event stream is an interesting escape from blocking run() chains. The production question I'd pin down is ordering and backpressure: when two participants react to the same FunctionCallOutput, what keeps a late or duplicate event from triggering the same action twice? Do ContextItems carry stable IDs and causal parent links that a trace or replay can preserve?