Chatting

How to interact with your agent.

Public agent pages

Browse public agents on the Grid at Agents. Open a listing at https://inference.sh/agents/{namespace}/{name} to see what it does before you chat or integrate.

The page is a single centered column, with chat at the top:

1. Identity — avatar, display title, clickable namespace/name (copies the agent ref), description, and a short facts line (model or harness, tool and skill counts, last updated). When the listing has a banner image, it fades in behind the top of the page.
2. Composer — when you are signed in, a message box sits under the identity block, unless the agent uses an external harness bound to a connected remote. Sending the first message creates a chat the same way as New chat in the workspace, then opens that chat. Example prompt chips under the box send their text when you click them.
3. Start chat / start session — when you are signed out, or the agent uses an external harness bound to a connected remote, you get a start chat or start session button instead of the composer. Harness agents bound to a remote use start session to open that remote, where the harness folder is chosen.

Below the composer, about and api tabs share the same column:

Open the page with #api in the URL to land on the api tab (same deep link as public app pages).

For discovery from search or the CLI, see Search (collection=agents) and belt suggest.

In the workspace

1. Open your agent
2. Type a message
3. Watch it work

You'll see:

• The agent's thinking
• Tool calls as they happen
• Results as they come back

Chat header

The header stays focused on the conversation:

Agent version, copy-reference, edit-agent, and the execution trace are not in the header anymore — open chat settings → agent for those controls.

Chat settings

Open chat settings from the gear icon in the chat header (only after the conversation has started). Settings apply to this conversation only and save as you change them (same dialog pattern as workspace settings).

General

Agent

See which template agent answers in this chat, copy its reference, open the version this chat runs, switch to another platform loop agent when allowed, and open the execution trace.

Current agent shows the agent title, namespace/name, and an 8-character version prefix when the chat is pinned to a template version.

External harness agents (Claude Code, Codex, and similar) have no editable template version in inference shell, so edit agent is hidden — the same rule the old header used.

Via API, call POST /chats/:id/agent with namespace/name (same as the workspace picker). The JavaScript workspace uses switchAgent() from useAgentActions() when AgentChatProvider is mounted. For the graph programmatically, use GET /chats/:id/trace.

Permissions

Control human-in-the-loop tool approvals and other allow / ask / deny rules for this chat.

When a tool needs approval, you can approve, reject, or always allow from the chat UI. Always allow adds an allow rule on the chat layer (and still approves the pending call).

On the this chat layer you can remove rules you added. Allow rules from an agent template written by another workspace do not apply in your chat (their ask and deny rules still can); only allow rules you add on this chat, or from an agent your workspace owns, open tools without asking.

Use add a rule to narrow what runs without asking (or to ask or deny specific tools, harness patterns, remote commands, or folders). Chat rules can only narrow what governance or agent layers allow; the API refuses an allow that a layer above asks about or denies.

Use test a call to see which layer and rule would decide a sample tool name, harness call, command, or path before you run it.

→ Approval settings · Chat rules REST API · Chat settings API · Always allow tool

Memory

When the agent uses the internal memory tools, it stores key–value notes on this chat (agent_data.memory on Get chat). The memory pane lists every note and its value.

Via API, pass forget_memory (array of keys) on POST /chats/:id/settings. Keys that are not stored are ignored.

Hooks

Toggle whether lifecycle hooks configured on the agent (suggest, learn, webhooks, gates) run in this chat without editing the agent template.

Set disable_hooks on POST /chats/:id/settings or use the Run hooks switch in chat settings.

→ Per-chat disable

Long conversations and context

Very long threads can approach the agent model's context limit. Before each turn, the platform checks whether the next prompt would use more than 80% of that limit. When it would, older parts of the live transcript are summarized into a compaction entry and only the newest portion (about 25% of the budget) stays verbatim.

In the workspace you may see a compaction line in the transcript — a short summary of earlier user messages and assistant replies. Tool-heavy stretches are summarized without replaying every tool output. The chat keeps going; you do not need to start a new conversation unless you want a clean slate.

Compaction never cuts between a tool call and its result, so the model always sees matched pairs. If you use lifecycle hooks, agent.pre_compact runs before summarization (your webhook can return deny or stop to skip it for that turn) and agent.post_compact runs after. Turn off hooks for one chat with Run hooks in chat settings or disable_hooks on POST /chats/:id/settings.

