# October documentation

> October is infrastructure for supervised AI collaboration. Use it to run, connect, and supervise real AI agents across repositories, terminals, applications, machines, and people.

Website: https://www.october.dev/
Download: https://www.october.dev/download
Concise agent index: https://www.october.dev/llms.txt
Complete agent context: https://www.october.dev/llms-full.txt

## What October is

October is a desktop runtime and coordination layer for long-running technical work. It is useful when a job crosses more than one agent, application, repository, machine, person, or day.

October Desktop supports 32 local agent harnesses in one workspace. Connected harnesses can discover peers, exchange scoped context, delegate tasks, review one another, and coordinate across machines.

A conventional chat interface treats work as one linear conversation. October treats work as an operation. The spatial canvas shows participants and resources. Agent Intercom lets connected agents discover peers, exchange scoped context, divide work, report status, and ask a human operator for decisions.

October is broader than a coding tool. The same operating model can coordinate software releases, technical research, data gathering, backups, archives, estate administration, insurance, bank paperwork, email exports, and other work that spans several systems and requires human review.

## Quickstart

### 1. Install October Desktop

Download October for macOS, Windows, or Linux from https://www.october.dev/download. The Linux release is an x64 AppImage (auto-updates); an x64 DEB package is available for Debian and Ubuntu (including 24.04, or if the AppImage will not launch).

Every platform can also download the latest release from a terminal. For Linux (AppImage — recommended, auto-updates):

```sh
curl -fL "https://october.dev/api/download?platform=linux" -o "October-x64.AppImage"
chmod +x October-x64.AppImage
./October-x64.AppImage
```

Or the DEB package (system install, manual updates):

```sh
curl -fL "https://october.dev/api/download?platform=linux-deb" -o "October-amd64.deb"
sudo apt install ./October-amd64.deb
```

The stable October endpoint redirects to the newest published release, so the command does not need a version number. Sign in, then continue using existing provider accounts and local agent credentials.

### 2. Open the work

Open an existing project or create a scratch workspace. A workspace can hold agent terminals, chats, documents, notes, browsers, code, previews, and application surfaces.

### 3. Add an agent

Launch a supported harness in a terminal or chat node. The agent remains attached to its own working directory, runtime, provider account, tools, and credentials.

### 4. Add another participant

Add another agent, document, application, or human collaborator. Draw connections only between the nodes that need to share context or control.

### 5. Define the outcome

Describe the desired result, constraints, and review standard. Watch the plan, tasks, messages, and activity. Intervene when needed and approve the final result yourself.

## Core concepts

| Concept | Meaning |
| --- | --- |
| Operation | The complete unit of work: outcome, people, agents, tasks, resources, machines, dependencies, activity, and current state. |
| Canvas | The spatial supervision view. Position communicates role and connections communicate allowed collaboration. |
| Node | A live participant or work surface, such as an agent terminal, chat, document, browser, preview, note, or editor. |
| Connection | An explicit relationship. Agent connections create peers. Resource connections scope context and control. |
| Harness | The real agent process or provider-specific interface that October runs and coordinates. |
| Agent Intercom | The coordination layer for peer discovery, messages, task state, selected context, status, and human escalation. |
| Operator | A person who sets scope, watches activity, handles approvals, redirects work, reviews outputs, and decides. |

## Agent Intercom

Agent Intercom is exposed to supported agents through MCP and native harness integrations. It gives each agent a node identity and a scoped view of the peers and resources connected to that node.

Agent Intercom provides:

- peer discovery through `list_peers`
- recent peer summaries through `get_peer_context`
- direct questions, findings, handoffs, and mid-turn nudges through `message_peer`
- queued delivery through `check_inbox`
- visible canvas topology through `list_canvas`
- shared work through `add_task`, `claim_task`, `complete_task`, and `list_tasks`
- dependency sequencing through `get_node_status` and `wait_for_nodes`
- human decisions through `ask_user`
- agent creation through `add_terminal` and `add_chat`
- safe delivery through `send_to_node`
- explicit context relationships through `connect_nodes` and `disconnect_nodes`
- visible plans through `create_plan` and `update_plan_item`

Messages to a busy agent are queued until the process can safely receive them. Agents can mark a message as requiring a reply or allow it to expire when late delivery would be useless.

October does not merge every process into one unrestricted context. Peer information is bounded and summarized. Connections determine which agents and resources can collaborate.

## Agent workflows

A workflow is a graph of live agents and work surfaces. Nodes remain visible, inspectable, and interruptible. Connections express collaboration. The task board records ownership, dependencies, and completion.

Recommended workflow:

