Research: Dynamic Workflows as an optional execution backend for Squad ceremonies

Ouverte
#2,162 0 commentaires 0 réactions 0 personnes assignées Voir sur GitHub

Les mainteneurs répondent en général sous 1 jour

Personne n'a encore pris cette issue.

Évaluation

Difficulté
5/5
Temps estimé
Plus d'une semaine
Accessibilité débutants
35/100
Type d'issue
Fonctionnalité
Clarté
Plutôt claire
Activité
Active
Stack technique
github, typescript
Domaine
ai, cli, devtools

Piste de recherche

Start by reading the current ceremony specification and the entry points for Ralph, squad loop, and schedule.json, then compare them with the Dynamic Workflows concepts and limits in the linked GitHub documentation. Use one existing ceremony for an opt-in adapter spike, keeping irreversible actions out. Done means a capability mapping, working comparison, recovery and approval demonstrations, and a recommendation for the portable model.

Rédigé par le modèle d'indexation à partir du texte de l'issue.

Description

post-2.0

Context

GitHub recently introduced Dynamic Workflows for Copilot CLI, the Copilot app, and the Copilot SDK. Extensions can define orchestration in code while agents handle reasoning: sequential and parallel stages, conditional paths, structured results, verification, checkpoints, pause/resume, and resource limits.

This overlaps with capabilities Squad already has or is defining: ceremonies, /fleet coordination, squad loop, Ralph, scheduling, recovery, verification roles, and rate/resource governance.

For the next version, investigate whether Dynamic Workflows can become an optional execution backend for Squad, without making Squad's portable model dependent on this GitHub feature.

References:

Qualifications: the feature is in public preview. Deterministic orchestration does not make agent outputs deterministic. Human interaction depends on the client. AI-credit limits are approximate, not hard spending ceilings. Scheduling should be investigated as a host/automation integration rather than assumed to be a native workflow primitive. Reusing a workflow definition is distinct from resuming a run with saved results.

Areas to investigate

1. Ceremonies as executable workflows

A ceremony could describe a portable process:

research -> challenge -> plan -> approve -> implement -> verify

A Copilot adapter could translate that ceremony into a Dynamic Workflow: workflow code controls execution, while Squad agents provide reasoning at specific stages.

Compare the current ceremony specification with actual workflow primitives. Identify existing semantics, gaps, and potential new portable concepts. Do not assume ceremonies are already executable task graphs.

2. Reusable multi-agent coordination patterns

Examples:

parallel review -> challenge -> reconcile -> final result

research -> architecture -> plan -> parallel implementation -> test -> security review -> approval -> PR

Determine what belongs in the portable model versus the adapter: structured stage contracts, dependencies, conditional transitions, failure handling, bounded retries, and parallel-work isolation. Parallel agents must not silently overwrite shared files or team state.

3. Dynamic Workflows as an execution backend

Evaluate:

Squad ceremony/task graph -> execution adapter -> Copilot Dynamic Workflow

The adapter should sit alongside existing execution mechanisms, not replace them by default. Compare preservation of agent identity, charters, routing, permissions, shared decisions, and persistent memory.

Define a backend capability contract. Unsupported semantics must be surfaced explicitly, not silently skipped or weakened. Keep preview-specific APIs inside the Copilot adapter.

4. Verification and approval gates

Could Challenger, Worf, and fact-checker become required execution stages rather than instructions an orchestrating agent is expected to remember?

implementation -> security review -> adversarial review -> tests -> consensus/gate -> human approval

Investigate portable concepts for required reviewers, evidence, approval, rejection, disagreement, and escalation. Distinguish model consensus from executable checks and human authorization: agent agreement is not proof of correctness.

Define behavior when a reviewer fails, returns malformed output, or disagrees, and when a client cannot present an approval prompt. Missing approval must not become implicit approval.

5. Long-running and scheduled work

Compare backend capabilities with Ralph, squad loop, schedule.json, recovery/checkpointing, rate/resource governance, and unattended execution.

Investigate whether the backend can own execution mechanics while Squad retains portable intent and policy. Separate scheduling/triggering from workflow execution.

