Action launcher

You are reading an initiative. You want the agent to draft plans for it. The action you want is two clicks away on a button at the top of the page, and the drawer that opens already knows what you are working on, which skills are appropriate at this point in the workflow, and what kind of starting context the agent should be given. You write a sentence about what you want, pick how the agent should run, and the work starts.

That is the action launcher. It is the entry point for almost every operation an agent runs on a record in Disco Parrot, and the part of the product that gets you from "looking at a record" to "agent working on the record" without scrolling through menus.

What the launcher offers

The launcher opens on a record (an initiative, a plan, a bug, a skill, a sandbox profile, a portfolio) and shows the skills that make sense at that record's current status. An initiative in Approved offers a different set than an initiative in In Progress; a bug in Triage offers triage-shaped skills, a bug in In Review offers review-shaped ones. The set comes from the status-scoped skill bindings on the entity's workflow, so the same admin decision that drives the columns on a board drives the menu in the launcher.

A few skills are always available regardless of the status the record is in. The team's most-used patterns (verify, review, create-pr, the ones every workflow needs) bypass the status bindings and show up alongside the status-specific options. The launcher reads as "here is what is right for this moment, plus the always-available basics."

The first time you open the launcher on a kind of record, your default mode is chat. The next time, the launcher remembers what you picked last (per entity type, per user, scoped to your browser) so opening it feels like picking up where you left off.

Three modes for one action

A skill can run in three shapes, and the launcher lets you pick which one fits.

Manual

The form-filling mode. You enter the fields a new record needs (a title, a project, a sprint, an owner) and the record is created without an agent involved. Use it when you know what you want and the agent does not need to be in the loop.

Chat

Opens a scoped conversation with the agent. The starting context you provide becomes the first message; the agent has the focal record (and its plans, bugs, and attachments) materialized into its sandbox the way the Built for query page describes. You read what it does and direct it from there. This is the right mode when the work is genuinely a conversation, not a checkpoint-able sequence.

Flow

Runs a multi-step Flow against the record. The launcher offers the templates that fit (drafting plans on an initiative, implementing a plan, fixing PR comments) and you pick parameters, an oversight mode, and a sandbox profile before launching. The work runs as a Flow with steps, transcripts, and a checkpoint surface; you do not stay in the launcher while it runs. Run a Flow & manage checkpoints covers what happens once it does, and Build a Flow is where the templates the launcher offers are authored.

A handful of operations always use the built-in skill

Review, verify, and create-pr need predictable ship paths, so the launcher routes them through the platform's default skill regardless of any binding configured for them. A tenant binding cannot redirect these three. The rest of the skill catalog is wide open to admin configuration.

Starting context, the input that becomes a first message

The starting-context field is a single textarea that does double duty. In chat mode, what you write becomes the first message to the agent. In flow mode, what you write becomes the userPrompt parameter the Flow passes into its first step. In both cases, it is the direction you give the work before it starts.

The right way to think about starting context is as the brief you would write for a colleague. A sentence about what success looks like. A pointer to where the work should land. A constraint that is not obvious from the record itself. The agent already has the record materialized into its sandbox along with the related plans, bugs, and attachments, so you do not have to re-explain what the record says; you explain what you want done with it.

Attachments travel with the launch

You can attach files alongside the starting context. PDFs, screenshots, design docs, sample data; up to 10 MB each, up to five files in a single launch. The attachments travel with the conversation or the Flow so the agent has them in its context from the first turn.

This is where you drop the spec the work is about, the broken log the bug is about, the screenshot of what you want changed, the dataset the analysis is about. The attachment is durable; if you send the conversation to the background and come back to it later, the files are still attached. If a Flow step needs to read them, it can.

Sprint pre-fill so the work lands where you wanted

When you launch the action on a sprint backlog (creating a plan or filing a bug while looking at a sprint), the launcher pre-fills the sprint picker with the sprint you are on, so the work you create lands in the right sprint without an extra click. The launcher forces manual mode in that case to make sure the sprint context is preserved across the launch; chat and Flow mode would silently drop the sprint binding without it.

