Get started
Concepts
Daguito is a multi-tenant, voice-first conversational AI platform built on a flow engine. Before you build your first agent, it helps to understand the pieces: how a message comes in, how a flow runs, and where each piece of data lives. This page is that map.
Key Daguito concepts
Before diving deeper, it's important to understand the terms we use on the platform:
The instructions that define your agent's behavior. It's how you explain to the model what it should do, how to speak, and what rules to follow. In Daguito, it's configured as "System prompt" in the AI agent node.
The state your agent keeps during the conversation. It includes the data the user provided (facts), message history, working variables, and persistent state across flow branches. Do not confuse with the Knowledge Base, which is the information the agent queries from your uploaded documents.
Actions the agent can execute to interact with the real world: call APIs, search your knowledge base, process payments, send emails. These are the agent's "arms".
The event that starts a flow. It can be a WhatsApp message, an external webhook, a scheduled task, or a manual action. It's the "entry point" of every conversation.
Each block in your visual flow. Nodes are the computing units: some use AI (agents), others have no AI autonomy (actions, decisions, transformations). They connect to each other to create behavior.
The complete flow of connected nodes that defines your agent's behavior. It's like a map: the user enters through a trigger and traverses different nodes until completing their task.
Your repository of documents and information. The agent searches here to respond with precise and up-to-date context.
The surface where your user interacts: web widget, WhatsApp, Instagram, voice, API. The same agent can serve multiple channels without changing its behavior.
Triggers
A trigger is the input that a node receives to activate it. When an event arrives — a WhatsApp message, an audio, an HTTP call — the node wakes up, uses its prompt, checks its memory, and responds with an output. Without a trigger, the node does nothing.
Ejemplo: mensaje desde WhatsApp
// Qué llega cuando un cliente escribe por WhatsApp
{
kind: 'message',
channel: 'whatsapp',
text: '¿Cuánto vale?',
sender: { id: '...' },
session_key: '...'
}Ver todos los triggers y ejemplos →
Messages: Normalized Payloads
It doesn't matter if the message comes from WhatsApp, the widget, or voice — it's always processed the same way. One flow handles all channels with no per-channel code.
Each message has a type (kind) that defines what data it carries. There are seven:
How the agent responds: Streaming vs Oneshot
When the AI assistant generates a reply, it can deliver it in two different ways. Choosing the right one depends on the channel where you're publishing your agent:
- Real-Time Delivery (Streaming): The reply is sent word by word as it's generated — like watching someone type live. The customer doesn't wait for every word to finish before reading the first one. Ideal for web chat and your store's widget.
- Complete Reply (Oneshot): The AI generates the whole reply internally and sends it in a single block when it's done. The customer receives the full message all at once. Required for WhatsApp and Instagram, which don't support real-time messages.
Channels: Inbound Surfaces
A channel is every surface a message can enter through. The enum lists them all: adding a new channel starts by adding it here and then building its adapter.
Flows: Orchestration Graphs
A flow is a directed acyclic graph (DAG) of nodes connected by typed edges. It is Daguito's executable unit: in Daguito we always say "flow" — never "workflow" or any other name.
Nodes: Computation Units
Every node in a flow is a self-contained computation unit. They all receive the same context and return the same result type. There are three canonical roles: agent (AI with autonomy), node without AI (fixed, predictable task), and trigger (the entry point). The key distinction between agent and node without AI is not whether they use AI, but whether the model has autonomy to decide what to do.
Knowledge Base
Knowledge Base is the database your agent queries before answering: catalogs, PDFs, policies, or FAQs. It is independent from conversation Memory — memory stores the chat history, Knowledge stores your documents. Daguito combines semantic vector search with a retrieval pipeline, all isolated per organization.
Message Coalescing
When a user sends three messages in five seconds, you don't want three agent turns — you want one with everything together. Coalescing groups those inbound messages before enqueueing them to the flow.
- Every channel (widget, WhatsApp, webhook) goes through the same ingest pipeline and uses the same coalescing function.
- It prevents redundant turns, lowers LLM cost, and improves conversational-UI latency.