Agents and models

Agent - a program that works with code: reads files, edits them, runs commands. Model - what the agent thinks on. External agents come with their own models; With the built-in Pulse agent, you choose the model.

All this lives on two pages of the “Agents and AI” group: Settings → Agents and Settings → Models.

Agents

Agent How to connect What do you need
Claude Code ACP adapter @agentclientprotocol/claude-agent-acp claude in PATH, claude auth login
Codex ACP adapter @agentclientprotocol/codex-acp, CLI is built into Pulse login: Login button or OpenAI API key
Kimi Code kimi acp kimi in PATH, kimi login
OpenCode opencode acp opencode in PATH, opencode auth login
Grok grok agent --no-leader stdio grok in PATH, grok login or variable XAI_API_KEY

They all talk to Pulse ACP (Agent Client Protocol): Pulse sends a prompt, receives a stream of events - text, tool calls, permission requests, token consumption. Therefore, transcript, graph, automode and permissions work the same for any of these agents. A new ACP agent without editing Pulse cannot be connected yet: the list of agents is closed (AgentKind in src/shared/types.ts:74), and everyone needs their own registry entry src/main/agents/registry.ts — how to find the CLI, launch and check the input. Open the list and take agents from the ACP registry - proposal docs/terminal/research/2026-10-02-acp-direction.md, the decision on it has not been recorded.

The agent reports models, modes and effort himself after the first session: they appear as chips in the chat and in the “Default Settings” of the card.

Embedded Agent Models

The built-in Pulse agent is its own tools (read_file, write_file, edit_file, list_dir, search, bash) on top of a model with function call support.

Codex and OpenAI models

No need to install Codex CLI - it runs inside Pulse (the version is visible in the card as “built-in CLI”). All you need is login:

  • via ChatGPT account (like Claude Code, no API key needed) - the “Login” button in the Codex: Pulse card will open the Terminal with a login command, the browser will ask you to confirm your subscription. Same thing manually: codex login;
  • by OpenAI API key — the “OpenAI API Key” field in the same card.

If you have your own codex (for example npm i -g @openai/codex), Pulse will take it: it's in PATH and shows as "installed".

A new model that is not yet on the list. Providers are releasing models faster than agents are updating their listings. Field "Model by hand" accepts any id in the agent’s card: it goes into the “Model” chip and into new sessions. This is how it is connected, for example: GPT-6 Astra — in the API and in the Codex CLI its id gpt-6-astra (requires Codex 0.153.1 or later; Pulse has 0.154 built in). Access to Astra from OpenAI is issued in stages, so the model will work when it appears in your account.

The same model can be used with the built-in Pulse agent, without Codex: “Local Model” card, address https://api.openai.com/v1, API key and model gpt-6-astra. Then Pulse tools (reading, editing, searching, bash) and its sandbox will work.

Local model

Any OpenAI-compatible server is suitable:

Server Default address
Ollama http://localhost:11434/v1
LM Studio http://localhost:1234/v1
LiteLLM http://localhost:4000/v1
llama.cpp server http://localhost:8080/v1
vLLM, enterprise gateway your address, usually with a key

The card specifies the address, key (if needed) and context window. Button "Check" does two things: asks /models (server responds? accepts key? what models are there?) and sends a test call to the tool - whether the selected model can function calling. Without this, the built-in agent will not be able to work: the model will only talk.

Tested models with tool calls: qwen2.5-coder, qwen3, llama3.1, devstral, gpt-oss.

When working with a local model, data does not leave the machine.

GigaChat

Built-in agent on top of GigaChat API (Sber):

  1. Get Authorization key in your GigaChat personal account.
  2. Paste it into the GigaChat card (the key is stored encrypted in the keychain).
  3. Click "Check": Pulse will perform OAuth and retrieve a list of models.

The access type (scope) is selected automatically: if the key is issued for another account, Pulse will sort through GIGACHAT_API_PERS, GIGACHAT_API_B2B, GIGACHAT_API_CORP and the worker will remember.

Important: Not every model may be included in the tariff. If the request fails with “402 Payment Required”, this is not a Pulse error - the account does not have tokens specifically for the selected model. Select another one in the “Model” chip or top up the package.

The connection follows the chain of NCA Mintsifra - the root certificate is built into the application, nothing needs to be configured.

The same key works outside of the agent. GigaChat is not only a model for an embedded agent, but also an AI action provider: select it in Settings → AI, and the commit message, stash name, explanation of changes, PR texts, atomic commit plan and conflict analysis will go to GigaChat. They don’t ask for a second key - the AI ​​page shows the status of the key from the agent’s card, a transition to it and the “Check” button. Speech via GigaChat is not transcribed by Pulse - see Voice Input below. Details - GigaChat.

What this adapter can do: table of capabilities

Each agent’s card has a table of five lines: the exact status, whether it reports the cost, interruption of the turn, continuation of the session after a restart, whether it asks for permission. Agent support and the same quality of work are different statements, and the difference is visible before choosing an agent, not in the middle of the work.

There are three states in the table, not two:

Word What does it mean
yes the possibility exists and has been verified
no checked, there is no possibility - and next to it it says how it will turn out
not verified we don't know. It's not "can't"

Under each line there is a source: reading the adapter code, live testing with a probe with the date and version number of what responded during the test, or turns that Pulse has already seen.

