Chat with Your Squad Member

Talk to your squad through Desktop, Telegram, or the WebSocket API.

Once your squad member is deployed, there are three ways to talk to it: the built-in Desktop chat, messaging apps like Telegram, or the WebSocket API for programmatic access.

​

Three ways to chat

Method	Best for	Setup required
Desktop	Day-to-day interaction, debugging, monitoring	None — built in
Messaging apps	Reaching your squad from Telegram or WhatsApp	Connect a messaging app
WebSocket API	Building integrations, automation, custom UIs	Developer setup

​

Desktop chat

The fastest way to talk to your squad. Open the Chat tab in Desktop and start a new conversation.

Tabbed interface — open multiple conversations at once and switch between them like browser tabs. Use ⌘T to open a new tab, ⌘W to close, and ⌘1–9 to switch.

What you see while chatting:

• Real-time streaming — responses appear token by token as the agent generates them
• Thinking indicators — see when the agent is reasoning through a problem (including context compaction status)
• Tool use — watch the agent call tools, see the inputs it sends, and the results it gets back
• Image support — send images to your agent for analysis or discussion

The empty chat panel shows your recent conversations and deployed agents for quick access. Every conversation is automatically saved. Come back later and pick up where you left off.

​

Guide a response or queue a follow up

On a current HQ, the message box stays editable while your agent works. Type your message and press Send.

DashSquad decides how to deliver it:

• If your message changes or narrows the work in progress, it becomes a Steer: the agent picks it up at its next safe boundary. It is labeled Auto-steered.
• If it asks for separate work, it becomes a Follow Up in the shared queue, labeled Auto-queued.
• If DashSquad is not sure, it asks. The choice opens with its best guess marked Suggested, and your message stays in the box until you pick one.

To choose yourself, press Cmd+Return (Ctrl+Enter on Windows and in the web client) instead of Send. On iPhone, iPad, and Android, touch and hold Send to choose Steer or Follow Up yourself. The choice offers:

• Steer — Guide the response in progress. The agent receives your guidance at its next safe boundary. It appears in the conversation with a delivery status, becoming Steered when delivered.
• Follow Up — Send after this response finishes. Save the next request in the shared queue. You can queue several requests and edit or remove one before it starts.

To make the call, the HQ sends your new message’s text — along with a short excerpt of the current task and the reply in progress — to a decision model (TypeSafe’s Jev, reached through OpenRouter using your OpenRouter key). Images are never sent. Automatic routing needs that OpenRouter key on your HQ; without one, or with Settings → Chat → While a response is running → Always ask in Desktop, every message asks instead — switch to Always ask any time you’d rather turn this off.

Closing the chooser keeps your draft and attachments. Sending clears only the draft the HQ has acknowledged; text you type afterward stays in the message box.

Follow Ups run in order. Stop ends the current response and advances to the next Follow Up. If a response fails, the remaining queue shows Follow Ups paused. Review the failure, then choose Resume Follow Ups. While paused, you can keep drafting or edit and remove queued items.

The HQ saves accepted Follow Ups across disconnections and restarts. Opening the same conversation on Desktop, web, iPhone, iPad, or Android shows the same queue. A Steer that misses the end of its response is marked not delivered; it never becomes an unrelated later request.

These controls require Mobile API v2. Older HQs and Desktop’s local chat keep their existing single-response composer. Authentication or connection errors do not enable a legacy fallback. Older HQs always ask.

​

Reading tool activity

When your agent uses a tool, Desktop and the web client show a tool card. DashSquad for iOS groups consecutive thinking, status, and tool steps into one compact Activity row so a long tool run does not crowd out the conversation. Tap the row to inspect the individual steps and available results.

Collapsed by default. Each card shows a single line: the tool’s name, a short summary of what it was asked to do, and what came back. A bash card reads its command, a read card names the file and says how many lines it returned, a grep card says how many matches it found. Tap or click a card to expand it and see the full inputs and result.