1. State the outcome, constraints, and review criteria.
2. Break independent work into self-contained tasks.
3. Create one agent per genuinely parallel workstream.
4. Use isolated git worktrees for simultaneous edits in one repository.
5. Record dependencies on the shared task board.
6. Connect agents that need to communicate directly.
7. Let agents share findings and ask one another questions.
8. Watch status, messages, outputs, and approvals.
9. Redirect, interrupt, or rescope work when evidence changes.
10. Review the actual outputs and make the final decision.

### Example: software release

- Frontend agent: implement UI changes and report changed routes.
- Backend agent: update the API and publish the response contract.
- Server agent: wait for both agents, deploy a preview, and run integration tests.
- Documentation agent: update user and agent references after the contract stabilizes.
- Human operator: review diffs and previews, handle approvals, and authorize production.

### Example: technical administration

- Research agent: inventory accounts, providers, contacts, and deadlines.
- Document agent: classify paperwork and record missing evidence.
- Backup agent: export email, phone, and photo archives with provenance.
- Finance agent: reconcile bank and investment records.
- Second human operator: join from another computer to review and provide decisions.
- Primary operator: approve every sensitive action and final submission.

## Multiplayer

October multiplayer lets people and agent processes participate in the same operation from different computers.

Shared operational state can include canvas layout, connections, presence, cursors, agent activity, task ownership, dependencies, messages, summaries, and escalation requests.

Each host retains control of its local repositories, worktrees, terminal processes, application runtimes, provider accounts, keys, and credentials. A remote collaborator can operate the shared canvas without receiving unrestricted access to another computer.

Multiplayer is not a shared group chat. It is shared supervision of a spatial system whose participants can work and communicate across multiple axes.

## Canvas and IDE mode

Use the spatial canvas to see the complete operation. Arrange agents, resources, and people by role or workstream. Draw connections to make context and ownership visible.

Use focused IDE mode when one terminal, chat, code editor, browser, or preview needs full attention. Return to the canvas without losing the surrounding state.

- Canvas mode: plan, delegate, connect, and supervise.
- Focused mode: implement, inspect, debug, review, and intervene.

Common node types include:

- agent terminal
- agent chat
- document
- browser
- live application preview
- code editor
- sticky note
- video editor
- slide deck

## Supported harnesses

October Desktop supports these local agent harnesses:

- October
- Claude Code
- Codex
- Cursor
- Grok
- Muse Code
- opencode
- Hermes
- Pi
- OMP
- Gemini
- Cline
- Kimi Code
- Qwen Code
- Goose
- DeepSeek
- Freebuff

Integration depth can differ by harness version and operating system. October checks capability before launch and should refuse visibly when a required coordination integration is unavailable.

October's own harness can use the signed-in October session instead of requiring a separate provider key.

DeepSeek joins Agent Intercom from a chat node. Freebuff runs as a terminal-only harness, but its current CLI does not expose an integration seam for peer tools.

## Human control

October provides coordination and visibility. It does not transfer responsibility to the agent group.

- Scope context with explicit connections.
- Keep local credentials on their owning host.
- Use isolated worktrees for parallel repository edits.
- Require human decisions for consequential, ambiguous, or irreversible actions.
- Review files, diffs, tests, previews, documents, and external side effects.
- Interrupt agents that drift, loop, duplicate ownership, or request unsafe permissions.
- Treat activity status as evidence of work, not proof of correctness.

## Troubleshooting

### An agent does not appear as a peer

Confirm the agent was launched from an October-managed terminal or chat. Confirm its harness version supports Agent Intercom, then confirm a canvas connection exists between the intended peer nodes. Restart the agent after integration changes.

### A message is queued

The target agent is busy or waiting for human input. October queues the message instead of typing over active work. Do not send duplicates.

### Two agents are editing the same repository

Use isolated worktrees and distinct ownership. Merge results only after review and dependent verification.

### An agent needs a document or application

Add the resource to the canvas and connect it to the agent. This creates a visible, scoped context relationship.

### A collaborator cannot reach a local process

Confirm the host October app is online, the process is running, the node is present, and the intended cross-machine connection exists. Local processes remain owned by their host.

## Product answers

### Is October only for coding?

No. Coding is one use case. October is for technical work that needs several agents, tools, machines, people, or days.

### Does October provide its own model?

No. October coordinates the agent harnesses and provider accounts the user already has.

### Is October just an MCP server?

No. October is a desktop runtime and collaboration layer. Agent Intercom uses MCP and native harness integrations to expose coordination capabilities, but the product also includes the operating system, canvas, process supervision, shared state, multiplayer, and human control.

### How is October different from several terminal tabs?

Separate tabs do not share a consistent model of peers, tasks, ownership, dependencies, messages, selected context, or current system state. October adds that operational model for both agents and people.

### Who makes the final decision?

The human operator. Agents propose and execute. October coordinates and exposes state. People set scope, review results, handle approvals, and decide.