---
title: 'Your Sautikit number can now answer itself: managed AI agents are live'
description: >-
  Managed AI agents now answer inbound calls on your Sautikit number — always or
  after hours — with tools, handover summaries, and full transcripts.
summary: >-
  Launch: bind a published AI agent to your Sautikit number and it answers
  callers in real time — interruptible, tool-calling, with a handover that
  briefs your team. The same agents dial broadcasts.
date: 2026-07-21T00:00:00.000Z
type: blog
---


## Summary

Starting today, any number on Sautikit can be answered by a managed AI agent. You write a prompt, publish the agent, and bind it to your number — every call, or only the ones that arrive after your team goes home. The agent holds a real conversation: callers can interrupt it, it can call your API mid-sentence to look things up, and when it decides a human is needed it hands the call over with a written summary of everything said so far. Broadcasts point the same agents outward, dialling whole campaign lists as live conversations. No servers, no audio plumbing, no model wrangling. Three API calls and your number answers itself.

## The call you didn't answer

Every business number has a shadow ledger. The customer who called at 7:40 pm and got nothing. The one who rang during the Monday rush, heard it ring out, and tried your competitor instead. Missed calls do not show up in a dashboard as lost revenue — they show up as silence, which is why they are so easy to ignore.

The fix has existed for a while if you were willing to build it: fork the call audio over a WebSocket, run your own speech models, stitch the conversation together, keep it all alive at telephone latency. Some of our customers built exactly that on Sautikit's `Stream` verb, and it works. But it is a project — weeks of engineering before the first caller hears anything — and most teams with a ringing, unanswered phone do not have weeks.

So we built the managed version. The conversation loop, the voices, the barge-in handling, the tool calling, the transfer logic — all of it runs inside Sautikit. What is left for you is the part only you can do: describe the job.

## Create an agent

An agent is a prompt with a phone-shaped body. Give it a name, a brief, a model from the Sautikit catalog (`GET /v1/models` — ids like `sautikit-flash`), a voice, and a hard cap on call length:

```js
const res = await fetch("https://api.sautikit.com/v1/agents", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.SAUTIKIT_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    name: "After-hours desk",
    base_prompt:
      "You answer for Wema Dental in Nairobi. Book and reschedule appointments, answer questions about services and prices, and take a message with a callback number for anything clinical. Hand over to a human if the caller asks or if it is an emergency.",
    model: "sautikit-flash",
    voice: "Woman",
    max_call_minutes: 10,
  }),
});

const agent = await res.json();
```

Then publish it. Publishing freezes a revision — the thing that actually answers calls — so you can keep editing the draft while yesterday's version works the phones.

## Bind your number

One call to the routing endpoint puts the agent on the line. The example below is the configuration most teams start with: humans answer during business hours, the agent takes everything else.

