Three worker agents are running in parallel to analyze different modules of a large codebase. The coordinator wants them to be fully independent. Which design decision best enforces parallel isolation?
Select an answer to reveal the explanation.
Short Explanation
Think of three scientists running independent experiments — they can't peek at each other's lab notebooks mid-experiment, or the results aren't independent. You need separate workspaces, memory namespaces, and file scopes for each worker, then let the coordinator merge only after they finish.
Full Explanation
Parallel isolation ensures that each worker agent's analysis is conducted independently, preventing one agent's intermediate, and potentially incorrect or incomplete, findings from biasing another's. The isolated-workspace design achieves this by giving each agent its own workspace: a separate memory namespace so writes do not collide or bleed across agents, and a separate file scope so agents cannot read each other's intermediate outputs. The coordinator retains control over when merging occurs, ensuring only complete, validated outputs are combined. On the exam, parallel isolation means separate namespaces and file scopes per agent, with merging only done at the coordinator level after all agents complete.
The read-only access to the full shared memory store design defeats isolation. Even read-only access to in-progress data creates a dependency between agents — one agent might see another agent's partial findings and adjust its analysis accordingly, creating correlated outputs that are no longer independent. Isolation requires not seeing each other's intermediate state, not just not writing to it.
The same GitHub Actions job with shared environment variables design is the opposite of isolation — shared environment variables and a common job context create maximum coupling. Agents can see each other's state through the shared environment, filesystem, and any shared tools. This design makes the agents highly dependent on each other's behavior.
The global lock on the shared memory store design converts parallel execution into sequential execution, eliminating the performance benefit of parallelism and creating a bottleneck. It also does not achieve isolation — agents still share the same memory namespace, just with serialized access. Isolation is about separation, not serialization.