---
title: Quick chats
description: Chat with an agent that needs no computer, daemon or sandbox. It works through MCP servers only, Venom Notes by default, with the other Venom servers and the catalog servers you connected a switch away.
section: agents
order: 6
audience: [user, builder]
sources: [services/nodejs-cloud/lib/agents/quick.ts, services/nodejs-cloud/lib/agents/quick-pure.ts, services/nodejs-cloud/lib/agents/mcp-client.ts, services/nodejs-cloud/lib/agents/connections.ts, services/nodejs-cloud/components/agents/ServerPicker.tsx, services/nodejs-cloud/app/api/workspace/agents/servers, services/nodejs-cloud/app/api/workspace/agents/skills, services/nodejs-cloud/components/agents/SkillPicker.tsx, services/nodejs-cloud/components/agents/PickerRow.tsx, services/nodejs-cloud/lib/skills/agents.ts, services/nodejs-cloud/migrations/0334_agent_chats_skills.sql, services/nodejs-cloud/app/api/workspace/agents/connections, services/nodejs-cloud/migrations/0293_agent_quick_chats.sql]
features: []
---

A quick chat needs nothing set up. You don't need a daemon, a project or a computer. Venom Cloud runs the agent itself, on
your organisation's gears, and the agent works only through MCP servers: Venom's own (your notes, tasks, people, calendar
and the rest) and the catalog servers you connected, such as Granola.

Use it to ask questions about your workspace and to get small jobs done in it: "what did we decide about pricing last
week?", "file an issue for the login bug and assign it to me", "summarise my meetings with Acme". For work on code, use a
[code chat](/docs/agents/app.md); for work in a website, a [computer chat](/docs/agents/computer-chats.md).

## Start one

Open `/agents`. **Quick chat** is the first choice under **Where**, and it is already picked. Type your message and send it.

Two pickers sit in the prompt box:

- **Servers**: the MCP servers this chat may use. Venom Notes (your notes) is on by default.
- **Gear**: the model preset the agent runs on. The picker lists every one of your organisation's gears (Gears page),
  then Venom's built-in gears (eco, normal, power, qwen, china, auto, …) unless your organisation allows only its own.
  A quick chat runs on the cloud, so a gear runs on the first of its models that your organisation serves right now
  (a provider key, one of the cloud's model aliases, or a live daemon, which the cloud relays to): in a list, the first
  served entry; a wildcard such as `qwen/*`, the first served model that matches it, in alphabetical order (the picker
  shows which). A gear the cloud can't run right now is still listed, greyed out, with the reason: its model is served
  only by a daemon that is offline, no provider key reaches it (and which provider would), it names only a wildcard
  nothing served matches, or your organisation keeps to its own daemons. Admins get a link to the Gears page from there.
  The default is your organisation's default gear while it can run, else the first gear that can. When the default
  can't run, the chat says so and names the gear it used instead. The model call goes through the org's routing and is
  metered and booked to you like any other chat.

There is no mode picker. A quick chat always asks before anything destructive (below).

The next quick chat opens with what you used last: the servers, the gear and the place (a quick chat, a project or a
computer). Each choice is saved as soon as you change it, even if you never send the chat, and follows you to your other
devices. A server you can no longer use (your organisation stopped allowing it, or you disconnected it) is switched off
quietly when the list loads. The gear is remembered separately from a code chat's.

### Files and pictures

Attach pictures, Word documents and text or code files to a message: the paperclip, a pasted screenshot, or files dropped on
the chat. The agent sees a picture as a picture and reads a document as text. Up to 6 files a message and 50 a chat. See
[Files and pictures in a chat](/docs/agents/attachments.md) for the types, the limits and what happens on a gear whose model doesn't
read pictures.

## Pick servers

The **Servers** pill opens a dialog with a search field on top, already focused. Type to find a server among all of them:
a name matches by its first letters, a part of it or its letters in order (`lnr` finds Linear), a description by whole
words, and the best match comes first. With nothing typed the list is in sections (empty ones are hidden):


- **Venom**: Notes, Tasks, People, Calendar and Venom's other workspace servers. Switch on what the chat needs; a
  product your plan lacks answers with an error when the agent calls it. A product with its own guidance (Venom Studio:
  which kind of artifact to make, the workflow, and how to make it look designed) brings it into the agent's instructions
  when it is switched on.
- **Connected**: catalog servers you already connected.
- **Connect more**: the catalog's remote servers you haven't connected yet, each with a **Connect** or **Sign in** button. A server that needs a sign-in sends you to its
  sign-in page and comes back to `/agents` with the server switched on. A server without sign-in (DeepWiki, Context7)
  connects at once.

Each server has a switch on the right, green when the chat uses it; click the switch or anywhere on the row. A server you
haven't connected yet shows its **Connect**, **Sign in** or **Sign in again** button where the switch would be, and gets its
switch once it is connected (one the chat already has on keeps its switch beside the button, so you can turn it off). A
server whose sign-in failed or expired shows **Reconnect** beside its switch. The pill shows the server's name, or how many
are on ("3 servers").

Use the keyboard: `↑` `↓` move, `Enter` switches the highlighted server on or off (or connects it), `Space` does the same
while the search is empty, `Esc` closes. On a phone the dialog is a sheet from the bottom.

**Only servers your organisation allows are listed.** The catalog servers come from the MCP registry an admin keeps on the
MCP page (the `mcp.allow` list of the organisation's policy). When that policy has an MCP section, a catalog server it
doesn't list is not shown, can't be connected and is refused when you start or change a chat; a chat that already has
it stops using it from its next message. With no MCP section nothing is restricted. Venom's own servers are always listed.

**Your organisation's own servers** (added by an admin on the MCP page, see [custom MCP servers](/docs/cloud/custom-mcp-servers.md))
are listed too, as `custom:<id>`, when the cloud can reach them (reach "Cloud and clients") and they are on. One that needs no
credential, or one org-wide secret, is available at once. One where each member signs in shows **Sign in** like a catalog
server; one where each member gives their own token is connected through `POST /api/workspace/agents/connections` with `token`
(write-only). Servers that are "Clients only" are never offered here.

A connected server whose sign-in has expired or failed shows **Reconnect**. A chat holds at most 12 servers. A change
applies from the next message, and the list stays the same for the whole of a turn: nothing a tool returns can add a
server or a tool.

Connections are yours alone: other members connect their own. Leaving the organisation deletes your connections and
their tokens.

## Use your organisation's skills {#skills}

The **Skills** pill, beside the servers and the gear, lists the skills your organisation has turned on for you in the
[skills registry](/docs/cloud/console-skills.md): search by name, title or description, and switch on the ones this chat should
have. Each skill has a switch, as the servers do. Skills your organisation marks **required** are always on: their switch
is on and can't be turned off, and says why when you point at it. Your choice is remembered for your next quick chat. With
Venom Studio in the chat, the `studio-artifact` skill is on as well, so an artifact is researched and planned before it is built
([Studio for agents](/docs/studio/agents.md#workflow)). If the agent tries to create an artifact before reading the skill, that
first create waits: the agent gets the skill's steps instead (shown as the skill being loaded), posts its brief and outline, and
then creates it. Once per chat. The Studio server also offers `workspace_web_search` (Venom Search, when
your organisation has turned it on).

## Researched reports {#research}

With Venom Studio in the chat, a request for a report, briefing, analysis or deck about a topic starts a
[research run](/docs/studio/research.md): the cloud plans it with goals, splits the research across parallel researchers (Venom
Search, the pages found, scholarly works, World Bank data), writes an analysis per section, builds the artifact from what was
found and reviews it against the goals. A plan card in the chat shows each step as it runs. Two more pills sit beside the
gear: **Research** (Quick, Standard or Deep) and **Agents** (1 to 8). Both are remembered; words in the message ("deep
research, 6 agents") win. Quick, an edit to an artifact, or a small ask with your own text keeps the agent's own turn above.
The chat stays busy until the run ends, even across a restart of the service; **Stop** cancels it.

Only a skill's name and one line go into the agent's prompt. The agent reads a skill's instructions with `skill_load` when
a task matches, and can read the files beside it. To run one yourself, type `/` as the first character of your message: a
fuzzy list of your skills opens above the box; Enter or Tab picks one, and the box holds `/name `. Add what you want done
after it (`/pdf-forms form.pdf data.json`); that message reaches the agent with the skill's instructions attached, once.

A skill is guidance: it gives the agent no tools and no permissions, and a skill disabled or taken out of your scope is gone
from the chat's next turn. A chat holds at most 20 chosen skills. Over the API, `skills` on `POST /api/workspace/agents/chats`
and `PATCH .../chats/{id}` takes skill names, and `GET /api/workspace/agents/skills` (MCP `agents_skill_list`) lists yours.

## What the agent can do

The agent calls tools as you, with your permissions:

- Venom's servers run in the cloud with the same checks and scopes as the [workspace MCP server](/docs/cloud/workspace-mcp.md):
  read and write on the products you switched on, never admin. A tool you could not use yourself fails the same way.
- A catalog server is called over MCP with your own sign-in token, which is kept sealed in the vault and never shown.

Tool results are treated as data, not instructions. A note or a meeting transcript that says "delete everything" is
read, not obeyed.

### Confirm before destructive

A tool that deletes, purges, sends, publishes, shares or otherwise can't easily be undone waits for you. The chat shows the
call with **Allow once** and **Deny**. Allow once runs it, as you; Deny tells the agent it did not run. Either way the agent
goes on and says what happened. A tool counts as destructive when its name says so (delete, remove, purge, send, revoke,
merge and the like), when its MCP annotations say so, or when it has no annotations at all. A write whose name says
publish or share also waits. A read-only tool never does.

When the model provider's content filter or the answer length limit stops an answer, the chat says so under it.

### Limits

| Limit | Value |
|---|---|
| Steps per message (model calls) | 12 |
| Tool calls per step | 4 |
| Length of one model answer | 16,000 tokens |
| Time per model answer | no limit while the model keeps writing; given up after 90 seconds with nothing from it, and never past the message's time |
| Time per message | 12 minutes |
| A tool's output kept for the model | 8,000 characters (the rest is cut, and the agent is told) |
| Conversation sent to the model | the latest ~120,000 characters, oldest whole messages dropped first |

An answer that reaches the length limit is cut off. A tool call in it whose arguments were cut does not run: the agent is
told its answer was too long and to send the work in parts (in Venom Studio: create the artifact with the first part, then
add the rest with edits). A text answer that is cut off ends with a notice in the chat.

Some models lose count of the closing brackets deep in a long tool call (a whole deck inside `mcp_call`), one too many or one
too few, with every value intact. When an answer finished, such arguments are repaired and the call runs, and the agent is told
its JSON was repaired. Arguments that are cut off, or broken in any other way, are never guessed at: the call does not run and
the agent is told why. A model that calls `mcp_tools` through `mcp_call`, nests one `mcp_call` in another, or sends the tool's
arguments as JSON text gets the call it meant, on the chat's servers only.

A slow model can take minutes to write a whole deck or page; it is not stopped while it keeps writing. When the message's time
runs out in the middle of an answer, what it wrote so far stays in the chat, but none of the tool calls in that answer run:
the agent is told the answer was cut off and to send the work in parts, and the chat says the turn ran out of time.

When a message runs out of steps or time, the chat says so; send another message to go on. While the agent answers, the
prompt box waits: stop it with **Stop** (or Esc), or let it finish, then send the next message.

## When a message is lost {#lost}

If the service restarts while you send a message (a deploy, a crash), the agent may never get it, or may stop halfway.
The chat says so instead of going quiet:

- A message that could not be sent is marked **This message was not answered.** with a **Retry** button under it.
- A turn that stops with no sign of life for five minutes is ended in the transcript: **The agent stopped before
  finishing (the service restarted). Send again to continue.** with the same **Retry**. The notice is written once, the
  first time the chat is read afterwards, so the page, the Studio ask box and the `agents_*` tools all see it.

**Retry** resends the message under the id the page gave it, so it is never stored twice. If the agent already answered it,
nothing runs. A chat you reload while the agent works shows it as working, and shows the notice if the turn was lost.

## API and MCP

A quick chat is a chat of kind `quick`. Everything in [Chats API and MCP tools](/docs/agents/api.md) works on it, except steering,
follow-ups, questions and modes:

| Route | MCP tool | Does |
|---|---|---|
| `POST /api/workspace/agents/chats` `{kind: "quick", servers?, gear?, prompt?, attachments?}` | `agents_chat_create` | Start one. Without `daemon_id` or `seat_id`, `quick` is the default. `servers` defaults to `["globe"]`. `attachments`: uploaded files for the first message ([Files and pictures](/docs/agents/attachments.md#api-and-mcp)). |
| `PATCH /api/workspace/agents/chats/{id}` `{servers}` | `agents_chat_update` | Change its servers. |
| `GET /api/workspace/agents/gears?kind=quick` | `agents_gear_list` with `kind: "quick"` | Every gear of the org's, then the built-ins (not when the org locks its gears). One the cloud can run now has `available: true` and `model`, the model it runs on (`pattern`: the wildcard that model matched). One it can't has `available: false`, `why` (the reason in words) and `reason` (`code`: `no_model`, `wildcard`, `offline`, `sovereign`, `no_key` or `unserved`, with `model` and `provider`). `can_manage`: you can fix gears on the Gears page. Create and update refuse an unavailable gear with the same reason (`400 invalid_gear`); a turn on one fails with it (`409 no_model`). |
| `GET /api/workspace/agents/servers` | `agents_server_list` | The servers a quick chat can use: Venom's and the catalog's that the org allows, each with `available`, `connection` (`none`, `pending`, `connected`, `error`), `sign_in` and `default_on`. |
| `POST /api/workspace/agents/connections` `{server}` | `agents_connection_create` | Connect a catalog server. One without sign-in answers `state: "connected"`; an OAuth one answers `authorize_url`, the page to sign in on. |
| `DELETE /api/workspace/agents/connections/{server}` | `agents_connection_delete` | Disconnect it and delete its tokens. |

`GET /api/workspace/agents/connections/callback` is where the sign-in page sends the browser back; it has no MCP tool.
Servers are named `globe`, `tasks`, … for Venom's, `catalog:<id>` for the catalog's (`catalog:granola`) and `custom:<id>` for your organisation's own. Each entry of `GET …/servers` also carries `section` (`venom`, `catalog` or `org`) and `icon` (an org server's tile letter, else null).

The event stream and the transcript have the same shapes as a code chat's, so a client that reads one reads the other.
The cloud keeps a quick chat's conversation (migration 0293, `agent_chat_events`); archiving the chat hides it.

## For operators

Quick chats need nothing beyond the `agents` add-on. Connecting a catalog server that needs a sign-in needs the vault
(`VENOM_VAULT_KEYS`) and the cloud's own address (`VENOM_CLOUD_ORIGIN`, else the request's), which the sign-in page sends
the browser back to. Every remote MCP call goes through the SSRF guard: public https addresses only, no redirects
followed.

Not yet: push notifications for quick chats, and applying the org's MCP policy allow-list to the catalog servers the
picker offers.