Integrations can listen for context.compacted on the agent run event stream. See Context auto-compaction.

Example conversation

1You: Create a logo for "Morning Brew" coffee shop23Agent: I'd be happy to create a logo. A few questions:4       - What style? (minimal, vintage, modern)5       - Any specific colors?6       - Should I include a coffee cup icon?78You: Modern style, warm colors, yes include a cup910Agent: [Calling stable-diffusion...]11       12       Here's your logo! I created a modern design with 13       warm orange and brown tones featuring a stylized 14       coffee cup.15       16       Want me to create variations?

Widgets

Sometimes agents need structured input.

They can generate small UI forms:

1Agent: I need some details:23       ┌─────────────────────────┐4       │ Company: [____________] │5       │ Style: [Modern ▼]       │6       │ Colors: [____] [____]   │7       │                         │8       │ [Generate]              │9       └─────────────────────────┘

Fill it out and the agent continues.

From the terminal

After belt login, run agents and manage chats without opening the workspace:

1belt agent run myteam/my-agent "Hello"2belt agent run myteam/my-agent "Follow up" --chat chat_abc1233belt chat get chat_abc1234belt chat send chat_abc123 "What's the status?"   # streams the agent's reply5belt chat watch chat_abc123                       # re-attach without sending a new message

belt chat send streams the agent's response (same behavior as belt agent run). Use belt chat watch to follow a chat that is already running or after approving a tool without --watch.

When a tool requires approval, list and act on pending invocations:

1belt chat pending2belt chat approve ti_abc123 --watch

→ CLI setup · Agents API

Per-chat context

Agents can declare context fields that their tools use as {{context.NAME}}. Pass values when you start a chat (belt agent run --context key=value on the CLI):

1{2  "agent_id": "agent_abc123",3  "context": {4    "project_id": "proj_456",5    "environment": "staging"6  }7}

Context is set once per chat and cannot change, so every tool call in that conversation uses the same project or environment. The server substitutes the values when tools run; they are not written into the system prompt unless the field sets in_prompt: true.

→ Context in Adding Tools · Create Chat REST API

Structured results

When an agent uses the finish tool (required for structured output), the final JSON is stored on the chat as output. Retrieve it with GET /chats/:id (see Get Chat) or agent.run() in the SDK.

Inspecting execution

The workspace shows tool calls and reasoning as the agent runs. For integrations and debugging:

Use streaming when you need live updates; use List chat messages when you need a point-in-time transcript after the run. Use GET /chats/:id for chat-level metadata such as output and status.

Sending messages mid-run

While the agent is still working (chat.status is busy), you can send additional user messages without waiting for the current turn to finish. In the workspace, these appear as pending messages until the agent picks them up on its next turn.

Via REST, call POST /chats/:id/messages with a message string, or send another message with POST /agents/run using the same chat_id. When a run is already active, the API auto-queues instead of starting a new run. The message is created with status: "queued"; when the agent's next turn starts, it transitions to ready and is included in context (its transcript order may update at that point so it appears after any tool results that finished while it was waiting). To withdraw a queued message before the agent consumes it, call POST /chats/messages/:messageId/cancel. See Send chat message, Cancel message, Queuing while a run is active, and Chat message status.

Terminal and API

• CLI — belt agent run, then belt chat get, pending, approve, or reject for follow-ups and human-in-the-loop. See CLI Setup.
• REST — New conversation: POST /chats (with agent) → POST /chats/:id/messages. One-shot: POST /agents/run. Follow-ups: GET /chats/:id (metadata), GET /chats/:id/messages (transcript), POST /chats/:id/messages, and POST /tools/:id/invoke or /reject. See Agents REST API.

Chat integrations

Connect your agent to external chat platforms. For Slack, configure your app's event subscription URL to the agent's channel webhook (POST /agents/{id}/channel/slack). See Messaging channel webhooks.

Talk to your workspace from where you already are. For custom HTTP tools mid-conversation, see Agent webhooks.

Tips

• Be specific about what you want
• Provide context when relevant
• Ask for variations if the first result isn't right

Next

→ Browsing the Grid — discover apps on the same explore site
→ Agents REST API — chats, runs, and streaming from your own code