Using CoWork from WhatsApp and Other Channels

This guide explains how to use CoWork from remote chat channels such as WhatsApp, Telegram, Slack, Discord, and other configured messaging integrations.

It focuses on daily usage: starting work, following up, stopping tasks, using temporary sessions, invoking skills, and getting scheduled results back in chat. For setup, see Channel Integrations. For per-channel features and best practices, see Channel User Guides. For the lower-level lifecycle model, see Gateway Message Lifecycle.

Mental Model

Think of each chat as a remote control for CoWork.

You can:

• send a normal message to start a task
• send another normal message to add context to the current task
• use commands when you want to control the task lifecycle
• use skill slashes when you want a specific workflow
• receive progress, approvals, final answers, and scheduled results in the same chat

The most important rule is simple: ordinary text during a running task is treated as a follow-up, not as a new task.

If you want a new task, send /new. If you want to stop the current task, send /stop.

Starting a Task

Send the task directly:

Update the README with the new onboarding flow.

Research the latest pricing for these three tools and summarize the differences.

Draft a customer reply based on the last email thread.

CoWork will route the message into the selected workspace for that chat. If no workspace is selected, it may ask you to choose one or use the channel's default behavior.

Best practices:

• Be specific about the desired output.
• Mention files, folders, links, or constraints up front when you know them.
• Use follow-up messages for corrections or extra context while the task is still running.
• Use /new before changing topics.

Following Up on a Running Task

When a task is active, normal chat messages become follow-ups:

Also make sure the examples use TypeScript.

Ignore the old API section. That is deprecated.

Use the shorter version and keep it under 500 words.

This is useful when you notice something mid-run. You do not need a command for ordinary context, corrections, or extra requirements.

If you want to make the follow-up more explicit, use:

/queue Add tests for the retry behavior too.

Use /queue <message> when you want the text to clearly be handled as task input rather than a command or a new topic.

Steering a Task

Use /steer for high-priority guidance during an active task:

/steer Prioritize correctness over speed. Do not change public APIs.

/steer Stop editing docs and focus only on the failing test.

Use this for corrections that should affect the current run immediately. For ordinary extra details, a normal message is usually enough.

Best practices:

• Keep steering messages short and directive.
• Use /steer for constraints, not for unrelated new work.
• If the task is going in the wrong direction entirely, use /stop and then start again.

Starting Fresh Without Stopping the Old Task

Use /new or /newtask when you want the next message to start a new task:

/new

Then send the new request:

Now write a short launch announcement for the feature.

/new unlinks the chat from the current task. It does not cancel the old task. This is useful when a task can continue in the background but you want to move on in the chat.

Best practices:

• Use /new when changing topics.
• Use /new before asking an unrelated question while a task is still running.
• Use /stop instead if the old task should not continue.

Stopping a Task

Use /stop or /cancel to cancel the active task:

/stop

/cancel

After cancellation, CoWork clears that chat's task association so late updates from the stopped task are not sent back into the chat.

Best practices:

• Use /stop when the task is wrong, obsolete, or no longer worth completing.
• Use /new instead when the task may continue but you want the chat to move on.
• After /stop, send a fresh task message with the corrected request.

Temporary Sessions

Use /new temp for scratch work:

/new temp

Then send a task:

Prototype a small Node script that parses this CSV shape.

Temporary sessions are useful for experiments, one-off analysis, and work that should not attach to a normal project workspace.

CoWork hides temporary workspace paths from chat replies and from /workspaces so the workspace list stays focused on real user workspaces.

Best practices:

• Use /new temp for scratch prototypes, quick writing drafts, isolated analysis, or throwaway experiments.
• Use a real workspace when the task should edit project files or use project context.
• Do not expect temporary sessions to be a long-term project home.

Checking Status

Use /status for gateway and task status:

/status

Use /task for a current task snapshot:

/task

Use /queue to inspect queued work:

/queue

Best practices:

• Use /task when you want to know what CoWork thinks it is currently doing.
• Use /queue when multiple tasks or follow-ups may be waiting.
• Use /status when you are checking whether the channel is connected and responsive.

