Introducing Zod: The Open-Source AI Agent Framework

Today we are excited to announce the launch of Zod, an open-source framework for building, deploying, and managing AI agents. After months of development and testing with early adopters, we’re thrilled to share what we’ve built.

What is Zod?

Zod is a comprehensive framework that makes it easy to build AI agents that can:

Use external tools and APIs
Maintain persistent memory across sessions
Interact with users through intuitive chat interfaces
Orchestrate complex multi-agent workflows
Deploy to production with ease

Why We Built Zod

We noticed a gap in the market for a framework that combines the power of AI agents with the simplicity of modern web development tools. Existing solutions either required too much boilerplate or lacked the features needed for production use.

Zod bridges that gap by providing:

Extensibility: Plugin architecture for custom tools and extensions
Observability: Built-in logging and monitoring
Developer Experience: Hot reload, CLI tools, and comprehensive documentation
Production Ready: Containerization support, load balancing, and horizontal scaling

Key Features

Agent Extensions

Zod comes with several built-in extensions that you can use out of the box:

Extension	Description
Agent Extension	Manages the AI agent — streaming responses, tool calls, and conversation steering
OpenRouter Extension	Connects to AI model providers with streaming, reasoning tokens, and multi-model support
Policy Extension	Enforces budget limits, step limits, approval gating, and loop detection
Project Extension	Handles workflow orchestration — organizing complex tasks into graphs that can branch and loop
Storage Extension	Manages persistent state — key-value memory, message queues, session persistence, and auto-save
Plugin System	Loads additional capabilities from the internet at runtime without modifying core code

Multi-Agent Support

Zod excels at orchestrating multiple agents working together. Here’s a simple example:

import { Agent, Orchestrator } from '@zod/core';

const researcher = new Agent({
  name: 'researcher',
  description: 'Searches and summarizes information',
  model: 'gpt-4',
  tools: ['search', 'scrape'],
});

const writer = new Agent({
  name: 'writer',
  description: 'Creates content from research',
  model: 'gpt-4',
  tools: ['write'],
});

const orchestrator = new Orchestrator({
  agents: [researcher, writer],
  strategy: 'sequential',
});

const result = await orchestrator.run({
  task: 'Write a report on climate change',
});

Memory and State Management

Zod provides powerful memory capabilities:

const agent = new Agent({
  name: 'assistant',
  memory: {
    type: 'persistent',
    backend: 'redis',
  },
});

await agent.addMemory('user_preferences', {
  theme: 'dark',
  language: 'en',
});

const prefs = await agent.getMemory('user_preferences');

Tool Integration

Easily connect your agents to external services:

const agent = new Agent({
  tools: [
    {
      name: 'search',
      description: 'Search the web',
      handler: async (query) => {
        return await searchAPI.search(query);
      },
    },
    {
      name: 'calculator',
      description: 'Perform calculations',
      handler: async (expression) => {
        return evaluate(expression);
      },
    },
  ],
});

Architecture Overview

Zod is built on a modular architecture:

┌─────────────────────────────────────────┐
│              Zod Framework              │
├─────────────────────────────────────────┤
│  ┌─────────────┐  ┌─────────────────┐  │
│  │   Agents    │  │  Orchestrators  │  │
│  └─────────────┘  └─────────────────┘  │
│  ┌─────────────┐  ┌─────────────────┐  │
│  │   Memory    │  │     Tools       │  │
│  └─────────────┘  └─────────────────┘  │
│  ┌─────────────┐  ┌─────────────────┐  │
│  │   Policy    │  │   Extensions    │  │
│  └─────────────┘  └─────────────────┘  │
└─────────────────────────────────────────┘

Getting Started

Getting started with Zod is straightforward:

# Create a new project
npm create zod@latest my-agent-app

# Navigate to the project
cd my-agent-app

# Start the development server
npm run dev

Then create your first agent:

// src/agent.ts
import { Agent } from '@zod/core';

export const myAgent = new Agent({
  name: 'my-agent',
  description: 'A helpful assistant',
  model: 'gpt-4',
});

const response = await myAgent.chat('Hello, world!');
console.log(response);

Roadmap

We’re just getting started! Here’s what’s coming:

v1.0 (Current): Core agent framework with basic extensions
v1.1: Enhanced multi-agent debugging tools
v1.2: Graph-based workflow builder
v1.3: Enterprise SSO and role-based access control

Community

Join our growing community:

GitHub - Star us and contribute
Discord - Chat with other developers
Twitter - Follow our updates

Conclusion

Zod represents a new approach to building AI agents — one that’s developer-friendly, production-ready, and extensible. We believe it will help developers create more capable and reliable AI systems.

We’re excited to see what you build with Zod! Check out our documentation for tutorials, API reference, and examples.

Thank you for being part of our journey. The future of AI development starts here.