Multi-Agent System Architectures

Classify a design as a single LLM call, deterministic workflow, tool-using agent, or multi-agent system based on its control flow and degree of autonomy.

Model a framework-neutral LLM agent as a perception-reasoning-action control loop in pseudocode.

Determine whether a stated application justifies multiple agents rather than a single agent or deterministic workflow.

Extract architectural quality attributes and operating constraints from a multi-agent system scenario.

Decompose a generic task into agent roles with non-overlapping responsibilities.

Write an agent contract specifying inputs, outputs, capabilities, constraints, failure responses, and completion conditions.

Define a task-lifecycle state machine that makes status, ownership, and valid transitions explicit.

Represent inter-agent messages and shared task state with explicit schemas.

Assign correlation, causation, idempotency, and provenance identifiers to messages in a multi-agent interaction.

Choose between direct request–response and queued or event-driven communication based on coupling, latency, delivery, and ordering requirements.

Select centralized, partitioned, or replicated state ownership based on consistency, availability, and failure requirements.

Separate working context, private agent memory, shared state, and durable knowledge in a system design.

Construct a context handoff that preserves essential evidence while limiting irrelevant history.

Trace a multi-agent request from entry to termination on an architecture diagram.

Design a router architecture that selects an agent from structured request attributes.

Design a centralized supervisor architecture that delegates tasks to specialist agents.

Design a sequential pipeline with validated handoffs between agents.

Design a parallel fan-out and aggregation pattern for independent subtasks.

Design an aggregation policy that handles missing results, low-confidence outputs, and disagreement among parallel agents.

Design a hierarchical manager–worker architecture for decomposing and coordinating a large task.

Select a coordination pattern from requirements for coupling, predictability, latency, and fault isolation.

Explain how peer-to-peer, group-conversation, and blackboard coordination differ in control flow.

Construct and update a runtime task graph when the required subtasks are not known in advance.

Apply plan-and-execute coordination with explicit triggers for monitoring and replanning.

Specify a delegation protocol covering task offers, acceptance, progress, results, and rejection.

Choose a conflict-resolution mechanism such as deterministic rules, scoring, voting, or a judge agent.

Design a critique or debate pattern that reduces correlated errors without creating unbounded discussion.

Detect and prevent cycles, deadlocks, and livelocks in an agent coordination graph.

Specify a tool contract containing input and output schemas, preconditions, side effects, errors, and timeout behavior.

Assign least-privilege tool permissions and scoped credentials to agents based on their responsibilities.

Classify tool operations as read-only, idempotent, reversible, or irreversible to determine safe execution controls.

Validate agent messages and tool results before they influence control decisions or alter shared state.

Define write, retrieval, update, and expiration policies for private and shared agent memory.

Preserve source provenance and evidence links as retrieved information passes between agents.

Place human approval gates and compensating actions around irreversible tool operations.

Design retry, timeout, circuit-breaking, and fallback behavior for a failed agent or tool call.

Prevent duplicate or conflicting work through task identifiers, idempotency rules, version checks, and concurrency controls.

Choose queue delivery, ordering, acknowledgement, and deduplication semantics for an asynchronous agent workflow.

Use checkpoints and replay to recover an interrupted multi-agent workflow without repeating unsafe side effects.

Isolate agent and tool failures with bulkheads, resource limits, and bounded concurrency.

Design compensating steps for a multi-agent workflow that fails after partially completing external actions.

Specify termination conditions, execution budgets, escalation paths, and human-approval checkpoints for agent loops.

Instrument a multi-agent execution with correlated events, state transitions, and decision traces.

Define task-quality, coordination, reliability, latency, and cost metrics for a multi-agent system.

Build a compact evaluation set covering normal flows, edge cases, adversarial inputs, and coordination failures.

Select and calibrate rule-based checks, model judges, and human review for evaluating agent outputs.

Test agent contracts, state transitions, and coordination invariants with controlled execution scenarios.

Diagnose an observed system failure by attributing it to an agent, handoff, tool, state, or control-policy defect.

Compare candidate architectures with a controlled experiment measuring quality, cost, latency, and reliability.

Map prompt injection, privilege escalation, data leakage, and untrusted-agent behavior onto architectural trust boundaries and select appropriate mitigations.

Design agent identities, authentication, authorization, secret handling, and audit records for a multi-agent system.

Defend against indirect prompt injection arriving through agent messages, memory, retrieved content, or tool results.

Choose a production execution topology—such as inline orchestration, worker queues, or durable workflows—based on latency, scale, and recovery requirements.

Design backpressure, admission control, rate limiting, and autoscaling for a production multi-agent workload.

Evaluate architectural trade-offs among model capability, agent specialization, latency, cost, and operational complexity.

Produce a concise framework-neutral architecture specification containing component boundaries, control and data flows, state management, failure handling, security controls, and an evaluation strategy.