Pausing and Resuming

Use:

/pause

/resume

Pause is useful when you need time to review, provide missing context, or stop the agent from continuing temporarily without cancelling the task.

Best practices:

• Use /pause when you intend to continue the same task.
• Use /stop when you do not want the task to continue.
• Send any missing context before /resume.

Background Tasks

Use /background, /bg, or /btw to start a task that should not take over the current chat task:

/background Prepare a short competitor summary for Linear, Asana, and Trello.

/bg Check whether the docs mention the old product name.

/btw Draft a weekly update from this workspace context.

Background tasks are useful for side work. They should be self-contained because they are intentionally unlinked from the active chat task.

Best practices:

• Use background tasks for independent work.
• Include enough context in the command itself.
• Do not use background tasks for urgent corrections to the active task; use a normal follow-up or /steer.

Workspace Selection

Use /workspaces to list available workspaces:

/workspaces

Use /workspace to select one:

/workspace 2

/workspace cowork

Temporary scratch workspaces are hidden from /workspaces.

Best practices:

• Select the workspace before asking CoWork to edit files.
• Use clear workspace names where possible.
• Use /new temp instead of adding a temporary folder to the normal workspace list.

Commands and Help

Use /help for a compact reminder:

/help

Use /commands for the fuller command catalog:

/commands

Some channels support category views:

/commands task

Best practices:

• Use /help when you only need the basics.
• Use /commands when looking for less common controls.
• If you type an unknown slash command, CoWork will tell you it is unknown instead of treating it as a task.

Skill Slash Commands

Skills are specialized workflows. Use /skills to see what is available:

/skills

Toggle a skill with:

/skill skill-id

Run an enabled skill with its slash form:

/simplify Make this proposal shorter and clearer.

/batch Update every docs page that still uses the old term.

/llm-wiki Build a research vault for agent workflow patterns.

Enabled skills can also be invoked by their skill slug:

/react-best-practices Review this component architecture.

Best practices:

• Use skill slashes when you know the workflow you want.
• Use normal language when you want CoWork to choose the approach.
• Keep /skill <id> for toggling skills; use /<skill-slug> args to run one.
• If a skill is disabled, enable it first or ask CoWork to use another approach.

Approvals

When CoWork asks for approval, respond with:

/approve

or:

/yes

To reject:

/deny

or:

/no

Best practices:

• Read approval prompts carefully before approving.
• Use /deny when the requested action is too broad, risky, or no longer needed.
• Add a short follow-up after denial if you want CoWork to try a safer alternative.

Scheduled Results in Chat

Scheduled tasks can deliver results back to a channel. The result is formatted and delivered through the same path as normal chat replies.

Examples:

/schedule Every weekday at 9am, summarize new issues in this repo.

/brief schedule morning

Scheduled tasks should produce the final result as task output. CoWork handles sending that output to the selected chat.

Best practices:

• Make scheduled prompts explicit about the desired final answer.
• Use deliverOnlyIfResult when empty successful runs should stay quiet.
• Include the relevant chat transcript variables only when the recurring job needs recent chat context.
• Avoid asking the scheduled task to message you directly; delivery is handled by the scheduler.

WhatsApp-Specific Tips

WhatsApp supports a few conveniences:

• natural shortcuts such as help, status, new task, new temp, stop, queue ..., and background ...
• typing indicators while CoWork is working
• editable progress messages, so repeated progress updates can update one message instead of spamming the chat
• self-chat mode for using your personal "Message Yourself" thread
• response prefixes when you want bot replies to be visually distinct

Best practices:

• Use self-chat mode when connecting your personal WhatsApp number.
• Set a short response prefix if your own messages and CoWork replies are hard to distinguish.
• Use /new temp for scratch work instead of creating random temporary folders.
• Use /commands when you forget the exact slash form.

Telegram Tips

Telegram exposes the core gateway commands in the bot's / menu after the bot connects.

Useful commands:

• /new and /newtask start the next message fresh.
• /stop and /cancel stop the active task.
• /queue message adds an explicit follow-up to the current task.
• /steer guidance sends high-priority guidance to the active task.
• /background prompt starts unlinked side work.
• /commands shows the full remote command catalog.

