Why Aelio?

The problem

Every platform eventually needs a conversational interface for its customers — support chat, order tracking, self-service actions. Building this from scratch means:

Integrating an LLM and managing prompts
Building a chat interface with reconnect and history
Wiring messaging channels
Implementing safety rails (confirm before cancel/delete)
Building per-customer memory across sessions
Handling identity across chat interfaces
Deploying and scaling chat infrastructure

This takes months and a dedicated team. Most platforms either skip it or ship a basic chatbot that can't actually do anything.

Who solves what today

Tool category	Solves	Doesn't solve
OpenAPI → MCP (Claude Desktop, Cursor)	Developer calls APIs from AI IDE	End-customer chat on a chat interface
Chatbot builders (Intercom, Drift)	Support chat UI	Real backend tool execution
LLM frameworks (LangChain, CrewAI)	Agent orchestration	Production channels, safety, memory
Voice AI (Vapi, Bland)	Phone calls	Text chat, platform tool integration

Nobody owns the platform-to-end-customer conversational layer with real backend integration, safety, memory, and multi-channel delivery.

What Aelio solves

Need	How Aelio solves it
End user is a customer, not a developer	Chat interface channels with identity resolution
Interaction on your preferred chat interface	Built-in channel adapters + BYO provider hooks
Identity, session, safety	Lifecycle states, read/write/destructive gates, confirmations
Persistent user understanding	Analytical agent + vector memory (not just turn-by-turn)
Real backend actions	SDK exposes your actual functions — not API docs
No credential sharing	SDK dials out; your auth/DB stay in your process
Fast integration	One SDK install, one YAML, one container — under 30 minutes

Key differentiators

SDK dials out (not webhooks in)

Your backend opens one WebSocket to Aelio. No inbound ports, no firewall changes, no webhook URLs to configure. Your API keys and database credentials never leave your process.

Functions, not API docs

You expose real handler functions with aelio.expose(). The LLM calls them with typed parameters. No OpenAPI ingestion, no schema drift, no hallucinated endpoints.

Two agents, one system

The conversational agent handles real-time chat. The analytical agent builds persistent customer intelligence in the background. Memory is core, not an optional bolt-on.

Production safety

Read/write/destructive safety levels. Write actions require explicit user confirmation. Lifecycle states gate which tools are available. Built into every turn.

Single-container deployment

One Docker image (~190MB). SQLite embedded. No Redis, no separate vector DB, no Kafka. Self-host on any cloud or run locally.

Open source

Apache-2.0 intent. No vendor lock-in. Inspect, modify, and self-host everything.

When to use Aelio

Use Aelio when

Your customers need to ask questions and take actions via chat
You want a chat interface from one integration
You have existing backend logic you want to expose conversationally
You need safety rails and memory without building them
You want to ship in days, not months

Consider alternatives when

You only need a static FAQ chatbot with no backend actions
You need voice/telephony (not Aelio's focus in V1)
You want a no-code chatbot builder with a visual flow editor
Your use case is developer-to-AI-agent (use MCP instead)

The integration promise

// This is the entire integration for most platforms:
import { aelio } from '@aelio/sdk';

aelio.expose('getOrderStatus', handler, { safety: 'read', ... });
aelio.expose('cancelOrder', handler, { safety: 'write', ... });

await aelio.listen({ secret: process.env.AELIO_SDK_SECRET });

Plus a script tag for the widget. That's it.