Assess cancellation, interruption, retry, resume, and reuse of completed results. Determine how resumed runs avoid duplicate side effects such as publishing, PR creation, or decision writes. Document what happens if the ceremony, repository revision, or workflow definition changes between pause and resume.

Key architectural question

Squad defines WHO + WHAT + PROCESS: agents and roles, tasks, ceremonies, dependencies, policies, and gates.

Execution backends implement HOW: dispatch, parallel execution, conditional transitions, runtime checkpointing/resume, and resource accounting/enforcement. Scheduling may come from the host or a separate trigger adapter.

The intended semantics of a dependency, gate, or policy remain Squad-owned; the backend supplies the mechanism. Dynamic Workflows could be one backend, with a capability-based path for non-Copilot runtimes.

Research questions

  • How closely do existing ceremonies map to Dynamic Workflow primitives?
  • Which orchestration concepts should remain portable?
  • Do we need explicit gates, approvals, consensus rules, parallel stages, dependencies, and structured stage contracts?
  • Could schedule.json reference a ceremony and inputs rather than describe orchestration itself?
  • Which runtime responsibilities can be delegated, and which must remain Squad-owned?
  • Can an adapter preserve charters, memory ownership, routing, and governance without duplicating Squad's runtime?
  • How do backend limits relate to Squad rate governance, including approximate credit ceilings and work already in flight?
  • What permissions apply to agents versus extension code? GitHub documents that extension code can execute outside agent permission prompts; how should Squad governance cover that boundary?
  • What guarantees exist for checkpoint persistence, retries, cancellation, and side-effect idempotency?
  • How do approval and unattended execution behave across CLI, app, SDK, and non-interactive clients?
  • How do we avoid coupling the specification to a preview API, and what does this imply for future non-Copilot backends?

Suggested next-version spike

Select one existing ceremony, or the closest supported equivalent, and implement an opt-in Dynamic Workflow adapter. Candidate:

research -> parallel specialist review -> Challenger -> plan approval -> implementation -> Worf review -> tests -> human approval

Compare:

  1. Current Squad execution.
  2. Dynamic Workflow execution.
  3. The smallest portable representation supporting both.

Use the same bounded task and inputs. Keep publication, merges, and other irreversible actions out of the initial spike. Include approval before implementation, not only after it.

Deliverables / completion criteria
  • A mapping of ceremony semantics to backend capabilities, including unsupported features and gaps.
  • A small working adapter and example preserving agent identity, charters, and ownership rules.
  • A comparison of behavior, orchestration overhead, observed latency and AI-credit usage, observability, and recovery; record results rather than assume savings.
  • Demonstrations of success, reviewer rejection/disagreement, failed checks, pause/resume, reached resource limits, and unavailable approval channels.
  • Evidence that required gates cannot be bypassed and resumed stages do not repeat completed side effects.
  • A recommendation: adopt an optional backend, extend the portable model first, or defer, with preview/API risks and implications for non-Copilot runtimes.

Non-goals

  • Replacing Squad orchestration or removing human oversight.
  • Making Dynamic Workflows mandatory.
  • Redesigning all ceremonies, scheduling, or Ralph in this spike.
  • Treating agent agreement as a substitute for tests or authorization.

The goal is to determine whether Dynamic Workflows can serve as a runtime target for Squad's portable coordination model, not to couple Squad to one execution engine.

CC @bradygaster

Langage dominant
TypeScript
Étoiles
3.4k
Forks
516
Merge moyen
1 j 15 h
PR mergées (30 j)
116

Préparer son environnement

Par où commencer

  1. Lisez l'issue en entier, puis le guide de contribution du projet.
  2. Signalez en commentaire que vous la prenez — cela évite que deux personnes fassent le même travail.
  3. Forkez le dépôt et travaillez sur une branche.
  4. Ouvrez une pull request qui référence le numéro de l'issue.

Autres issues de github/squad

Toutes les issues de github/squad

Issues similaires

Plus d'issues TypeScript

Recevez les nouvelles issues par e-mail

Un résumé court des issues GitHub adaptées aux débutants.