Activities: the mode you're working in.
Real collaboration has modes. A songwriting session isn't one conversation — it's brainstorming, then lyric drafting, then arrangement, each with its own focus, process, and definition of done. An Activity is that mode, made explicit: a structured way of working that you and the agent enter together, stay in while it's useful, and switch out of when the work changes shape.
When an activity is active, it reshapes the agent's focus for the whole conversation — the goal, the process, and the expected output are in front of the agent on every turn, not just when a skill happens to load. It works in project context: the mode is applied to your files, not in the abstract.
The playbook
Every activity is defined by a playbook — a markdown file with a deliberately simple structure:
- Description — what this mode is for.
- Input — what the work needs to start (a concept, a draft, source material).
- Output — what done looks like (a lyric sheet, a structured outline, a review).
- Process — the steps, in order, including where to pause for the human.
- Information index — resources and references the mode draws on.
Like everything in GoTo Agents, the playbook is visible, editable markdown. If the agent runs a brainstorm differently than you'd like, you don't tune a prompt in the dark — you edit the process section of the playbook.
Switching modes, mid-conversation
Activities are entered and exited inside a conversation — no new
session, no context loss. Either side can drive: you can ask to start
brainstorming, or the agent can propose it — it has a
switch_activity tool that starts, switches, or ends the active
mode. End an activity and the same conversation continues, mode-free, with
everything you produced still on the table.
This is the piece that makes activities feel like collaboration rather than configuration: "let's move from brainstorming into drafting" is one sentence, and both of you are now working the drafting playbook against the same project files and shared memory.
Skills vs Activities vs Tasks
GoTo Agents has three ways of packaging "things agents do," and the distinction is worth thirty seconds:
| What it is | Lifetime | Analogy | |
|---|---|---|---|
| Skill | How to do something. Packaged knowledge the agent loads when a task calls for it. | Picked up and put down within a turn or two. | Pulling a manual off the shelf. |
| Activity | A mode we're working in. A playbook that reshapes the conversation toward a kind of output. | Persists across turns until switched or ended. | Moving to the whiteboard for a brainstorm. |
| Task | A structured one-shot execution. A parameterized definition that runs headless and returns validated JSON. | One run, with a persisted execution record. | Sending a work order. |
Rules of thumb: if the agent should know it, make a skill. If you and the agent should work in it, make an activity. If software should invoke it and consume the result, make a task.
Where it lives
core/activity_manager.py— activity definitions, files, and lifecycle.core/switch_activity_tool.py— the in-conversation mode switch.- Activity prompt templates — editable in settings (
activity_prompt,discovery_activity_prompt), so how a mode is presented to the agent is itself user-editable markdown.