Turns instead of guesses. The line “informs the cost” is filled in by the sessions themselves: if the price came in at least one turn, there is an opportunity, and this is written down as a number (“the price came in 7 out of 10 turns”). If the price has never arrived in five or more turns, it doesn’t exist. Less than five turns remain “untested”: there is nothing to say about two turns. Observations fill in only the unverified and never rewrite the verified - a person sorts out the dispute between them.

Double-check yourself. External adapters are asked by the probe:

node scripts/acp-capabilities.mjs all     # claude, codex, kimi, opencode, grok
node scripts/acp-capabilities.mjs codex # one at a time

It asks the adapter for an option and tries to load the newly created empty session. Failure of such a download means "unknown": Codex ACP 1.12.0 responds Internal error to an empty session, but after the turn is completed and the process is restarted, it loads it successfully. For a continuation response, do a separate live turn and restart the process or application. A report with answers, dates and versions is included in docs/acp-capabilities.json; from there it is transferred to the table by hand. The probe does not check built-in agents (local model, GigaChat): they do not have ACP, and all that is known about them is reading the code and observing turns.

What this table doesn't know. On what version the agent himself The test was in progress, it was not written down everywhere: the probe names the adapter version, not the CLI. If a line seems outdated, it’s faster to run the probe again than to guess.

Agent options (profiles)

A variant is an agent with a character: name, role, instructions, model, mode, effort, auto mode, skills and color. Created in the base agent card, section "Agent Options".

  • Role from the set (lead, developer, reviewer, tester, documenter, refactorer) substitutes the character and instructions, but only in the fields that you did not correct.
  • Instructions goes to the agent as the first turn before the task: role, rules, response format.
  • Skills — a hint “use these skills when appropriate”, not a restriction.
  • Speed dial with one button creates a team: Lead, Developer, Reviewer, Tester on available agents and suitable models.

Options are selected in the composer instead of the naked agent; The “Team” chip runs several options on one task.

Instructions Versions

Each save of a modified instruction (profile or swarm member) creates a version. Under the instruction field there is a chip “v3 · 18.09 14:20”: it contains a list of versions with the date, the difference to the current text, the full text and the “Return” button. For each session, you can see which version was sent to the agent in the first turn (“instrument v2”), so it is clear what wording was used to obtain the result.

Context window

Do not confuse the context window with the provider’s limit: the window is how much the model remembers at a time, the limit is how much you have left for your subscription or package. About limits and session transfer to another model - separate document.

For the built-in agent (local model and GigaChat) the card specifies context window: 8k / 32k / 128k / 200k or your number. Using it, Pulse calculates the percentage of fill and, on approaching the border, compresses the history itself: it trims the old outputs of the tools and collapses the old turns into a summary. The line “Context compressed: …” appears in the transcript. Details - in Memory and context.

Auto mode

The "Permissions" chip in chat switches the session between "Ask" and "Auto". In auto, Pulse answers permission requests itself and puts the agent into its automatic mode (acceptEdits / auto / yolo). Policies are always in effect; auto mode does not cancel them. You can enable auto mode for an agent entirely in his card.

Voice input

The microphone icon in the task composer speaks the prompt in a voice. The decryption is not done by Pulse, but by the provider that has already been selected in Settings → AI — a separate key and a separate subscription are not needed.

Provider in “Settings → AI” Voice What does it decipher?
OpenAI (with key) yes whisper-1, request POST /audio/transcriptions
OpenAI-compatible with the specified address yes the same request to your server (whisper.cpp, LocalAI, faster-whisper…)
Anthropic no API does not have speech transcription
CLI agent no CLI does not have speech transcription
GigaChat no nothing: Pulse does not decrypt via GigaChat - neither now nor “ever”

If the selected provider does not have a decryption, the button does not disappear and does not promise anything: the tooltip says what is missing, but pressing it opens Settings → AI. Ollama does not decrypt the address by default, so for an OpenAI-compatible provider without an explicitly specified address, the voice is considered unavailable.

How is the recording going? The first click shows who the recording will go to, which model and at whose expense; recording begins only after confirmation. The system asks for access to the microphone (on macOS - once per installation; the refusal can be removed in “System Preferences → Privacy and Security → Microphone”). While recording is in progress, a stopwatch and two buttons are visible: "Ready" stops the recording and sends it for decryption, "Cancel" (or Esc) throws it away on the spot. Until “Ready,” the recording does not leave the device, and the microphone turns off immediately after stopping. The ceiling is two minutes: longer than Pulse does not write, but transcribes what is recorded.

The transcript is added to what has already been typed in the composer - what was typed by hand is not lost.

The consent “to send code fragments” from “Settings → AI” does not apply to voice: voice is not a code, and permission for it is asked separately, before the first recording to this recipient.

Price. At OpenAI (and at any cloud gateway), decryption is paid according to the provider’s tariff. Pulse does not know and does not show the exact price: it is set by the provider and changes without us. For the same reason, the decryption does not fall into the “Expenses” - the provider does not return its cost in the response. The server decrypts it for free, but whether it can do this at all becomes clear from the first recording: the server without /audio/transcriptions responds with 404, and Pulse says so.

The records are not saved anywhere: the bytes live in the window’s memory before sending and disappear after it.

Integrations

Settings → Integrations: GitHub and GitLab tokens (imported from gh / glab or entered manually). Pulse displays a link to PR/MR in the task thread and transfers tokens to agents in the environment so that they can work with the hosting themselves.