Best practices:

• Use the Telegram / menu for common controls.
• In groups, check the configured routing mode. Some groups route only mentions or commands.
• Reply to the bot or mention it when using Telegram group modes that require a mention.
• Telegram can show draft-style streaming for assistant text; concise follow-ups keep the chat easier to read.

Discord Tips

Discord supports native slash commands for the core lifecycle controls.

Useful commands:

• /new mode:temp starts a scratch temporary session.
• /stop cancels the active task.
• /commands category:task control browses command groups.
• /queue message:... sends an explicit follow-up.
• /steer guidance:... steers the active task.
• /background prompt:... starts unlinked side work.
• /task prompt:... remains a compatibility shortcut for starting a task directly.

Best practices:

• Use /task prompt:... only when you want to start task text from Discord's native slash UI.
• Use /status for current state; /task in normal text channels is the gateway task snapshot command when delivered as text.
• In servers, confirm the bot has access to the channel and that the server is allowed by the channel configuration.
• In threads, CoWork preserves thread context where the adapter can provide it.

Slack Tips

Slack can route messages from DMs, mentions, and registered slash commands. CoWork can handle the command text once Slack delivers it, but Slack slash commands must be registered in the Slack app configuration first.

Recommended Slack slash commands:

/help
/commands
/status
/workspaces
/workspace
/new
/newtask
/stop
/cancel
/pause
/resume
/queue
/steer
/background
/skills
/skill
/schedule
/brief
/approve
/deny
/models
/providers
/agent

Manifest-style snippet:

features:
  slash_commands:
    - command: /new
      description: Start the next CoWork message fresh
      usage_hint: "[temp]"
      should_escape: false
    - command: /stop
      description: Stop the active CoWork task
      should_escape: false
    - command: /commands
      description: Browse CoWork commands
      usage_hint: "[category]"
      should_escape: false
    - command: /queue
      description: Show queue status or add a task follow-up
      usage_hint: "[clear|message]"
      should_escape: false
    - command: /steer
      description: Send guidance to the active task
      usage_hint: "<guidance>"
      should_escape: false
    - command: /background
      description: Start unlinked side work
      usage_hint: "<prompt>"
      should_escape: false

Repeat that pattern for the remaining core commands you want visible in Slack. In Socket Mode setups, keep the existing Socket Mode receiver and app tokens; the command entries just make Slack deliver those slash payloads to CoWork.

Best practices:

• Register the core slash commands in the Slack app manifest or app settings.
• Use Slack DMs for personal work and channel mentions for shared work.
• Prefer /queue message or /steer guidance for active-task input in busy channels.
• Slack supports message edits for curated progress, so one progress message can be updated instead of sending repeated status messages.

Common Patterns

Start a project task:

/workspace cowork
Update the channel docs to mention editable WhatsApp progress.

Add context while it runs:

Also mention that /stop cancels and /new only starts fresh.

Steer the task:

/steer Keep this end-user facing. Avoid implementation details.

Move on without cancelling:

/new
Draft a short changelog entry for the same feature.

Cancel and restart:

/stop
Rewrite the request from scratch: focus only on WhatsApp, not all channels.

Use scratch mode:

/new temp
Create a quick outline for a support article about remote commands.

Run a skill:

/simplify Make this announcement clearer for non-technical users.

Run side work:

/background Check if any docs still mention the old command list.

Troubleshooting

If CoWork does not respond:

• send /status
• check that the channel is enabled
• check self-chat or group routing settings
• confirm the sender is allowed by the channel security mode
• use /workspaces to confirm the chat has a usable workspace

If a message went to the wrong task:

• use /new before changing topics
• use /task to inspect the active task
• use /stop if the active task should be cancelled

If a slash command does not work:

• send /commands
• check spelling and aliases
• use /skills if it is a skill command
• enable the skill with /skill <id> if needed

If progress messages look noisy:

• prefer WhatsApp or channels with editable progress where available
• use concise follow-ups
• avoid repeatedly sending unrelated messages into an active task

Quick Reference