Core concepts

cove1 is an AI customer service system. The product is an AI customer-support agent: you design the agent's logic on a visual canvas, ground it in your own knowledge base, connect every channel your customers already use, and run the whole operation from one console — delivered for your business, on OpenAI-compatible models.

This page defines the core concepts you'll work with. Each one maps to a part of the system, and understanding how they connect is the fastest way to get productive.

Under the hood, cove1 combines a conversation engine — channels, the shared inbox, agent assignment, and the customer-facing widgets — with an agent runtime and knowledge layer that handle the visual flow, retrieval, and model orchestration. A single modern console sits on top and presents them as one product.

Agent

An agent is a configured unit of automation that handles conversations on your behalf. It has a purpose (for example, "answer product and billing questions for the storefront"), a knowledge base it can draw on, a model that powers its reasoning, and a flow that defines how it moves from an incoming message to a reply.

An agent is not a single prompt. It's a small program you assemble on the canvas: it receives a message, decides what the customer wants, retrieves relevant facts, reasons over them, and then either answers or hands off to a person. You can run more than one agent — a different agent per brand, per language, or per channel — and each keeps its own knowledge and configuration.

Two properties matter most when you design an agent:

• Scope. What the agent is allowed to answer, and what it should escalate. A tightly scoped agent is more reliable than one asked to know everything.
• Grounding. Where its answers come from. An agent that answers only from its knowledge base — and says so with citations — is one you can trust in front of customers.

Visual canvas

The visual canvas is where you build an agent's logic. Instead of hiding behavior inside code, you lay it out as a flow of connected nodes, each doing one job. You can see the whole path a message takes, change it without redeploying, and reason about failure cases directly.

A typical support flow moves through five stages:

1. Intent — classify what the incoming message is about. Is this a returns question, a technical issue, a pricing question, or something the agent shouldn't handle at all? Intent routing keeps each branch focused.
2. Retrieve — pull the most relevant chunks from the knowledge base for the detected intent. This is where the agent gathers the facts it will answer from.
3. Reason — send the message, the conversation history, and the retrieved context to the model to work out an answer. The model is asked to rely on the retrieved material, not on its own recollection.
4. Decide — check the result against your rules. Did retrieval return anything relevant? Is the customer asking for a human, or raising something sensitive like a refund or a complaint? This gate chooses the next step.
5. Reply or handoff — either send the grounded answer back to the customer through their channel, or route the conversation to a human in the console with the full context attached.

Because each stage is a node, you can tune one part without touching the rest — tighten the intent classes, swap the retrieval dataset, adjust the handoff conditions — and watch the effect on real conversations.

Knowledge base

The knowledge base is the agent's source of truth. It's organized into datasets — collections of imported material such as help-center articles, product docs, policies, PDFs, and links. When you import a document, cove1 splits it into chunks and indexes them so they can be retrieved by meaning, not just keyword match.

At answer time, the retrieve node runs a similarity search over the relevant dataset and returns the chunks most likely to contain the answer. Those chunks become the context the model reasons over, and the sources behind them are cited — so a reply can point back to the exact material it came from.

This is what keeps answers grounded. When the knowledge base has no relevant chunk for a question, the agent should say it doesn't know or hand off, rather than inventing an answer. Curating the knowledge base — keeping it current, removing stale material, and splitting documents sensibly — is the highest-leverage way to improve answer quality. See Knowledge base for how to import material and inspect what retrieval used.

Console (AIDesk)

The console — AIDesk — is the single place your team runs support. Every conversation, whether the agent is handling it or a human is, flows into one shared workspace so nothing falls through the cracks.

The console gives your team:

• Inbox — a unified stream of conversations across every connected channel, with their current status (open, pending, resolved) and whether an agent or a person is driving.
• Assignment — route conversations to the right teammate or team, manually or by rule. When an AI agent hands off, the conversation lands in the inbox already assigned or ready to be picked up.
• Notes — private, internal-only notes on a conversation that customers never see. Use them to capture context, flag an account, or brief the next person who picks up the thread.

Because the AI agent and your human team work the same inbox, a customer never notices the seam between them — the conversation is continuous even when the responder changes.

Channels

A channel is a way a customer reaches you: a website widget, email, or a messaging app like WhatsApp, Messenger, Instagram, or Telegram. cove1 handles channels through its conversation layer, so one agent can serve many channels at once and every message lands in the same console.

The key idea is that channels are an entry point, not a silo. A customer might start on the web widget and follow up by email; both belong to one conversation, handled by the same agent with the same knowledge, tracked in the same inbox. See Channels for the full list and setup details.

Human handoff

Human handoff is the controlled transfer of a conversation from the AI agent to a person. It's a first-class part of the flow, not a fallback bolted on the side — the decide node chooses when to escalate.

Common triggers for handoff:

• The customer explicitly asks for a human.
• The question falls outside the agent's scope, or retrieval found nothing relevant.
• The topic is sensitive — a refund, a complaint, a cancellation, an account or security issue.
• The agent's confidence is low, or the conversation has gone back and forth without resolving.

When a handoff fires, the conversation moves into the console with its full history and any retrieved context intact, so the person who picks it up doesn't ask the customer to repeat themselves. The transfer is smooth in both directions: a human can also hand a conversation back to the agent once the sensitive part is handled. To the customer it's one continuous thread.

Models

cove1 runs on OpenAI-compatible models, so it can point at any provider or private endpoint that speaks the OpenAI API. The default is DeepSeek — strong reasoning at a low cost — but you're never locked in. Swapping models is a configuration change, not a rewrite: set the base URL, the key, and the model name, and the same flows run on the new model.

Being OpenAI-compatible means the model can be chosen on the basis of cost, latency, language coverage, or data-residency requirements rather than a vendor's roadmap — and for deployments with strict residency needs, an in-region endpoint keeps model traffic where the rest of your data lives. See Deployment for how those choices are made during a rollout.