crewai task-specific inbox isolation with lobstermail

Run a three-agent CrewAI crew for long enough and you'll hit the shared-inbox problem. The researcher agent sends a contact request to a data vendor. Two days later the outreach agent sends a follow-up from the same address, because that's the only address available. Replies arrive and you have no idea which task they belong to, which agent should process them, or why one message is getting silently dropped.

CrewAI isn't at fault here. The framework handles role separation well. The shared inbox is an infrastructure decision made early — one account, one address, keep it simple — that stops working the moment two agents start sending email in parallel.

Where role separation breaks down#

CrewAI's design pushes you toward clean agent boundaries. Your researcher researches, your writer writes, your QA agent checks output. Context passing, task sequencing, tool routing — the framework handles all of it. Done carefully, it scales further than most people expect.

Email collapses that model the moment two agents share a single address.

Picture a crew that monitors vendor relationships: a researcher tracks pricing updates, an outreach agent handles renewals, and a summarizer writes status reports for the humans. All three occasionally send and receive email. With a shared inbox:

• A pricing reply arrives and gets processed by whichever agent polls next
• The outreach agent replies to a thread that was meant for the researcher
• You lose the ability to trace which task generated which email thread
• Debugging a failed pipeline means reading through 300 mixed emails to reconstruct what happened

The problem compounds over time. By week three of a long-running crew, the inbox is a pile of merged conversations with no clear ownership.

Task-specific inbox isolation solves this. Each agent gets its own @lobstermail.ai address provisioned at crew startup. Replies arrive in a specific inbox that only that agent watches. The role separation you designed at the task level holds at the communication layer too.

Setting up per-task inboxes#

With LobsterMail, provisioning an inbox is a single API call that returns an address. No DNS configuration, no human signup step. Your crew initialization script handles it.

Here's what startup looks like with three isolated inboxes:

import os
import httpx
from crewai import Agent, Task, Crew

LOBSTERMAIL_TOKEN = os.environ["LOBSTERMAIL_TOKEN"]

def hatch_inbox(role_name: str) -> str:
    """Provision a named LobsterMail inbox and return the email address."""
    r = httpx.post(
        "https://api.lobstermail.ai/v1/inboxes",
        json={"name": role_name},
        headers={"Authorization": f"Bearer {LOBSTERMAIL_TOKEN}"},
    )
    r.raise_for_status()
    return r.json()["address"]

# Each role gets its own address at startup
researcher_email = hatch_inbox("crew-researcher")
outreach_email   = hatch_inbox("crew-outreach")
summarizer_email = hatch_inbox("crew-summarizer")

# crew-researcher@lobstermail.ai
# crew-outreach@lobstermail.ai
# crew-summarizer@lobstermail.ai

Each agent then receives its address as part of its configuration. The cleanest pattern is injecting it into the agent's backstory field so the model knows which inbox to use when constructing email tool calls:

researcher = Agent(
    role="Vendor Researcher",
    goal="Track pricing changes from key vendors",
    backstory=(
        f"You communicate via {researcher_email}. "
        "Only read and send from that inbox. Never use another address."
    ),
    tools=[receive_email, send_email],
    verbose=True,
)

outreach = Agent(
    role="Vendor Outreach",
    goal="Negotiate renewals and flag pricing anomalies",
    backstory=(
        f"Your dedicated email address is {outreach_email}. "
        "Use only this address for all vendor communication."
    ),
    tools=[receive_email, send_email],
    verbose=True,
)

Your receive_email and send_email tools are thin wrappers around the LobsterMail API, each scoped to the address injected into that agent's context. The scoping makes cross-contamination structurally impossible — the tool call is authenticated to a specific inbox, not a shared account.

What debugging looks like with isolation#

Before: something breaks in your email pipeline overnight. You open the shared inbox and there are 200 emails spanning three agent roles and four days of work. You manually trace conversation threads to reconstruct what happened. This takes a while.

After: the outreach agent failed. You open the outreach inbox. Twenty emails, all from outreach work. The researcher's inbox is separate and untouched. You find the problem in under five minutes.

That's the operational payoff, independent of correctness. When a specific task fails, you look at the specific inbox for that task. Nothing else to filter through.

Inbox isolation also matters for parallel execution. CrewAI's Process.parallel mode runs multiple agents simultaneously, and without isolated inboxes, two agents polling the same address will race — processing some emails twice and silently dropping others. Per-task inboxes remove the race condition entirely. Parallel tasks just work.

A few things worth doing before you ship#

Log the inbox addresses in your task output at crew initialization. When you're debugging a run from last Tuesday, you want to look up exactly which address was active for each role.

Decide whether inboxes should persist across runs. For long-running crews where vendor contacts might reply to existing threads, you want the same crew-researcher@lobstermail.ai address across restarts. LobsterMail's smart inbox function returns the existing address for the same name rather than creating a new one, so reuse is automatic. For short-lived or ephemeral tasks, a fresh random address per run keeps your data cleaner.

Set a timeout on your email polling loops. If a reply never arrives, you want the task to surface as a failure rather than hang indefinitely. Crews that block on email without a timeout are hard to diagnose when things go quiet.

For more on managing email at scale across many agent tasks, see running 50 agent inboxes.

Your agents can provision their own inboxes. Get started with LobsterMail — it's free.