> ## Documentation Index
> Fetch the complete documentation index at: https://docs.zavu.dev/llms.txt
> Use this file to discover all available pages before exploring further.

# Introduction to Zavu

> Build and deploy AI agents that answer on WhatsApp, SMS, voice, email, Telegram and Messenger. One API, one webhook contract, one bill.

## What Zavu is

Zavu is the communication layer for humans and agents.

You get two things, and they are the same platform:

* **An API for messages.** Send and receive on WhatsApp, SMS, voice, email,
  Telegram, Instagram and Messenger through one integration.
* **A runtime for agents.** Declare an agent in TypeScript, deploy it with one
  command, and it answers on those same channels. Including phone calls.

Most teams start with one and end up using both. The agent that answers a
WhatsApp thread is the same object that answers the phone, and the message you
send by hand goes out the same pipe.

## Two ways to build

There is no wrong entry point. Pick the one that matches where your code lives.

<CardGroup cols={2}>
  <Card title="Deploy on our infra" icon="cloud-upload" href="/quickstart">
    Write `defineAgent` and `defineTool` in a file, run `npx zavudev deploy`.
    Zavu runs the code, holds the conversation, and calls your tools.
  </Card>

  <Card title="Call our API from yours" icon="code" href="/quickstart-messaging">
    Keep your stack. Use the REST API or an SDK to send, receive, and drive
    conversations from your own backend.
  </Card>
</CardGroup>

## Ship an agent

```ts theme={null}
import { defineAgent, defineTool } from "@zavudev/functions"

defineAgent({
  senderId: process.env.SENDER_ID!,
  name: "Bella",
  provider: "zavu",
  model: "openai/gpt-4o-mini",
  prompt: "You are Bella, host at the pizzeria. Keep it short.",
  channels: ["whatsapp"],
})

defineTool({
  name: "check_availability",
  description: "Get free reservation slots for a date and party size.",
  parameters: {
    type: "object",
    properties: {
      date: { type: "string" },
      partySize: { type: "number" },
    },
    required: ["date", "partySize"],
  },
  handler: async ({ date, partySize }) => {
    // your real booking logic: DB, POS, external API, whatever
    return { available: true, slots: ["19:00", "21:00"] }
  },
})
```

```bash theme={null}
npx zavudev deploy
```

Your code is the source of truth. Every deploy reconciles the live agent to
match what the file declares, so an agent you delete from the code is deleted
for real. See [How agents work](/concepts/agent-architecture).

Not starting from scratch? `npx zavudev agents pull fermi` drops a ready-made
agent into your project as editable code. Seven of them ship today, for sales,
support, and front desk. See [Factory agents](/guides/functions/factory-agents).

## Send a message

```typescript theme={null}
import Zavudev from '@zavudev/sdk';

const zavu = new Zavudev();

await zavu.messages.send({
  to: "+14155551234",
  text: "Your order #1234 has shipped!"
});
```

No channel specified means `auto`: Zavu scores the channels your sender can
reach the recipient on and sends through the one that wins on cost and
deliverability, with fallback if it fails. See
[Smart routing](/guides/sending-messages/smart-routing).

## Channels

| Channel       | Best for                                               | Agents |
| ------------- | ------------------------------------------------------ | ------ |
| **WhatsApp**  | Rich media, templates, high engagement                 | Yes    |
| **SMS**       | Universal reach, alerts, OTP, no internet required     | Yes    |
| **Voice**     | Two-way phone calls, text-to-speech alerts             | Yes    |
| **Email**     | Transactional and marketing mail, attachments, replies | Yes    |
| **Telegram**  | Bot messaging, large file sharing                      | Yes    |
| **Messenger** | Facebook Page and Marketplace conversations            | Yes    |
| **Instagram** | Direct messages on a Business account                  | Yes    |

Every channel shares one send contract, one set of
[webhook events](/guides/receiving-messages/events), and one bill.

## Build with your coding agent

Zavu is designed to be operated by the agent you already code with. Give it the
skills and it writes correct Zavu code on the first try, instead of guessing at
endpoints.

```bash theme={null}
npx skills add zavudev/zavu-skills
```

Twelve skills cover agents, functions, voice, channels, webhooks, templates,
broadcasts, contacts and phone numbers. For direct API execution, add the
[MCP server](/tools/mcp-server). They compose: skills decide what to do, MCP
does it.

## Next steps

<CardGroup cols={2}>
  <Card title="Agent quickstart" icon="rocket" href="/quickstart">
    Deploy an agent that answers a real channel, in about ten minutes
  </Card>

  <Card title="Messaging quickstart" icon="send" href="/quickstart-messaging">
    Send your first message from your own backend
  </Card>

  <Card title="How agents work" icon="sitemap" href="/concepts/agent-architecture">
    From TypeScript on your machine to an agent answering a phone call
  </Card>

  <Card title="CLI" icon="terminal" href="/guides/cli/overview">
    Every resource in the API, from your shell and your CI
  </Card>

  <Card title="Authentication" icon="key" href="/authentication">
    API keys, environments, and the sender header
  </Card>

  <Card title="API reference" icon="code" href="/api-reference">
    Every endpoint, with a live playground
  </Card>
</CardGroup>