Name and avatar
How the agent introduces itself and the photo the customer sees. This is the role it holds in your operation: salesperson, receptionist, broker, support analyst.
A channel agent is the one talking to your customer. You define its name, personality, voice, and memory, then hand it real tools and a knowledge base of its own. From there, it decides what to do with every message.
This isn't a chatbot running a flow. It's an operational agent trained to work.
The same agent answers on WhatsApp, in your website chat, and on the phone.
Seven decisions on a screen. None of them is a conversation path — they're the traits of the worker who will do the job.
How the agent introduces itself and the photo the customer sees. This is the role it holds in your operation: salesperson, receptionist, broker, support analyst.
The text that describes who it is, what it may promise, the tone it uses, and where it stops. This is where your business rules live — written in plain language, not wired into decision nodes.
The voice the agent uses when it replies with audio and when it answers the phone. Same agent, same prompt, coming out as sound.
Which official WhatsApp number, which webchat, or which voice extension belongs to this agent. One agent can sit in more than one place without being rebuilt.
Which numbers the agent recognizes as the manager's. That's what separates someone asking about a price from someone asking for the weekly report.
Long-term memory is a per-agent switch. On, and the agent remembers the customer next time. Off, and every conversation starts clean.
In the platform, those six decisions fit into a single tab. The screen below is the Personality tab of a channel agent's editor: the WhatsApp channel it is linked to, the name the customer sees, the internal description, the voice profile used in audio and on the phone, the temperature control between Precise and Creative, the long-term memory switch with the warning that it consumes more tokens, the phone numbers the agent recognizes as the manager's, and the system prompt — the text that describes the job and its limits.
The other tabs hold the rest of the agent: Memory shows what is retained per channel and lets you erase it, APIs lists your system's tools with method, authentication, and a usage counter, MCPs gathers the connected servers, and Web Chat Embed hands you the code snippet for the website chat. In none of them is there a flowchart, a decision node, or a scripted conversation path.
Just below the prompt, the Tools enabled row is this agent's inventory of actions: checking inventory and opening an order are lit up, the status lookup is identified by its method, and the delete-order route is dark — deleting an order is not part of her job. At the bottom of the screen, the unsaved-changes badge waits for the manager to confirm before any of it reaches a customer.
Taking a permission away or handing it back means dimming a chip or lighting one up. When business policy changes — the agent may look an order up, but may not cancel it — the change happens on this screen, in minutes, instead of turning into an integration ticket in somebody's queue.
It is also the same screen for every channel this agent works on: one decision instead of three parallel settings someone has to keep identical.
Voice Profile appears in the same tab as the prompt and the tools because the one taking the call is this agent, not a sibling of it: the same personality text, the same tools, and the same memory, live on the call.
In a flow-based automation, voice service is a separate product, with a separate script to write and keep current. Here it is one field on the form.
In a flow-based chatbot, every new customer question becomes a new branch on the tree — and somebody has to draw that branch. Here, the new question meets the same agent, with the same knowledge and the same tools, and the agent handles it.
When a business rule changes, you rewrite a paragraph of the prompt or upload a document to the Vault. There is no map to redraw.
A tool isn't a menu button: it's an action the agent chooses to take when it makes sense for that conversation.
Everything a human rep would do inside the chat, the agent does on its own initiative.
When the answer isn't in the prompt, it goes looking instead of making something up.
And with your system's APIs registered, it can query the ERP, the patient record, or the order system mid-conversation.
Service doesn't end when the message does. The agent flags what has to come back around.
The official template is what lets you reach a customer outside Meta's 24-hour window.
When the agent needs a piece of data that only lives in your system, it calls the API you registered as a tool, reads the response, and keeps the conversation going with the number in hand. The customer never sees the seam.
The same holds in the other direction: the agent writes back to your system when the prompt allows it, and logs what it did in the CRM.
The price of a consultation, the delivery window, the return policy, an internal procedure. What your company knows, the agent comes to know — without turning any of it into code.
Upload a PDF, text, or an image, or write knowledge blocks directly on the screen. The content is indexed and becomes searchable for the agent during a conversation.
Each agent has its own vault. The salesperson doesn't need to carry the finance manual.
The agent itself saves new knowledge mid-conversation and removes what turned out to be wrong. If a manager corrects a piece of information over WhatsApp, it goes into the vault and holds for the next customer.
That's the difference between a base that ages quietly in a repository and one the operation updates day to day, with no ticket and no release.
The knowledge base is what lets the agent answer about price, timing, and procedure without anyone programming a flow.
The screen below is the Knowledge Vault of the Aurora — Sales agent: search and format filters at the top, the uploaded files in the middle, and, at the bottom, the knowledge blocks typed straight onto the screen. Each file carries its own indexing state — the PDF catalog already indexed and available to search, the returns policy text still being processed, and the spec sheet image waiting in the reading queue. Only what is already indexed answers the customer; the rest joins the vault the moment it finishes, with no release and no ticket.
The two strips at the bottom show the vault in use: the lookup the agent ran against the base during a conversation today, and the block the agent itself saved after a manager's correction over WhatsApp.
The numbers next to the filters say what this agent carries today: fourteen items, across PDF, text, and image. The catalog that is already indexed announces 142 passages available to search — a PDF does not sit in the vault as one whole attachment, it becomes passages the agent searches through.
On the right end of the bar, the agent selector swaps the entire vault: each agent sees only what belongs to it.
Upload the file or type the block and save: the rule that changed this morning is already answering customers this afternoon, with nobody translating policy into code first.
And because a lookup returns the passage rather than the document, the customer gets the sentence that answers their question instead of a manual attached for them to read alone.
Look at the lookup strip at the bottom of the screen: it logs a call made from inside a live conversation, with three passages returned. Nobody marked “look it up in the base here” at some point along a path — the agent is the one that concluded, in the middle of the customer's sentence, that it needed to search before answering.
In a flow-based automation, the search only happens at the node where someone predicted it would; a question that arrives outside that point comes back as a menu.
Customer history is vectorized with embeddings, and a worker pulls stable facts out of it — episodic memory — along with customer traits, a read on mood, and a sense of time.
It's the same technology behind text service, voice service, and Squads. That's why a conversation still flows weeks later, and why the agent knows that this customer already complained about a delivery date back in March.
It's also the subject of the patent filed with the USPTO in 2025 — Autonomous Agent Memory Framework Inspired by Human Cognition.
What doesn't change message to message: the plan they signed up for, the delivery address, the restriction they declared.
How that customer tends to talk, and what state they showed up in over the last few conversations.
How long ago something was said — the difference between a live loose end and a closed matter.
The conversation memory screen shows what is stored per channel and lets you clear it.
Every agent has a schedule of its own: routines it runs at a set time, and waits it creates for itself inside a conversation.
A recurring task configured per agent, at a defined time. It wakes up, does what was agreed, and logs the result.
“Follow up with this customer in 2 days.” The wait comes out of the conversation itself, the moment the agent decides something needs a callback.
The screen lists what's active per agent and lets you create, edit, and follow along. Nothing runs hidden from the manager.
A channel agent's schedule serves the conversation: the callback it promised, the reminder it agreed to, the check-in on that one customer. When the routine belongs to the business — sweep the ERP every morning at 7, decide who needs to be contacted, and send the channel agent to contact them — that work belongs to the orchestrator agent.
The agent that works becomes the starting point for the next one — inside your company or between companies on the platform.
Duplicate an agent you've already tuned and change only what differs: the branch, the language, the channel, a passage of its personality. What was right stays right.
An agent can be shared with another company on the platform — and the other company has to accept. Nothing lands in anyone's account without the other side saying yes.
Useful for multi-unit groups, for franchises, and for the reseller program — the partner hands over a finished agent and the client accepts it.
The platform includes a simulator identical to WhatsApp so a manager can test the agent with no real number, nothing published, and no template spent.
Once the agent behaves the way you want, link the channel. The same agent shows up on official WhatsApp, in your website webchat, and on the phone.
The agent recognizes administrator phone numbers and answers the manager differently.
Transferring to a human is one of the agent's tools, but an operator can also take over on their own. On takeover, the platform pauses the bot in that chat automatically; when the operator closes out, the agent resumes. No parallel conversation, no lost history.
No. The agent is given a personality, knowledge, and tools, and it chooses what to do at every turn of the conversation — including deciding that nothing needs to be done. There is no flowchart screen, no decision node, and no pre-mapped path for every possible thing a customer might say.
Through three paths that work side by side: the Knowledge Vault, where you upload PDFs, text, and images or write knowledge blocks right on the screen; your own system's APIs, registered as agent tools; and reading web pages during the conversation. The agent also saves new knowledge while it works.
If long-term memory is turned on for that agent, yes. History is vectorized, a worker extracts stable facts and customer traits, and the conversation picks up naturally weeks later. The memory screen shows what is stored per channel and lets you clear it.
Yes. The platform includes a test chat that simulates WhatsApp, with the same personality, the same tools, and the same memory as the published agent. Test conversations stay separate from real ones in the CRM.
Tell us which conversation your operation repeats every single day. We'll design the agent that handles it with you — with the tools and the knowledge that conversation demands.