Process Isolation Strategies

In Module 7, we learned how to isolate one agent from the host. In this lesson, we learn how to isolate agents from each other.

When you run a "Swarm" or a "Team" of agents, they might need to work on the same project (e.g., three agents coding the same React app). If you don't implement strict Process Isolation, they will overwrite each other's files, delete each other's variables, and enter into "Livelock" loops of mutual destruction.

---

1. Internal vs. External Isolation

Internal (Software-Level)

• Namespace isolation: Every agent gets its own "Keyspace" in the state object.
• state["researcher_output"] is separate from state["writer_output"].

External (Infrastructure-Level)

• Container Isolation: Every agent gets its own ephemeral Docker container.
• User Case: Agent A runs pip install while Agent B is running a test. By using separate containers, Agent A's installation doesn't break Agent B's environment.

---

2. The "Workspace" Pattern

To allow multiple agents to collaborate on files safely, we use the Shared Workspace pattern with Access Locks.

The Architecture

1. The Orchestrator creates a temporary directory: /tmp/shared_task_123.
2. Agent A (Researcher) is given "Read/Write" access.
3. Agent B (Writer) is given "Read/Write" access.
4. The Lockfile: Before writing, the agent must check if a .lock file exists. If it does, the agent must wait (or the orchestrator must queue the task).

---

3. Communication Isolation

Agents should never talk to each other "Directly" via raw sockets. They must use the Shared State Bus (LangGraph).

Why?

• Observability: If Agent A and Agent B talk directly, the "Orchestrator" (and you!) will lose track of the reasoning.
• Interruption: If a human needs to pause the swarm, they can only do so if the communication is happening through the state checkpointer.

---

4. Managing Concurrent Resource Usage

If you run 5 agents in parallel, they will consume 5x the CPU and 5x the Memory.

The "Scaling Wall"

If your server has 8 cores, you can't run 50 agents in parallel nodes.

• Solution: Use a Task Queue (Celery/RabbitMQ).
• Instead of creating 50 threads, you create 50 "Jobs" and let the worker pool handle them as resources become available.

---

5. Security: Preventing "Agent Collusion"

In a multi-tenant environment, you must ensure that Agent A for User 1 cannot see the data of Agent B for User 2.

Verification strategy

• Every container must be tagged with a TenantID.
• The networking layer must prevent containers with Different TenantIDs from seeing each other's IPs.

---

6. Implementation Example: The Isolated Worker Pool

import subprocess

def run_agent_task(task_code, container_id):
    # Execute the agent code in a SPECIFIC, isolated container
    # The --name flag ensures we are targeting the right 'Worker'
    cmd = f"docker exec {container_id} python -c '{task_code}'"
    return subprocess.run(cmd, shell=True, capture_output=True)

By passing a container_id, the orchestrator can ensure that the "Coder" agent always runs in the "Coding Container" and the "Tester" agent always runs in the "Testing Container."

---

Summary and Mental Model

Think of Process Isolation like Cooking in a Professional Kitchen.

• Each chef (Agent) has their own station (Container).
• They share the central pantry (The State).
• If the Sous Chef wants to give the Head Chef a sauce, they put it on the "Pass" (The Shared State) rather than walking into the Head Chef's station and potentially knocking over a pan.

Order in the kitchen is maintained by boundaries.

---

Exercise: Isolation Design

1. Collisions: Two agents are trying to write to index.html at the same time.
   • Design a "Logic Node" in LangGraph that acts as a Traffic Controller to prevent this.
2. Throttling: You have 100 agents but only 4 CPU cores.
   • How do you implement a "Queue" that ensures the user doesn't see a "Server Timeout" error?
3. Security: If Agent A is compromised by a prompt injection, how does Container Isolation keep Agent B safe from the same attack? Ready to speed things up? Let's talk about Concurrency and Throttling.