# Builder.io Agent Native Dependencies: Complete Monorepo Package Guide

> Discover the complete monorepo package guide for Builder.io Agent Native dependencies. Explore core runtime, AI SDKs, UI primitives, and platform-specific extensions.

- Repository: [Builder.io/agent-native](https://github.com/BuilderIO/agent-native)
- Tags: package-guide
- Published: 2026-07-18

---

**Builder.io Agent Native is a monorepo where the core runtime `@agent-native/core` depends on AI SDKs, UI primitives, and database libraries, while other packages extend it for specific platforms like mobile, desktop, and VS Code.**

The BuilderIO/agent-native repository organizes its architecture as a workspace-based monorepo. While the root [`package.json`](https://github.com/BuilderIO/agent-native/blob/main/package.json) only manages scripts and workspace configuration, the actual runtime dependencies live within individual packages, with `@agent-native/core` serving as the central engine that powers the entire framework.

## Core Package Dependencies

The `@agent-native/core` package located at [`packages/core/package.json`](https://github.com/BuilderIO/agent-native/blob/main/packages/core/package.json) constitutes the heart of the framework. It bundles together the action runtime, state management, UI components, and AI provider adapters required to build agent-native applications.

### AI and LLM Integration

The core package integrates with multiple large language model providers through specific SDKs. **Anthropic's SDK** (`@anthropic-ai/sdk` at `^0.90.0`) provides direct access to Claude models, while the **Model Context Protocol** (`@modelcontextprotocol/sdk` at `^1.29.0`) enables standardized context sharing between AI systems. Tokenization is handled by `@anthropic-ai/tokenizer` version `0.0.4`.

```json
{
  "@anthropic-ai/sdk": "^0.90.0",
  "@anthropic-ai/tokenizer": "0.0.4",
  "@modelcontextprotocol/ext-apps": "1.7.2",
  "@modelcontextprotocol/sdk": "^1.29.0"
}

```

### Database and State Management

Persistent state and SQL operations rely on **Drizzle ORM** (`^0.45.2`) paired with **libSQL** (`@libsql/client` at `^0.15.0`). This combination provides type-safe database access with SQLite-compatible storage. The schema definitions in [`packages/core/src/db/schema.ts`](https://github.com/BuilderIO/agent-native/blob/main/packages/core/src/db/schema.ts) establish tables for application state, resources, and agent memory using these dependencies.

### UI Component Primitives

The interface layer builds on **React 19** (`^19.2.7`) and **Radix UI** primitives for accessible components. **Assistant UI** (`@assistant-ui/react` at `^0.12.19`) provides chat-specific interface elements, while **TipTap** (`@tiptap/*` at `3.27.1`) powers rich text editing capabilities. Routing is handled by **React Router** (`@react-router/dev` at `^8.1.0`), and theming uses `next-themes` (`^0.4.6`).

```json
{
  "@assistant-ui/react": "^0.12.19",
  "@radix-ui/react-dialog": "1.1.15",
  "@radix-ui/react-dropdown-menu": "^2.1.16",
  "@tanstack/react-table": "^8.21.3",
  "react": "^19.2.7",
  "react-dom": "^19.2.7",
  "zod": "^4.3.6"
}

```

**Zod** (`^4.3.6`) serves as the schema validation library throughout, ensuring type safety for actions, inputs, and configurations across the framework.

## Workspace Package Dependencies

Beyond the core, the monorepo contains specialized packages that depend on `@agent-native/core` while adding platform-specific functionality.

### Toolkit and Development Utilities

The `packages/toolkit` directory contains helper utilities that extend the core runtime. It depends on `@agent-native/core` as a workspace package while integrating **AI SDK** providers (`@ai-sdk/*`), **OpenRouter** (`@openrouter/ai-sdk-provider`), and development tools like **Drizzle Kit**, **Vite**, and **TailwindCSS**. These tools facilitate building, deploying, and styling agent-native applications.

### Platform-Specific Packages

Builder.io Agent Native targets multiple platforms through dedicated packages:

- **Mobile App** (`packages/mobile-app`): Depends on `react-native` and **Expo** for iOS/Android deployment
- **Desktop App** (`packages/desktop-app`): Uses **Electron** alongside standard React dependencies for cross-platform desktop applications  
- **VS Code Extension** (`packages/vscode-extension`): Integrates with the **VS Code API** (`vscode`) and TypeScript for editor extensions
- **Dispatch** (`packages/dispatch`): Server-side layer using **Hono** (`>=4.12.4`) for API routing and `dotenv` for environment management
- **Scheduling** (`packages/scheduling`): Implements cron-style jobs using `cron-parser` for automated task execution
- **Pinpoint** (`packages/pinpoint`): Analytics integration using **Amplitude** (`@amplitude/analytics-browser`)

## Key Implementation Patterns

Understanding the dependency structure reveals how components interact with the core runtime through specific import paths and hooks.

### Consuming Actions in React Components

The `useActionQuery` hook exported from `@agent-native/core/client` enables React components to call server-defined actions. Located in [`packages/core/src/client/hooks/useActionQuery.ts`](https://github.com/BuilderIO/agent-native/blob/main/packages/core/src/client/hooks/useActionQuery.ts), this hook manages loading states and data fetching for agent operations.

```tsx
import { useActionQuery } from '@agent-native/core/client';

export function DocumentList() {
  const { data, isLoading } = useActionQuery('list-documents');
  if (isLoading) return <div>Loading…</div>;
  return (
    <ul>
      {data?.map((doc) => (
        <li key={doc.id}>{doc.title}</li>
      ))}
    </ul>
  );
}

```

### Defining Server-Side Actions

Server actions are defined using the `defineAction` helper from [`packages/core/src/action/defineAction.ts`](https://github.com/BuilderIO/agent-native/blob/main/packages/core/src/action/defineAction.ts). This utility, imported via `@agent-native/core/action`, provides type-safe action definitions with Zod validation and database access.

```ts
import { defineAction } from '@agent-native/core/action';
import { z } from 'zod';

export const createTask = defineAction({
  name: 'create-task',
  input: z.object({ title: z.string() }),
  async resolve({ input, db }) {
    const task = await db.insertInto('tasks').values(input).execute();
    return { taskId: task.id };
  },
});

```

### Embedding the Agent Panel

For non-React contexts or static HTML, the `AgentPanel` class from `./client/AgentPanel` can be imported directly from a CDN. The embedding bridge in [`packages/core/src/embedding/bridge.ts`](https://github.com/BuilderIO/agent-native/blob/main/packages/core/src/embedding/bridge.ts) handles communication between the host page and the embedded UI.

```html
<script type="module">
  import { AgentPanel } from 'https://cdn.jsdelivr.net/npm/@agent-native/core/client/AgentPanel.js';

  const panel = new AgentPanel({
    container: document.body,
    agentId: 'my-app',
  });
  panel.mount();
</script>

```

## Summary

- **Core runtime** (`@agent-native/core`) bundles React 19, Radix UI, Assistant UI, Anthropic SDK, Drizzle ORM, and Zod for the complete agent-native development environment
- **Workspace dependencies** follow a pattern where specialized packages (toolkit, dispatch, scheduling) import `@agent-native/core` and add platform-specific tools like Electron, React Native, or Hono
- **Key source files** include [`packages/core/src/action/defineAction.ts`](https://github.com/BuilderIO/agent-native/blob/main/packages/core/src/action/defineAction.ts) for action definitions and [`packages/core/src/client/hooks/useActionQuery.ts`](https://github.com/BuilderIO/agent-native/blob/main/packages/core/src/client/hooks/useActionQuery.ts) for React integration
- **Schema validation** uses Zod 4.x throughout the monorepo for type-safe configurations and API contracts

## Frequently Asked Questions

### What is the main entry point for Builder.io Agent Native dependencies?

The primary dependency hub is `@agent-native/core`, located in [`packages/core/package.json`](https://github.com/BuilderIO/agent-native/blob/main/packages/core/package.json). This package contains all essential runtime dependencies including React, AI SDKs, database libraries, and UI primitives. Other packages in the monorepo declare `@agent-native/core` as a workspace dependency and layer additional functionality on top.

### How does the core package handle database operations?

Database operations rely on **Drizzle ORM** paired with **libSQL** client libraries. The schema is defined in [`packages/core/src/db/schema.ts`](https://github.com/BuilderIO/agent-native/blob/main/packages/core/src/db/schema.ts), providing type-safe SQL operations for application state, resources, and agent memory. This architecture supports SQLite-compatible storage with full TypeScript inference.

### Can I use Builder.io Agent Native without React?

While the core package heavily utilizes React 19 and React Router for its UI layer, the framework exposes embedding capabilities through the `AgentPanel` class. This allows integration into vanilla JavaScript or HTML environments by importing from the CDN bundle, though the underlying dependencies still include React for component rendering.

### What AI providers are supported by the default dependencies?

The core package ships with **Anthropic's SDK** (`@anthropic-ai/sdk`) and the **Model Context Protocol** SDK for Claude integration. For additional providers like OpenAI or OpenRouter, the `packages/toolkit` includes `@ai-sdk/*` packages and `@openrouter/ai-sdk-provider`, though these require explicit integration in your application code.