Two cards open on their own:

• Task lists expand automatically — a to-do list is the agent’s plan for the turn, rendered as a checklist with a done/total count in the header. Completed items are ticked, the current item is marked in progress.
• Failures expand automatically and stay open, so the error is in front of you without a tap. Collapse it yourself and it stays collapsed.

Tool-specific bodies. Expanded cards render the result in a form that fits the tool: file edits show a colored diff with a +added -removed count, directory listings show entries with folder markers, web searches show titled results with their host, and grep results group matches under each file. Everything else falls back to the raw text.

​

Composer keys

The message box supports these keys across Desktop, the web client, and iOS:

Key	Desktop & web	iOS
Return	Insert a line break by default; configurable in Settings	Insert a line break by default; configurable in Settings
Shift+Return	Insert a line break	Insert a line break
Cmd+Return	Send	Send
Shift+Tab	Insert a line break	Insert a line break
Tab	Move focus out of the box	Move focus out of the box

On iOS a hardware keyboard’s Return is the natural newline and Cmd+Return sends — matching the send button. Plain Tab is always left to focus navigation so keyboard and screen-reader users can move out of the composer.

​

Telegram and WhatsApp

Connect your agent to a messaging app and chat with it just like you would with a friend. Send a message to your bot on Telegram and the agent responds in the same thread.

Setting this up takes a few minutes:

1. Create a bot on the messaging platform
2. Add the bot token to Desktop
3. Configure which agent handles messages from that bot

Once connected, your agent is always reachable — from your phone, desktop, or anywhere the messaging app runs.

Connect a messaging app

Step-by-step setup for Telegram, WhatsApp, and more.

​

WebSocket API

For developers who want to integrate agents into their own applications, the WebSocket API gives you full programmatic access.

​

Connecting

ws://localhost:9200/ws/chat?token=<your-chat-token>

Authenticate with a token in the query string. See HQ Chat WebSocket for full connection details.

​

Message flow

The protocol uses a simple request-response pattern over WebSocket:

1. Send a message — include the agent ID, a channel ID, a conversation ID, and your text
2. Receive streaming events — the server sends events as the agent works (text_delta, tool_use_start, tool_result, etc.)
3. Receive done — a done message signals the response is complete

// Send a message
{
  "type": "message",
  "id": "req-1",
  "agentId": "default",
  "channelId": "my-app",
  "conversationId": "conv-1",
  "text": "Summarize the latest logs"
}

// Receive streaming events
{ "type": "event", "id": "req-1", "event": { "type": "text_delta", "text": "Looking" } }
{ "type": "event", "id": "req-1", "event": { "type": "text_delta", "text": " at the" } }
{ "type": "event", "id": "req-1", "event": { "type": "text_delta", "text": " logs..." } }

// Stream complete
{ "type": "done", "id": "req-1" }

You can also cancel an in-flight request by sending { "type": "cancel", "id": "req-1" } and handle errors via { "type": "error" } messages.

Full API Reference

Complete WebSocket protocol spec, message types, and authentication details.

​

Sessions

Every conversation is persisted as a session. When you send a message to an agent, it sees the full history of that conversation — so it maintains context across messages without you repeating yourself.

Sessions are stored as append-only JSONL files. Each message, tool call, and response is recorded in order. This means your conversation history is durable and can be inspected if needed.

Sessions are scoped by agent and conversation ID. A chat in Desktop and a chat on Telegram are separate sessions, even if they’re with the same agent.

​

Streaming

Responses arrive in real time as the agent works. You don’t wait for the full response to be generated — you see progress as it happens:

• Text chunks appear word by word as the model generates them
• Tool use shows up when the agent decides to call a tool, as a collapsed card with the tool name and a short summary of its input
• Tool results update the same card when the tool finishes, showing what came back (see Reading tool activity)
• Thinking appears only when the model supplies a thinking block

This streaming experience works across all three chat methods — Desktop, messaging apps, and the WebSocket API.