Daydreams

Daydreams - AI Agent Framework

> Notice: This agent framework is no longer the core focus as features are already obsolete. > > The Daydreams core focus is on Agentic Commerce and not the agent harness. > > Check out the lucid-agents repo: https://github.com/daydreamsai/lucid-agents > > We recommend the Pi agent harness for building agents and incorporating lucid-agents in it.

Finally, TypeScript agents that scale and compose

🌐 Website • ⚡ [Quick Start](#-quick-start) • 📖 Documentation • 💬 Discord

🎯 The Problem Every AI Developer Faces

You build an AI agent. It works great in testing. Then you need to add more features and...

❌ Context switching breaks existing functionality ❌ State management becomes a nightmare ❌ Memory doesn't persist across sessions ❌ Code becomes a tangled mess of prompts and logic

Sound familiar? You're not alone. This is why most AI agents never make it to production.

⚡ The Solution: Composable Context Architecture

Daydreams is the first AI framework with composable contexts - isolated workspaces that combine for complex behaviors. Build agents that remember, learn, and scale with true memory, MCP integration, and TypeScript-first design.

🌐 Dreams Router - Universal AI Gateway

Access any AI model through one API with built-in authentication and payments:

import { dreamsRouter } from "@daydreamsai/ai-sdk-provider";

// Use any model from any provider
const models = [
  dreamsRouter("openai/gpt-4o"),
  dreamsRouter("anthropic/claude-3-5-sonnet-20241022"),
  dreamsRouter("google-vertex/gemini-2.5-flash"),
  dreamsRouter("groq/llama-3.1-405b-reasoning"),
];

// Pay-per-use with USDC micropayments (no subscriptions)
const { dreamsRouter } = await createDreamsRouterAuth(account, {
  payments: { amount: "100000", network: "base-sepolia" }, // $0.10 per request
});

Features:

• Universal Access - OpenAI, Anthropic, Google, Groq, xAI, and more
• x402 Payments - Pay-per-use with USDC micropayments
• OpenAI Compatible - Works with existing OpenAI SDK clients
• Automatic Fallbacks - Built-in provider redundancy

🌐 Live Service: router.daydreams.systems • 📖 Router Docs • ⚡ Router Quickstart

🌟 The Power of Context Composition

Unlike other frameworks, Daydreams lets you compose contexts using .use() - creating powerful agents from modular components:

import { createDreams, context, action } from "@daydreamsai/core";
import { openai } from "@ai-sdk/openai";

// Base analytics context - tracks user behavior
const analyticsContext = context({
  type: "analytics",
  create: () => ({ events: [], sessions: 0 }),
}).setActions([
  action({
    name: "trackEvent",
    schema: { event: z.string() },
    handler: async ({ event }, ctx) => {
      ctx.memory.events.push({ event, timestamp: Date.now() });
      return { tracked: true };
    },
  }),
]);

// Customer support context that composes with analytics
const supportContext = context({
  type: "support",
  schema: z.object({
    customerId: z.string(),
    tier: z.enum(["free", "premium"]),
  }),
  create: () => ({ tickets: [] }),
})
  // 🌟 The magic: compose contexts together
  .use((state) => [
    { context: analyticsContext, args: { userId: state.args.customerId } },
    // Conditional composition based on customer tier
    ...(state.args.tier === "premium" ? [{ context: premiumContext }] : []),
  ])
  .instructions(
    (state) =>
      `You are a ${state.args.tier} customer support agent. Track all interactions.`
  );

// Agent automatically gets ALL composed functionality
const agent = createDreams({
  model: openai("gpt-4o"),
  contexts: [supportContext],
});

// Customer gets support + analytics + premium features (if applicable)
await agent.send({
  context: supportContext,
  args: { customerId: "alice", tier: "premium" },
  input: "I need help with billing",
});

Result: Your agent seamlessly combines customer support, analytics tracking, and premium features in a single conversation. No manual integration required.

🔌 Universal MCP Integration

Connect to any Model Context Protocol server for instant access to external tools:

import { createMcpExtension } from "@daydreamsai/mcp";

const agent = createDreams({
  extensions: [
    createMcpExtension([
      {
        id: "filesystem",
        transport: {
          type: "stdio",
          command: "npx",
          args: ["@modelcontextprotocol/server-filesystem", "./docs"],
        },
      },
      {
        id: "database",
        transport: {
          type: "stdio",
          command: "npx",
          args: ["@modelcontextprotocol/server-sqlite", "./data.db"],
        },
      },
    ]),
  ],
});

// Use MCP tools in any action
const searchAction = action({
  name: "search-docs",
  handler: async ({ query }, ctx) => {
    // Read files via MCP
    const docs = await ctx.callAction("mcp.listResources", {
      serverId: "filesystem",
    });

    // Query database via MCP
    const results = await ctx.callAction("mcp.callTool", {
      serverId: "database",
      name: "query",
      arguments: { sql: `SELECT * FROM docs WHERE content LIKE '%${query}%'` },
    });

    return { docs, results };
  },
});

Result: Your agent instantly gets file system access, database querying, web scraping, 3D rendering, and more through the growing MCP ecosystem.

🚀 Get Your Agent Running in 60 Seconds

npm install @daydreamsai/core @ai-sdk/openai zod

import { createDreams, context, action } from "@daydreamsai/core";
import { openai } from "@ai-sdk/openai";
import { z } from "zod";

// Define a simple weather context
const weatherContext = context({
  type: "weather",
  create: () => ({ lastQuery: null }),
}).setActions([
  action({
    name: "getWeather",
    schema: z.object({ city: z.string() }),
    handler: async ({ city }, ctx) => {
      ctx.memory.lastQuery = city;
      // Your weather API logic here
      return { weather: `Sunny, 72°F in ${city}` };
    },
  }),
]);

// Create your agent
const agent = createDreams({
  model: openai("gpt-4o"),
  contexts: [weatherContext],
});

// Start chatting!
await agent.send({
  context: weatherContext,
  input: "What's the weather in San Francisco?",
});

That's it! Your agent is running with persistent memory and type-safe actions.

Or scaffold a complete project:

npx create-daydreams-agent my-agent
cd my-agent && npm run dev

🔥 Why Developers Are Switching to Daydreams

| 🏗️ Traditional AI Frameworks | ⚡ Daydreams | | ------------------------------- | --------------------------------- | | Monolithic agent design | Composable context architecture | | Memory resets between sessions | Persistent memory across restarts | | Manual state management | Automatic context isolation | | Complex integration setup | Native MCP support | | JavaScript with types bolted on | TypeScript-first design |

✨ Enterprise-Grade Features

🧩 Composable Contexts - Build complex agents from simple, reusable contexts 🔌 Native MCP Support - Universal access to external tools and services 💾 Persistent Memory - True stateful agents that remember across sessions ⚡ Full TypeScript - Complete type safety with excellent developer experience 🎯 Context Isolation - Automatic separation of user data and conversations 🔧 Action Scoping - Context-specific capabilities and permissions 🌐 Universal Runtime - Works in Node.js, browsers, Deno, Bun, and edge functions 🏗️ Modular Extensions - Clean plugin architecture for platforms and services 📊 Full Explainability - Understand every decision your agent makes

🏗️ Core Architecture

Context System

Isolated stateful workspaces for different conversation types:

const userContext = context({
  type: "user",
  schema: z.object({ userId: z.string() }),
  create: () => ({ preferences: {}, history: [] }),
  render: (state) =>
    `User: ${state.args.userId} | History: ${state.memory.history.length} items`,
});

Memory System

Dual-tier storage with automatic persistence:

• Working Memory: Temporary execution state (inputs, outputs, actions)
• Context Memory: Persistent data defined by your create() function

Action System

Type-safe functions with context access and schema validation:

const savePreference = action({
  name: "save-preference",
  description: "Save a user preference",
  schema: z.object({ key: z.string(), value: z.string() }),
  handler: async ({ key, value }, ctx) => {
    ctx.memory.preferences[key] = value;
    return { saved: `${key} = ${value}` };
  },
});

Extension System

Modular integrations for platforms and services:

import { discordExtension } from "@daydreamsai/discord";
import { supabaseExtension } from "@daydreamsai/supabase";

const agent = createDreams({
  extensions: [
    discordExtension({ token: process.env.DISCORD_TOKEN }),
    supabaseExtension({ url: process.env.SUPABASE_URL }),
  ],
});

🎯 Context Patterns

Single Context - Simple & Focused

Perfect for straightforward bots:

const faqBot = context({
  type: "faq",
  instructions: "Answer questions about our product",
});

Multiple Contexts - Separate Workspaces

When you need isolated functionality:

const agent = createDreams({
  contexts: [
    chatContext, // User conversations
    gameContext, // Game sessions
    adminContext, // Admin functions
  ],
});

🌟 Composed Contexts - Maximum Power

This is where Daydreams excels - contexts working together:

const smartAssistant = context({
  type: "assistant",
  schema: z.object({ userId: z.string(), plan: z.enum(["free", "pro"]) }),
}).use((state) => [
  // Always include user profile
  { context: profileContext, args: { userId: state.args.userId } },
  // Always include basic analytics
  { context: analyticsContext, args: { userId: state.args.userId } },
  // Add premium features for pro users
  ...(state.args.plan === "pro" ? [{ context: premiumContext }] : []),
]);

📖 Learn More About Contexts →

🔌 MCP Integration

Daydreams provides native Model Context Protocol support through extensions:

import { createMcpExtension } from "@daydreamsai/mcp";

// Connect to any MCP server
createMcpExtension([
  // Local servers via stdio
  {
    id: "files",
    transport: { type: "stdio", command: "mcp-server", args: ["./data"] },
  },
  // Remote servers via HTTP/SSE
  {
    id: "api",
    transport: { type: "sse", serverUrl: "https://mcp-api.example.com" },
  },
]);

Popular MCP Servers:

• Database Access: SQLite, PostgreSQL, MySQL
• File Systems: Local files, cloud storage, git repos
• Web Services: Search, scraping, APIs, social media
• Developer Tools: Code execution, testing, deployment
• Specialized: 3D rendering, image processing, analytics

📖 Learn More About MCP →

📚 Documentation & Learning

🏠 Complete Documentation - Everything you need to build production agents

🏃‍♂️ Quick Start Paths

🎯 I want to test it myself → 5-minute quickstart 🛠️ I want to see examples → [Working examples](#-examples) 🚀 I want to build something → [Tutorials](#tutorials) 💬 I need help → Join our Discord

Essential Guides

• First Agent - Build your

first agent in 5 minutes

• Context System -

Master stateful conversations

• MCP Integration -

Connect to external tools

• Extensions -

Platform integrations

Tutorials

• Basic Agent -

Simple conversational bot

• Multi-Context Agent -

Handle multiple workflows

• MCP Setup -

Connect external servers

• x402 Nanoservice -

Paid AI services

🚀 Extensions & Ecosystem

Platform Integrations

• @daydreamsai/discord -

Discord bot support

• @daydreamsai/twitter -

Twitter/X automation

• @daydreamsai/telegram -

Telegram bots

• @daydreamsai/cli -

Interactive terminal

Storage & Memory

• @daydreamsai/supabase -

Supabase vector store

• @daydreamsai/chroma -

ChromaDB integration

• @daydreamsai/mongo -

MongoDB persistence

Developer Tools

• @daydreamsai/mcp - Model

Context Protocol

• create-daydreams-agent -

Project scaffolding

🎯 Perfect For Your Use Case

| E-commerce | Healthcare | Financial Services | Developer Tools | | --------------------------- | ------------------------- | ------------------------ | ------------------------ | | Customer service at scale | HIPAA-ready agents | Compliance-first design | Code review automation | | Order processing automation | Patient data protection | Built-in risk management | Documentation generation | | Inventory management | Treatment recommendations | Transaction monitoring | API testing assistance |

🏃‍♂️ Examples

Explore working examples in [examples/](./examples):

• [Basic Chat](./examples/basic/) - Simple conversational agents
• [Multi-Context](./examples/basic/multi-context.tsx) - Multiple

conversation types

• [Discord Bot](./examples/social/discord.ts) - Platform integration example
• [MCP Integration](./examples/mcp/) - External tool connections
• [x402 Nanoservice](./examples/x402/) - Paid AI services with micropayments

🌟 Featured Examples

Each example includes:

• Complete TypeScript source code
• Step-by-step setup instructions
• Configuration examples
• Testing and deployment guides

🛠️ Development

Contributing

We welcome contributions! See [CONTRIBUTING.md](./CONTRIBUTING.md) for guidelines.

Development setup:

git clone https://github.com/daydreamsai/daydreams.git
cd daydreams
pnpm install
./scripts/build.sh --watch
bun run packages/core  # Run tests

🤝 Community & Support

📈 Join 1,000+ Developers Building Better AI

Companies using Daydreams: E-commerce platforms • Healthcare providers • Financial institutions • Developer tools

Get Help & Connect

💬 Discord Community - Get help from the team and community 📖 Documentation - Comprehensive guides and examples 🐛 **GitHub Issues*

…

Source & license

This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: daydreamsai
• Source: daydreamsai/daydreams
• License: MIT
• Homepage: https://docs.daydreams.systems/

Install and usage instructions live in the source repository linked above.