```js
await fetch(`https://api.sautikit.com/v1/numbers/${NUMBER_ID}/routing`, {
  method: "PUT",
  headers: {
    Authorization: `Bearer ${process.env.SAUTIKIT_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    inbound_agent: {
      enabled: true,
      agent_id: agent.id,
      mode: "after_hours",
      schedule: {
        timezone: "Africa/Nairobi",
        hours: [{ days: [1, 2, 3, 4, 5], start: "08:00", end: "17:30" }],
      },
      handover_callback_url: "https://example.com/voice",
    },
  }),
});
```

A call at 11 am on Tuesday reaches your team exactly as before. A call at 9 pm — or on Sunday — reaches the agent. Switch `mode` to `"always"` and the agent takes every call. And the failure path is deliberately boring: if the agent is unpublished or no AI seat is free, the call falls through to your normal routing. Callers never hear an error because of us.

## What happens when it rings

The part that makes this feel like a receptionist rather than an IVR with ambitions is the conversation itself. It runs in real time and it is interruptible — a caller who cuts in with "actually, Thursday works better" is heard mid-sentence, and the agent stops and adjusts, the way a person would.

Agents also act, not just talk. You can attach HTTP tools to an agent — your endpoints, described with JSON Schema, every request HMAC-signed so your API can verify who is calling. Mid-conversation, "what time is my appointment?" becomes a signed lookup against your booking system and a spoken answer in the same breath. Order status, account balances, CRM writes, reschedules: if you can put it behind an endpoint, your agent can do it on a call.

And when the conversation needs a human, the handover is the feature we are proudest of. The agent does not dump the caller into a queue. Sautikit POSTs a `CallHandover` request to your callback URL carrying the agent's reason and a summary of the conversation so far — who is calling, what they want, what has already been established. You respond with ordinary JSON voice actions:

```json
{
  "actions": [
    { "say": { "text": "Let me get someone from the team." } },
    { "dial": { "number": "+254720000010" } }
  ]
}
```

Your teammate picks up a call that arrives pre-briefed. The caller repeats nothing. That one detail is the difference between AI that deflects customers and AI that serves them.

## Every call, on the record

Calls answered by an agent are recorded by default, and each one produces a per-turn transcript: `GET /v1/calls/{id}?transcript=1` returns who said what and when, where the caller interrupted, and every tool call the agent made with its arguments. In week one, read the transcripts. You will find the question you forgot to put in the prompt, fix the draft, publish a new revision, and the next call is better. It is the shortest QA loop we know of for a phone line.

## The same agents, dialling out

Answering is half the story. [Broadcasts](/broadcasts) point a published agent at a contact list and dial outbound campaigns — payment reminders, appointment confirmations, renewal calls — as real conversations, personalised per contact with `{{variable}}` placeholders, paced inside calling windows you define, with retries for the people who did not pick up. Voicemail is detected and retried, never talked at.

```js
await fetch("https://api.sautikit.com/v1/broadcasts", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.SAUTIKIT_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    name: "July payment reminders",
    agent_id: agent.id,
    prompt_template:
      "Remind {{name}} their instalment of KES {{amount}} is due {{due_date}}. Capture a promise-to-pay date if they cannot pay now.",
    start_phrase: "Hello, this is Wema Credit with a reminder about your account.",
    schedule_days: [1, 2, 3, 4, 5],
    daily_start_minute: 540,
    daily_end_minute: 1020,
    timezone: "Africa/Nairobi",
    max_attempts: 3,
    backoff_minutes: 120,
    retry_on: ["no_answer", "busy", "voicemail"],
  }),
});
```

Load contacts, `/start`, and pull `report.csv` when it finishes for per-contact outcomes. That is the positioning in one line: broadcasts for outbound, AI agents for inbound — one agent definition, both directions.

If you would rather talk than code, the hosted [Sautikit MCP server](/mcp) exposes the whole stack — `create_agent`, `publish_agent`, `update_number_routing`, `create_broadcast` — so an AI assistant like Claude can stand up your receptionist and launch your campaign from a conversation.

## What it costs

AI time is KES 4.00 per minute, metered per second, on top of the standard per-second call rates — a 90-second answered call bills 90 seconds, not two rounded-up minutes. The free tier includes 1 concurrent AI call, enough to run a real after-hours line tonight; paid tiers raise concurrency to 5, 8, or 10. A dedicated number is KES 116 per month, claimed instantly. Everything draws on the prepaid wallet, topped up via M-Pesa, so the worst case of any experiment is the balance you loaded — and every agent call is hard-capped by `max_call_minutes`.

## Start tonight

The next call your business misses is optional.

- Read what agents can do on [/ai-agents](/ai-agents), and what campaigns look like on [/broadcasts](/broadcasts).
- Follow the guide: [Route inbound calls to an AI agent](/developers/guides/route-inbound-calls-to-an-ai-agent) — binding, schedules, and the full handover contract.
- Or just sign in at [app.sautikit.com](https://app.sautikit.com/login), open your number, and turn the agent on. Your number is about to learn to answer itself.