KnowledgeCoPilot

KnowledgeCoPilot sits beside the table of contents in the knowledge base editor and edits it for you. Tell it what is wrong with the structure and it reworks it: merge two sections, split one, retitle entries that read too vaguely for an agent to choose them, bring back a page the build left out. It is the odd one out among the CoPilots. AgentCoPilot, ToolCoPilot and TaskCoPilot work by calling the same API operations you would call. KnowledgeCoPilot has a bespoke toolset with exactly one capability: replace the table of contents of the knowledge base it is editing. Everything it does, it does by writing a whole new tree.

When it is available

Only once the knowledge base is ready. Before that there is no table of contents to edit, and the dashboard shows the build progress in its place. A build in flight blocks it. While the knowledge base is discovering, transcribing or generating, sending it a message is a 409 naming the status: knowledge base is transcribing — wait for it to finish. The build is rewriting the same tree, so a chat turn would be editing underneath it. You can still open the conversation and read it — you can watch, but not drive. The first thing you will see in the chat is a note the build itself left there when it finished, saying what it did and how many pages it left out.

What it is good for

Retitling and resummarising. This is the highest-value thing it does. Retrieval on Talqing is a model reading titles and summaries and choosing — there is no similarity search behind it — so an entry whose summary does not say what the page answers is an entry the agent will never fetch. Ask for “summaries that name the concrete things each page answers” and check the result against GET /v1/knowledge/{kb_id}/prompt. See editing. Restructuring. The build organizes pages from the site’s own link graph, which reflects how the site is navigated rather than how a caller asks. “Group these by product line instead of by year” is a sentence; doing it by hand is not possible at all, because patch_node cannot move an entry to a different parent. Unplaced pages. A ready knowledge base reports unplaced: pages that transcribed but that the table-of-contents pass judged redundant and left out. They are not reachable by an agent. Asking the CoPilot to place one is the only way to add an entry to the tree. Pruning. It can drop entries the same way it adds them, and it sees which pages exist, so “remove everything about the discontinued range” works without you listing the URLs.

What it cannot do

It only writes the table of contents. It cannot:

Fix a page’s text. Content lives on the transcribed page. Correct it with patch_node — see editing.
Crawl, transcribe, or add a page that was never indexed. It can only place URLs that are already indexed. Ask for one that is not and it will tell you, or the entry will be refused when it applies.
Attach the knowledge base to an agent, or touch anything else in the workspace. Unlike the other three CoPilots it has no access to the API surface at all.

Two structural rules it works under, which explain most of what it will refuse:

Every indexed page belongs at exactly one place in the tree. A second entry pointing at a URL already used is dropped.
A leaf must be a page. A category with nothing under it is dropped.

When part of what it wrote is refused, it says so rather than reporting plain success — “3 nodes could not be created” — and the tree it did write is applied.

Every edit replaces the whole tree, which means entry ids change. Node ids are re-issued on every rewrite, and version goes back to 0. A script holding node ids must re-read the tree after a CoPilot turn. regenerate_toc has the same effect.

What it sees

Before every model call inside a turn it is handed the live state, re-read from the database:

every indexed page, as url — title
the knowledge base’s current overview paragraph
the current table of contents, as JSON

The database is the truth, not the chat history, so a turn always works from the tree as it stands rather than from something said ten messages ago. It can also rewrite the overview — the three-to-six sentences shown above the map in the agent’s prompt — in the same turn.

Limits


Model round-trips per turn	25
Role required to send	EDITOR or ADMIN. A VIEWER can read the conversation and gets a 403 on send
Permissions	It acts as you, in your workspace only
Billing	Never billed. A CoPilot turn is not a session and carries no platform fee
Availability	`ready` knowledge bases only; 409 while a build runs

Driving it from the API

The dashboard rail is the usual way in, but it is a normal pair of endpoints. POST /v1/copilot/knowledge/{kb_id}/messages sends a message and returns as soon as the turn is queued. The reply does not come back on that response — it arrives on the stream. GET /v1/copilot/knowledge/{kb_id}/stream is a text/event-stream carrying three frames: snapshot (the whole conversation, sent first and on every reconnect), message (one new message, yours or the CoPilot’s) and turn (that turn’s lifecycle — running, done, error or canceled).

KB_ID=3d1f5a70-8c2b-4e19-9a63-b7f0c4d21e58

curl -sS -X POST "https://api.in.talqing.com/v1/copilot/knowledge/$KB_ID/messages" \
  -H "Authorization: Bearer $TALQING_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text": "Group the article pages by product line rather than by year, and rewrite each summary to name what the page actually answers."}'

curl -N "https://api.in.talqing.com/v1/copilot/knowledge/$KB_ID/stream" \
  -H "Authorization: Bearer $TALQING_API_KEY"

const { stream } = await talqing.copilot.knowledge.stream({ kb_id });

await talqing.copilot.knowledge.send({
  kb_id,
  sendMessageRequest: {
    text: "Group the article pages by product line rather than by year, and rewrite each summary to name what the page actually answers.",
  },
});

for await (const event of stream) {
  if (event.event === "message" && event.item.type === "message") {
    console.log(event.role, event.content);
  }
  if (event.event === "turn" && event.status !== "running") break;
}

talqing.copilot.knowledge.send(
    kb_id,
    text=(
        "Group the article pages by product line rather than by year, and rewrite "
        "each summary to name what the page actually answers."
    ),
)

with talqing.copilot.knowledge.stream(kb_id) as events:
    for event in events:
        if event["event"] == "message" and event["item"]["type"] == "message":
            print(event["role"], event["content"])
        if event["event"] == "turn" and event["status"] != "running":
            break

Open the stream before you send, or you will miss the frames for that turn. The conversation is durable either way — reconnecting replays it in the snapshot frame.

Editing by hand

patch_node, regenerate_toc, and the troubleshooting table for a knowledge base that is answering badly.

AgentCoPilot

The CoPilot in the agent editor, and how the four differ.

Get started

Agents

Tools

Knowledge

Agent teams

Agent tasks

Telephony

Web & chat

Integrations

Email outbound

Observability

Guides

Platform

KnowledgeCoPilot

When it is available

What it is good for

What it cannot do

What it sees

Limits

Driving it from the API

Next

Editing by hand

AgentCoPilot

​When it is available

​What it is good for

​What it cannot do

​What it sees

​Limits

​Driving it from the API

​Next

Editing by hand

AgentCoPilot

When it is available

What it is good for

What it cannot do

What it sees

Limits

Driving it from the API

Next