Smart Action, resume or start new

Almost every detail page that mounts the launcher does it through a button called Smart Action. The button is named that way because it does not just open the drawer; it looks at what is already in flight on the record first, and prioritizes resuming that over starting something new.

When something is in flight

If there is an active chat on the record, an in-progress Flow run, or a paused checkpoint waiting on a decision, Smart Action's primary button is "Resume." Click it and you are taken straight to the active piece of work: the chat panel opens with the conversation restored, or the run timeline opens at the step that needs you. The launcher is still one click away through a dropdown next to the primary button, in case you want to start a second thread instead of continuing the first.

When nothing is in motion

If nothing is in flight, Smart Action's primary button opens the launcher directly. There is no resume to offer, so the only sensible action is to start something new.

One pattern across the product

This is the same context-awareness that drives the Command Center cards, focused down to one record. You are not picking from a list of work; you are looking at the record in front of you, and the button knows whether that record has work in flight on it.

Oversight: supervised or autonomous

For Flow launches, you pick one of two oversight modes.

Supervised

The default. The Flow runs as an interactive run, pausing at every checkpoint the template defines, waiting for you to approve or reject each step before it continues. You see the work as it happens; you can adjust direction in flight. This is the right shape when the work matters and review is the point.

Autonomous

Runs the Flow to completion without stopping at checkpoints. The Flow finishes in the background, the record updates, the audit log captures what happened, and you read the result when it is done. This is the right shape when the work is routine, when the template is one you trust, when the answer is "do this, tell me when it is done."

Autonomous mode requires the flows.run scope. Workspaces on the smaller plans default to supervised; the autonomous toggle is gated behind the entitlement.

What happens when you click Launch

The drawer is the entry point, not the workspace. Clicking Launch takes you out of the drawer and into the right place to work on what you just started.

A chat-mode launch

The drawer closes and the chat panel opens on the right side of the page, with the conversation already started, your starting context posted as the first message, and the agent's first turn either running or ready to read. You stay on the record you launched from; the chat panel is the surface, the record behind it stays in view.

A flow-mode launch

The drawer closes and the page navigates to the run's timeline on the Sessions index, where the steps are listed in order and the active one is highlighted. Supervised runs pause at the first checkpoint waiting for your approval; autonomous runs start working immediately and the timeline updates as steps complete. Either way, the work is now visible on its own page.

A manual-mode launch

The drawer writes the record (creates the plan, files the bug, registers the project), closes, and navigates to the new record's detail page. There is no agent loop to wait for; the work is done at the moment you save.

The work shows up on Command Center either way

Whatever mode you picked, the work now also shows up on your Command Center as a card. If you launched a chat and want to switch contexts while the agent works, send the conversation to the background; the card carries on tracking the run on the Command Center while you do something else.

Where the launcher opens from

The launcher is wired across the surfaces where records live. The launcher trigger is usually the Smart Action button at the top of a detail page, which is context-aware: when there is already an active conversation or a paused Flow on the record, the button prioritizes resuming it; when there is nothing in flight, it opens the launcher to start something new. This is the same pattern that powers the Command Center cards, applied to the record you are looking at.

Specific entry points across the product:

The same drawer, the same three modes, the same skills resolution; the entity in context changes, the rest is the same.

Sandbox profile, the run's home

A chat or a Flow takes a sandbox profile (the image, the tools, the runtime, the repos) before it can launch. The launcher shows a dropdown of the profiles you have access to and remembers your last pick. A manual create that does not need an agent (filing a bug, creating a project) skips the picker entirely.

If a Flow template requires a specific profile (one with the right runtime tools, the right repo mounts, the right managed commands), the launcher narrows the dropdown to only the profiles that match. You do not have to know the constraints to launch the right thing; the launcher knows.