Skip to main content

The Program Assistant

The Program Assistant is a chat on the program editor page that designs the program with you. It is driven by an ordinary agent — by default one called Program Manager — that edits the plan through its own tools while you talk. Phases and activities appear in the Plan pane as it works.

Plan a program with the assistant​

  1. Go to Build → Programs and select New program.
  2. In the Program Assistant pane on the right (the Assistant tab on a narrow screen), describe what you want to achieve — the goal, what success looks like, constraints, and any deadlines.
  3. Answer its questions. The assistant scopes the work first, then proposes phases and activities and adds them to the plan.
  4. Follow along:
    • A status line under the chat narrates what the assistant is adding.
    • Plan changes lists each change it made — additions, removals and edits to the program, its context, tags, knowledge and access.
    • The Plan pane updates with every change. You can edit anything yourself at the same time; what you are typing is never overwritten mid-edit.
  5. When a turn finishes and the plan is complete enough to run, the app tells you Your program is ready to run! and offers Run the first phase now?. You can also keep refining.
  6. Review the plan — especially each activity's assignee, prompt and acceptance criteria — then select Create and start Phase 1 or Create program.

Your first message creates the draft program and ties the chat to it, so everything the assistant does lands in that program. You can attach images to your messages if the assistant's model can read them.

warning

The draft is discarded if you leave the editor before selecting Create program or Create and start Phase 1.

Refine an existing program​

Open the program, select ⋯ → Edit program, and talk to the assistant in the same pane. The assistant knows which program it is working on: its name, status, goal, phases (with the active phase's activities) and recent program knowledge are given to it at the start of the chat. The conversation for a saved program is kept, so you can return to it later.

The Split into smaller activities recovery action on a failed activity brings you here with a ready-made request; select it in the chat to send it.

Which agent answers​

The picker above the chat, Program Assistant's agent, chooses who replies in this chat. It lists your project's agents plus platform-provided agents (marked · platform); short-lived test agents are hidden. Use platform default (…) shows which agent the default resolves to.

The picker can only be changed before the draft exists — that is, before your first message or your first edit to the plan. After that the chat stays with the agent it started with. When editing an existing program, the default agent is used.

The default is resolved in this order:

  1. Your own preference, if you have set one (through the API or the MCP tool set_program_agent_preference).
  2. An agent named Program Manager in your project, or a platform-provided one.
  3. Your organisation's default program agent.

If none of these exists, the platform creates a Program Manager agent in your project the first time you open the assistant, using an available model. If your project has no models, the assistant shows "No LLM available to provision the Program Manager. Configure an LLM in platform settings." Add a model under Resources → Models and try again.

The Program Manager is an agent you can edit​

The Program Manager has no hidden prompts — its instructions and tools are stored like any other agent's. To change how it plans programs, edit it under Build → Agents: change its system message, model or tools as described in Agents.

Program manager agent vs. the assistant's agent​

The Program manager agent field in the plan is a separate setting: it records which agent manages the program and is shown as Manager in the program header (Platform default when unset). It doesn't change who answers in the Program Assistant chat.

Build a program from a plan with MCP​

If you work in Claude Code or another MCP client connected to the Platform MCP server, the create_program_from_plan tool creates a complete program — phases, activities, dependencies, documents and approval checkpoints — from one structured plan.

{
  "name": "Onboarding flow refresh",
  "brief": "Ship the new onboarding flow with analytics.",
  "documents": [
    { "title": "Design spec", "content": "…", "doc_type": "spec" }
  ],
  "phases": [
    {
      "key": "build",
      "name": "Build",
      "execution_mode": "sequential",
      "activities": [
        {
          "key": "api",
          "name": "Add onboarding API",
          "description": "Implement the onboarding endpoints.",
          "acceptance_criteria": "A pull request with tests is open.",
          "assignee": { "agent": "Software Developer Agent" },
          "expected_artifact_types": ["pull_request"]
        },
        {
          "key": "ui",
          "name": "Build onboarding UI",
          "assignee": { "team": "Frontend Team" },
          "depends_on": ["api"]
        }
      ]
    },
    {
      "key": "launch",
      "name": "Launch",
      "activities": [
        { "key": "notes", "name": "Write release notes", "assignee": { "workflow": "Release notes" } }
      ]
    }
  ]
}

What to know:

  • Every phase needs a key and name; every activity needs a key and exactly one assignee — an agent, team or workflow, by name or id. Activities can't be assigned to a person this way.
  • The whole plan is checked before anything is created: unknown names, unknown depends_on keys and dependency cycles are rejected. If something fails part-way through, the half-built program is deleted.
  • Every phase except the last gets Checkpoint completion and an approval checkpoint named "Approve: phase name", so a person signs off each phase before the next starts. Set completion_mode on a phase to opt out, or set "checkpoint" on the last phase to have its result approved too.
  • For agent and team activities with acceptance criteria and no explicit prompt, the description and the acceptance criteria (as a "DEFINITION OF DONE" section) are combined into the prompt, so the agent knows what done means.
  • Documents are injected into runs by default.
  • Pass run_first_phase: true to start the first phase immediately.

The tool returns the new program's id, the ids of its phases, activities and documents, and a link to open it in the app.

Delegations from Claude Code​

The MCP tools delegate_task and run_workflow hand a single task or workflow run to the platform. They run as activities in a standing program named Claude Code delegations, so you can follow, answer and review them on the Programs page like any other activity. Runs started this way are labelled Claude Code delegation as their origin.