Give Agents Jobs, Not Vibes

A model may be able to write, code, research, browse, and plan. That does not mean every task should ask it to do all five at once. Roles create repeatable expectations: what context arrives, which tools are available, what the worker may change, and what proof it must return.

One system might use a coding lane, a research and writing lane, and a tightly controlled local-operations lane. Providers and model names may change over time. The durable part is the contract around each lane.

A worker should receive a bounded packet, not a motivational speech. Include the objective, current state, relevant files or sources, constraints, allowed actions, acceptance checks, and required receipt. If another worker is already active nearby, include the ownership boundary.

Good packets make delegation legible. They also make failure diagnosable: you can tell whether the packet was incomplete, the worker made a poor decision, a tool failed, or the acceptance test was wrong.

Choose a worker based on the shape of the job, not loyalty to a model. A repository refactor needs code navigation, tests, and safe file edits. A positioning memo needs synthesis and voice. A local maintenance task needs controlled shell access. A browser workflow needs visible state and confirmation rules.

The control layer should make that routing decision from requirements and current availability. The front door should not force the user to know which worker is best before asking for the outcome.

Parallel workers help only when their tasks are independent and their boundaries do not collide. Split work by owned surface: content, implementation, verification, research, or a specific subsystem. Give one owner responsibility for integration and the final definition of done.

A swarm without integration ownership creates fast fragments. A small number of clear lanes usually beats a crowd of agents touching the same files and assumptions.

A dashboard can show several workers as active while no executor is actually running, no artifact is changing, and no receipt is being produced. Status language becomes decoration. This is agent theater: the appearance of an organization without operational proof.

Treat activity as a claim that needs evidence. Show the task identity, executor, last meaningful event, output artifact, and exit condition. If those are missing, the honest state is queued or blocked—not working.

Multi-agent design begins with control flow, not headcount. In a manager pattern, one agent keeps the task and calls specialists for bounded results. In a handoff pattern, control moves to a specialist with its own instructions and tools. In a pipeline, deterministic code moves a typed artifact through sequential or parallel worker stages. Each pattern creates a different accountability boundary.

Managers are useful when a single owner must synthesize several perspectives or maintain a consistent user relationship. Handoffs help when the specialist needs a sustained conversation and can responsibly own the remainder of the turn. Pipelines are strongest when outputs can be validated between stages: research produces cited notes, planning produces a task graph, implementation produces a diff, and verification produces receipts.

Do not reach for another agent when a function will do. A formatter, schema validator, file resolver, permission check, or test runner should remain deterministic. Agents belong where interpretation or adaptive search creates value. The seams between them should be typed enough that failure can be localized.

A worker’s reliability is constrained by the tools it can see. A vague ‘run shell command’ tool grants broad power and forces the model to invent syntax, target selection, error handling, and validation on every use. A purpose-built ‘deploy preview’ tool can require a project identifier, resolve the approved target, run fixed checks, return a deployment receipt, and refuse production by policy.

Design tools around meaningful actions with narrow schemas. Give parameters names a person can understand. Return structured errors that distinguish invalid input, missing authorization, dependency failure, policy denial, and an unsuccessful external action. Make read and write capabilities distinct so a worker can inspect broadly without gaining accidental authority to mutate broadly.

Model Context Protocol can standardize how hosts connect to external tool and resource providers, but protocol interoperability does not decide trust. The host still owns consent, credential scope, server allowlists, result validation, and what data enters the model context. Connectivity is plumbing; authority remains a product decision.

Parallel agents reduce elapsed time only when their work can proceed independently. Two workers editing the same component, changing the same database schema, or relying on different unstated assumptions create integration debt faster than they create value. The cost appears at the end, when a human must reconcile contradictory artifacts.

Partition work by ownership and contract. A research lane may deliver a source packet without touching implementation. A design lane may define states and acceptance criteria. Two code lanes can own separate packages with a stable interface. A verification lane should test the integrated result rather than merely endorsing each fragment. One integrator owns the final branch, decision reconciliation, and completion receipt.

Concurrency also needs cancellation and budgets. If an upstream assumption changes, dependent workers should stop or be marked stale. If one lane fails, the task graph should reveal which other results remain usable. Speed is valuable only when the system can explain what ran, what it cost, what collided, and which artifact became authoritative.