Real infrastructure ships with docs.

Quickstart — answer your first call in 5 minutes

On Anuvo Cloud, your first call is answered five minutes after you create an agent — point a number at it and go. On Resident, plan a deployment with the architecture planner first.

Cloud, in three steps

1. Create an agent — name it, set languages and the knowledge base (your FAQs, timings, booking rules).
2. Attach a number — bring your own number (port it or set a forward) or request one. SIP trunking or PSTN forwarding, both supported.
3. Call it. The agent answers on the first ring, in under 400 ms, barge-in aware.

Resident, in one paragraph

Resident ships as a packaged stack — a single appliance for most sites or a Helm chart into an existing cluster. The runtime contains STT, orchestration and TTS in-process; your PBX routes calls to it over SIP; it writes bookings and audits into your own systems. Measured: 355 ms, inside your network.

# Create an agent (Cloud)
curl -X POST https://api.anuvo.ai/v1/agents \
  -H "Authorization: Bearer $ANUVO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Front Desk",
    "languages": ["en-IN", "hi-IN"],
    "knowledge_base": "kb_front_desk_v1",
    "barge_in": true,
    "latency_budget_ms": 400
  }'

Cloud vs Resident

Both editions run the same agent with the same measured behaviour; they differ only in where inference runs and how you are billed.

If your compliance policy forbids patient or client audio leaving your network, Resident is the edition that fits the rule. Otherwise Cloud gets you live fastest. Moving later is a reconfiguration, not a rebuild.

Phone number & SIP setup

Anuvo connects over PSTN forwarding or SIP trunking; you keep your existing number in both cases.

• PSTN forwarding — forward your existing number to the Anuvo ingress. Fastest to live; works with any provider.
• SIP trunk — for Resident, your PBX/SBC routes calls to the Resident media server over SIP inside your network. No phone system replacement.
• Porting — we can help port a number to a carrier with direct SIP, if you want one less hop.

On Cloud, choose the region your calls terminate in — region choice affects the last hop of latency more than anything else.

The latency budget

Anuvo enforces a 400 ms end-to-end budget from call connect to first useful response; the measured p50 is 350 ms on Cloud and 355 ms on Resident.

The budget is a product decision, not a benchmark boast. Callers judge you in the first second of silence — above 400 ms a caller perceives the agent as slow or broken. The runtime enforces the budget per turn: recognition, understanding and synthesis run as a streaming pipeline, and the first response is generated from partial transcripts rather than waiting for silence.

What is on the critical path: media ingress, STT, intent, TTS, media egress. What is not: integrations. Booking and HIS writes run post-answer so a slow API never adds to the caller's wait. The full method and caveats are on the latency page.

Barge-in

Callers can interrupt Anuvo mid-sentence at any point, and the agent recovers instantly — no dead air, no "I didn't catch that".

Barge-in is the power-user signal of voice AI: technical buyers test it in the first call. Anuvo detects interruption within the media pipeline and yields the turn immediately; the interrupted utterance is re-interpreted in context. Recovery latency is part of the measured budget — you can test it yourself on the demo line.

{
  "barge_in": true,
  "barge_in_sensitivity": "normal",
  "recovery": "contextual"   // re-interpret in context, not restart
}

Multilingual lines

Anuvo is multilingual including Indian languages — English, Hindi and regional languages configured per line, so a single number can serve many callers.

Language is set per line, not per agent: a hospital front-desk number can answer in English, switch to Hindi on request, and serve regional languages the caller actually speaks. Detection and synthesis run inside the same latency budget; there is no translation hop.

"languages": ["en-IN", "hi-IN", "te-IN", "ta-IN"]

Data residency

On Anuvo Resident, call audio never leaves your network: no third-party model dependency, no data egress, no per-minute API fee.

Resident makes no outbound calls that carry audio. Recognition, orchestration, synthesis, transcripts and the audit log all resolve inside your boundary. The optional Cloud relay is metadata-only — dashboards and fleet analytics, never audio, never transcripts unless you explicitly opt in. See the security page for the architecture diagram and controls.

Authentication

All API requests authenticate with a bearer token; tokens are scoped to roles and can be rotated without downtime.

Authorization: Bearer $ANUVO_API_KEY

Tokens are issued per role — operator, supervisor, auditor — and every token's usage lands in the audit log. Rotate via POST /v1/tokens/rotate; old tokens expire within 5 minutes of rotation. On Resident, tokens and keys are managed on your infrastructure.

POST /v1/agents

