How it works
What actually happens inside a turn — retrieval, memory, tools, context, channels, and what stays private.
Grounded answers
How a document becomes something an agent can answer from — chunking, the context header, query rewriting, and the relevance floor.
Per-customer memory
How conversations become durable facts about a customer — derivation, deduplication, importance, and what gets recalled.
Tools and MCP
How an agent goes from answering to acting — the tool loop, context budgets, and connecting your own systems over MCP.
How typing "research it" works
A visitor who types a request should get the same thing as a visitor who picks it from the menu. Doing that with a keyword list fails in seven languages; doing it with a model on every message is slow and expensive. What we measured, why the router is two steps, and how the same sentence routes differently when a document is open.
Why agents get worse as context grows
Context rot, in concrete terms. Every turn is one self-contained request to the model; a long or tool-heavy one measurably lowers the accuracy of the answer. What that request contains, what gets dropped when it does not fit, and why the platform re-renders it before writing the answer instead of summarising tool results.
Where a conversation lives between turns
If every turn is one self-contained request, where does the rest of the conversation sit? What gets stored per turn and what never does, the verbatim window, how older turns are folded into a rolling summary exactly once, what happens when a single turn still overflows, and which facts outlive the session.
One agent, every channel
How the web widget, Telegram and WhatsApp reach the same agent with the same memory — identity resolution, the shared control flow, and what stays channel-specific.
Scheduled follow-ups
How an agent schedules work for later and delivers the result back to the channel it came from — durable tasks, atomic claiming, and recovery.
Private by design
Isolation enforced in the database, field-level encryption with per-user keys, and an honest account of what the end-to-end layer does and does not give you.
Running on open models
How the model layer stays separate from the agent layer — capability probing, multi-backend routing, and the four ways small open models break on tool calls that the gateway handles for you.
How a long document actually gets written
A forty-page report is not one long reply. It is a background job with a state machine — outline, questions, research, section-by-section writing — where every step can be re-run after a crash without duplicating work or losing budget, offsets for edits are computed by code rather than chosen by the model, and every version is kept.
Charts in the answer
When an answer contains a set of comparable numbers, the agent draws it — unprompted, mid-conversation. Nine chart types with a worked example of each, the containment gate that refuses a chart whose numbers are not in your material, and why derived figures are computed in code rather than by the model.
Watching a source over months
Continuous monitoring — the agent researches which pages to watch, you confirm, and it reports only what actually changed and actually matters to you.
Researching an answer it does not have
Deep research — one question becomes several ordered searches, every claim carries the source it came from, and anything the search did not establish is refused rather than filled in from memory.
Skills and how one gets chosen
How a capability pack reaches the model — the shared platform library, retrieval by intent, tools that arrive only with the procedure, and asking back when the request is ambiguous.
Checks on the answer
The checks that run on a finished answer before it is sent — what each one catches, how often it fires, and why a check that fires often is a bug rather than a feature.