Use one fabric_exec call with bounded role fan-out. Choose three to five roles that disagree usefully rather than duplicating one another, such as correctness, security, operability, maintainability, and requirements skepticism.
type CouncilOutcome =
| { role: string; status: "completed"; report: string }
| { role: string; status: "failed"; error: string };
const roles = [...new Set(
(JSON.parse(π.roles) as string[]).map((role) => role.trim()).filter(Boolean),
)];
if (roles.length < 3 || roles.length > 5) {
throw new Error("Council requires 3–5 distinct non-empty roles.");
}
await workflow.configure({
name: "Council review",
description: ${roles.length} independent perspectives with best-effort synthesis,
});
await phase("Deliberate", { total: roles.length + 1 });
const outcomes = await parallel(
roles.map((role) => async (): Promise => {
try {
const report = await agent(
Act as the ${role} council member. Independently analyze this task:\n\n${π.task},
{ label: role, tools: ["read", "grep", "find", "ls"] },
);
return { role, status: "completed", report };
} catch (error) {
return {
role,
status: "failed",
error: error instanceof Error ? error.message : String(error),
};
}
}),
{ concurrency: roles.length },
);
const completed = outcomes.filter(
(outcome): outcome is Extract<CouncilOutcome, { status: "completed" }> =>
outcome.status === "completed",
);
const failures = outcomes.filter(
(outcome): outcome is Extract<CouncilOutcome, { status: "failed" }> =>
outcome.status === "failed",
);
const coverage = { requested: roles.length, completed: completed.length };
if (completed.length === 0) {
return { status: "failed", coverage, failures, result: null };
}
if (completed.length === 1) {
return {
status: "partial",
coverage,
failures,
result: completed[0].report,
synthesisSkipped: "Only one role completed; another agent would add no diversity.",
};
}
try {
const result = await agent(
Synthesize these completed reports into one decision. Reject unsupported claims, preserve material disagreements, attribute each concern to its role. Do not infer the views of failed roles.\n\nTask:\n${π.task}\n\nReports:\n${JSON.stringify(completed)},
{ label: "council synthesis", tools: ["read", "grep", "find", "ls"] },
);
return {
status: failures.length === 0 ? "success" : "partial",
coverage,
failures,
result,
};
} catch (error) {
return {
status: "partial",
coverage,
failures,
result: null,
synthesisError: error instanceof Error ? error.message : String(error),
fallback: completed,
};
}
Pass the task as `strings.task` and the JSON role array as `strings.roles`. Successful synthesis returns only the compact decision, coverage, and failures. Raw completed reports return only when synthesis fails; one surviving role returns directly without spending another agent call.
Concurrent calls can overshoot an observational `tokenBudget` because usage settles afterward. Reserve at least `roles.length + 1` top-level agent calls when synthesis may run, and use a finite role set rather than relying on token accounting as a hard concurrent ceiling.
Status is `success`, `partial`, or `failed`. A partial result is usable evidence with named gaps and must not trigger an automatic whole-council rerun. If a missing perspective matters, retry that role with one plain agent using the original task and role; do not invoke a new council or rerun successful roles. Do not use a council for a lookup or a decision with no meaningful competing considerations.