---
title: "Own Agent"
id: "1720"
type: "page"
slug: "own-agent"
published_at: "2026-09-20T20:36:26+00:00"
modified_at: "2026-11-18T17:59:48+00:00"
url: "https://xedant.com/agents/multiagent/docs/own-agent/"
markdown_url: "https://xedant.com/agents/multiagent/docs/own-agent.md"
excerpt: "MultiAgent can get an own agent — a personal AI assistant whose interface is built…"
---

# Own Agent

[https://xedant.com/agents/multiagent/docs/own-agent/.md](https://xedant.com/agents/multiagent/docs/own-agent/.md)

MultiAgent can get an **own agent** — a personal AI assistant whose interface is built right into the MultiAgent pages: you talk to it in a chat without switching between programs. At the bottom of the sidebar there is a block summarizing your active chats, the global chat panel opens from any page, and the assistant has a queue of ready-made prompts, voice input and sound notifications. Connecting it is a one-time setup: you set the agent’s address and key at startup, and everything works. There are no settings screens in the interface and no data stored on the MultiAgent side.

## Connecting the assistant

The assistant is connected with environment variables — technical startup parameters you set once in the settings file at install time. There are two independent directions, each with its own key:

- **MultiAgent → agent (outgoing)** — `AGENT_API_URL` (the agent’s address) and `AGENT_API_KEY` (the key the agent accepts from its automated clients). This pair is what turns on the chat panel and the sidebar block. The key is stored only inside MultiAgent and never reaches the browser;
- **Agent → MultiAgent (incoming)** — `MULTIAGENT_HASH`: the fingerprint of the key to the program interface `/api/agent/*`, through which the assistant itself manages MultiAgent’s factories, agents and tools. On the agent’s own side the MultiAgent address arrives in the `MULTIAGENT_URL` variable and the key itself in `MULTIAGENT_KEY`.

The two directions are independent: to simply chat with the assistant, the outgoing pair “agent address + key” is enough; and the assistant can manage MultiAgent even with the chat turned off.

The agent’s address may include a subfolder — for example, when the agent lives on the same domain under its own path. The assistant works that way too. One more easy-to-miss detail: several family apps can live on one domain in different subfolders — each keeps its own saved chat lists, badges and appearance, so neighbors never overwrite each other’s data.

## Sidebar and chat panel

The assistant’s interface is embedded in every MultiAgent page. At the bottom of the permanent sidebar sits the assistant block: a summary of active chats (timer, token usage and cost — updated in real time), a warning if the connection to the agent has dropped, and two buttons: **“Tasks”** — the number in the circle next to it shows how many long jobs are running and waiting for their turn right now (at zero there is no circle, and while something runs the icon pulses); a click opens their log — and **“Chats”** — the assistant’s chat list. The queue of ready-made prompts opens from the chat panel’s input field.

The chat panel is a bottom drawer that opens from any page. This is where you talk to the agent: model and skill pickers (color-coded), the prompts button, a microphone for voice input, the agent’s answers in real time, queue message cards (editable, pausable, cancellable), usage statistics — tokens, cost, speed — and the **“Open in new window”** button, which opens the same chat in the agent itself. The model and skill you pick are remembered and become the defaults for new chats.

Every request to the agent goes through MultiAgent itself — the browser never talks to the agent directly, so the agent key never leaves MultiAgent. Live updates are delivered over a persistent connection: MultiAgent keeps one connection to the agent and forwards events to every open browser. The connection is opened on demand and rebuilds itself after a break.

The tree of factories and agents on the left is a workplace too. A row menu opens both on a right-click and with the three-dot button at the right edge, and its first item is **“Open”**: for a factory it leads to the home page, for an agent to its public address. Opening the menu selects the row first, so you can see right away what the commands refer to.

The font size from the **“Appearance”** window changes more than the conversation: the text of MultiAgent’s pages — tables, cards and forms — grows or shrinks with it. Fields, buttons and icons stay in place, so nothing breaks apart.

## Agent buttons, questions and messages

The panel does more than send text — it shows everything the agent replies with, and lets you answer right there:

- **agent buttons** — a click runs right in the panel, and buttons already pressed are marked. When a button is set to click itself, a countdown to the click is shown with a **“Cancel”** button next to it;
- **agent questions** — a question or a small form arrives as a card with answer options; the answer you pick is sent to the agent and continues its work, and the sent answer stays visible on the card;
- **agent block messages** — text, images and files render as in a messenger: images in a grid, files as separate tiles, attachments downloadable straight from the agent’s folder;
- **subtask navigation** — when the agent has spawned its own sub-agent, the chat header takes you back to the main chat or into any of its sub-agent chats;
- **“Continue from this message”** — the conversation rolls back to the chosen message and continues from it anew.

All of it arrives over the live event channel — no page reload. The chat list stays live too: commit counters and model or skill changes pull in on their own.

## Prompt queue

The prompt queue is a list of ready-made requests (“prompts”) the agent runs one after another. The queue belongs to the agent itself — MultiAgent only displays it: the “text + model + skill” rows are read from and saved to the agent’s settings, and nothing is stored in MultiAgent itself. Sending a row manually creates a chat with that row’s model and skill and opens it in the chat panel right away; the new chat’s title length follows the agent’s own setting — the maximum title length. The **AutoSend** settings (on/off, the maximum number of simultaneously active chats, the check interval, auto-redirect to the new chat, “Send during peak hours”, “Auto-commit before sending”, “AutoFix disabled until done”) are the agent’s settings too: its internal dispatcher runs the piled-up prompts on its own, even with the browser closed. The queue opens from the chat panel’s input field — it no longer has a button of its own in the sidebar footer.

The queue will not send a half-typed row: when it drains — the last row sent or deleted — **AutoSend turns itself off**. An empty queue shows a draft row, so the first prompt is written without clicking “New prompt”. The dialog footer tells you how many prompts are waiting and in what order they will go: “{count} prompt(s), bottom first”. Edits from two open tabs never overwrite each other — the rows merge line by line.

## Voice input and sounds

The panel’s input field has a microphone: speak your message and it is sent to the agent as plain text. Background chats (the ones processed while you have the panel closed or are in another chat) announce completion with a sound notification — an open chat plays none. The first time you use local recognition, short hints appear next to the microphone while it prepares — “installing ffmpeg” and “loading model”: preparation starts the moment recording begins, so the first transcription doesn’t wait for the download. Voice input and license checks work the same way as in the chats of MultiAgent’s regular agents. A muted sound stays muted after a page reload and applies right away.

## Model quotas under the input field

Under the panel’s input field run the quota bars — one per limit of the selected model. These are the plan’s limits the work runs into: the five-hour window, the week, the month. A green bar means there is reserve, the yellow switches on when about seven tenths are spent, the red when almost everything is. Hovering shows when the limit resets.

- **The set depends on the provider** — for one it is the five-hour window and the week, for another the window, the month and credits. Models whose provider reports no limits have no bars at all;
- **A click on a bar** opens the provider’s dialog with the details: the names of the limits, how much is already spent and when the reset comes;
- **An expired Codex session does not leave you idle** — the bars give way to a **“Sign in with ChatGPT”** button, and the sign-in runs by device code right in MultiAgent;
- **It can be turned off** — the “Appearance” dialog has a “Show model quota bars” switch;
- **The numbers come from the agent itself** — MultiAgent computes and stores nothing, it only displays what the provider reports, so the bars match what the agent itself shows.

The point: you see the limit coming before the work stalls. When the five-hour quota is spent, it is clear you are waiting for the reset — not hunting for the cause.

## Context usage

Along the top edge of the input field runs a thin bar: how much of the open chat’s context window is taken — the part of the conversation the model still remembers. When the bar runs low, the model starts losing the beginning of the exchange: the details of the first messages disappear for it, and answers get less accurate.

- **Hovering** shows the share in percent and the tokens: how much is taken already and how much fits in total;
- **A click** opens the **“Context usage”** dialog with a growth chart per message: you can see after which message the conversation became heavy. The chart updates as the exchange goes on;
- **It can be turned off** — the “Show chat context bar” switch in the “Appearance” dialog;
- **While the window’s size is unknown**, the bar stays empty: showing a share computed from a guess would be a lie.

The point: a new chat is cheaper to start early than to get an answer that has forgotten half the conversation. A clean chat is both accuracy and less spend on re-sending the history.

## Chat labels

To sort the chat list by topic, a chat can carry a **label** — a short name with its own color and icon. Labels are managed in the “Manage chat labels” dialog, which opens from the chat list’s filter or from the label menu on a chat itself: there you can create a label, rename it, and give it a color and an icon from the shared Material Symbols set. One label per chat — a chat either has one label, showing what it is for, or none.

- **Assigning and removing** — a label is assigned by clicking its icon on the chat row, and removed from the label menu in the chat panel header. Assigning a label alone doesn’t reorder or promote the chat in the list;
- **List filter** — the chat list can show only chats with a chosen label, together with the usual text search;
- **Visible to everyone at once** — labels live on the agent itself, and every change immediately reaches all open browsers — no page reload needed. Renaming a label changes it on every chat that carries it; deleting one removes it from all chats at once.

## Chats belong to an app

Every chat carries the app that created it. MultiAgent stamps that mark itself, on its own side, so it cannot be forged from the browser. Only MultiAgent’s chats show in the assistant’s lists: conversations started in the agent itself or in another app of the factory never enter here — and the other way around.

- **The counters and attention badges** in the panel also count only their own chats: other apps’ chats neither distract nor skew the summary;
- **Older chats without a mark** do not show in the lists but stay intact: a direct link to a chat still opens it, and the analytics totals keep counting it;
- **The prompt queue stays shared** on the agent: MultiAgent shows its own rows in it and hands back the whole queue on save, so other apps’ rows are never lost. The guard against sending an unfinished row watches the whole queue;
- **The “By apps” cut** in the analytics shows how many tokens and money each app spends. Whatever could not be attributed lands in “No app”.

The point: several apps and the person themselves can work with one agent. Chat lists stopped being a dumping ground, and the spend is visible per app — it is clear who exactly pulls the budget.

## When the assistant is not configured or unreachable

The assistant block appears only when both `AGENT_API_URL` and `AGENT_API_KEY` are set. On load, the app checks whether the agent is reachable and behaves accordingly:

- **Not configured** — there is no “New chat” button, the panel shows “Agent not configured”, and the sidebar warns about the missing variables;
- **Configured, but the agent is unreachable** — the interface is in place, and a persistent warning strip appears above the lower part of the sidebar with the last error from calling the agent: the first successful response clears it;
- **Key not set** — any call to the agent’s program interface answers with the “Agent API not configured” error.

Errors do not pop up over the interface or get in the way: if the chat list could not be fetched it shows “No chats yet”, an open chat shows “Failed to load the chat”, and the last error from calling the agent stays as a strip above the sidebar footer until the first successful response. A rejected key is distinguished from unreachability: an outdated key is marked as rejected rather than as an unreachable agent.

Sending messages, configuring the prompt queue and creating a new chat check the product license: if it has expired or is invalid, MultiAgent answers with an error and the app opens the license renewal dialog. A new key can always be pasted into that dialog — the activation itself is never blocked.

## The other direction: the assistant manages MultiAgent

The assistant can manage MultiAgent itself: create factories and server records, deploy agents and tools, watch their state. All it needs is MultiAgent’s address and key — it learns the available commands from the `/api/agent` catalog (MultiAgent publishes the list of its own capabilities) and acts like any other automated client. Long work — a deployment, an install, a check — does not hold the connection open: a “queued” mark and an operation number arrive at once, and by them the assistant learns how everything ended. The operations it starts show in the same progress feed as your own.

## As a product

When MultiAgent is deployed as a product from the catalog (the `multiagent` template), the assistant connects automatically: at install time you pick the linked agent (the default is “Create new agent”), and both pairs of variables are written for you, with no manual setup — one pair into the app’s configuration, the other into the linked agent’s configuration. On a linked agent a new chat starts with MultiAgent’s manager skill right away — no need to pick it by hand; if a skill was inherited from the open chat, it is kept. Details on the [Products](/agents/multiagent/docs/products)
 page.

[← Back to documentation](/agents/multiagent/docs)