Create or update a voice agent — languages, knowledge base, barge-in, latency budget, escalation rules.

curl -X POST https://api.anuvo.ai/v1/agents \
  -H "Authorization: Bearer $ANUVO_API_KEY" \
  -d '{
    "name": "Front Desk",
    "languages": ["en-IN", "hi-IN"],
    "knowledge_base": "kb_front_desk_v1",
    "barge_in": true,
    "latency_budget_ms": 400,
    "escalation": { "mode": "warm_transfer", "number": "+911234567890" }
  }'

POST /v1/calls

Trigger an outbound call or query call state, transcripts and recordings.

# Fetch a call's transcript + status
curl https://api.anuvo.ai/v1/calls/{call_id} \
  -H "Authorization: Bearer $ANUVO_API_KEY"

GET /v1/audit

Every call, action and token usage is in the audit log — queryable and exportable, and on Resident it never leaves your network.

curl "https://api.anuvo.ai/v1/audit?from=2026-08-01&role=operator" \
  -H "Authorization: Bearer $ANUVO_API_KEY"

Entries are append-only and tamper-evident (hash-chained). Filter by time, role, agent or call. Export as JSON or CSV for your compliance team.

Crux-Voice Engine Architecture — CruxLabx Technologies

Anuvo is powered exclusively by the Crux-Voice Engine, engineered by CruxLabx Technologies Pvt Ltd for ultra-low latency, enterprise telephony, and complete sovereign data isolation.

Core Engine Specifications

• Latency Budget: Sub-400 ms measured round-trip audio turnaround (350 ms Cloud / 355 ms Resident on-premise).
• Transport & Telephony: Direct LiveKit WebRTC media transport, native SIP trunking (Kamailio / FreeSWITCH / Asterisk), and Twilio/Telnyx media streams.
• Multilingual Speech Pipeline: Streaming neural ASR + Native Audio LLM orchestration + low-latency TTS tuned for Indian dialects (English-IN, Tamil, Hindi, Telugu, Odia).
• Sovereign On-Premise Stack: Single-binary or Helm deployment running STT, LLM inference, and TTS inside the customer boundary — 0 bytes of audio leave the facility.
• Enterprise Integrations: Instant read/write access to hospital HIS/EHR, appointment booking calendars, and CRMs over secure internal APIs.

# Crux-Voice Engine Integration (CruxLabx Technologies)
from cruxlabx.voice import CruxVoiceEngine, CallSession

engine = CruxVoiceEngine(
    model="crux-voice-v2",
    transport="webrtc",
    sample_rate=24000,
    residency="on_premise"  # 0 bytes audio egress
)

@engine.on_call
async def handle_inbound(call: CallSession):
    await call.answer(persona="Hospital Front Desk", languages=["en-IN", "ta-IN", "hi-IN"])

Webhooks & events

Anuvo fires webhooks for the events that matter — booking confirmed, call escalated, outbound follow-up scheduled.

{
  "event": "booking.confirmed",
  "call_id": "call_8f2a",
  "payload": {
    "department": "cardiology",
    "appointment_at": "2026-08-14T09:30:00+05:30",
    "patient": { "phone": "+919876543210", "language": "hi-IN" }
  }
}

Events are delivered with retries and an idempotency key; integrations should be safe to replay. Signature verification: X-Anuvo-Signature: HMAC-SHA256(body, secret).

SDKs

Official SDKs for Node.js and Python wrap the full REST API; anything else can use the documented HTTP endpoints directly.

# Node.js
import { Anuvo } from "@anuvo/sdk";
const anuvo = new Anuvo({ apiKey: process.env.ANUVO_API_KEY });

# Python
from anuvo import Anuvo
anuvo = Anuvo(api_key=os.environ["ANUVO_API_KEY"])

SDKs cover agents, calls, webhooks and audit, with typed responses and automatic retry/backoff. TypeScript types ship with the Node SDK.

Security & compliance

Anuvo encrypts in transit and at rest, enforces RBAC, records with consent, and on Resident keeps everything inside your network.

• Encryption: TLS 1.3 in transit; AES-256 at rest for recordings and transcripts. On Resident, keys live on your infrastructure.
• Consent: configurable announcement-and-consent flow per line; recordings are consent-gated.
• Retention: retention windows, deletion and export under your administration.
• RBAC: operator / supervisor / auditor roles, least privilege, full audit trail.
• Residency: Resident has no audio egress — relevant to DPDP-aligned and healthcare data policies.

Full detail on the security & data residency page.