English · 00:23:38
Feb 14, 2026 1:07 AM

Give your Coding Agents Email and Let Them Team Up to Build Your Software FAST!

Jeffrey Emanuel @jeffreyemanuel6375

SUMMARY

Dicklesworthstone demonstrates his Agent Mail system, enabling AI coding agents to collaborate via email on building a specialized web browser that converts pages to images and OCR markdown, from ideation to execution using tools like Claude and Beads.

STATEMENTS

  • The speaker introduces Agent Mail as a system allowing AI agents to communicate via email, streamlining collaborative software development on a new project: an agent-specific web browser that screenshots pages and uses OCR to extract markdown.
  • Initial setup involves installing Agent Mail with a single command on a remote machine via SSH, which automatically handles dependencies and integrations like codecs.
  • Before deploying multiple agents, the first agent reads project plans, best practices, and creates initial setup including pyproject.toml, library installations, and folder structures.
  • Using Steve Yegge's Beads tool, the first agent generates subtasks from the detailed markdown plan, dividing the project into manageable beads for subsequent agents.
  • Multiple tmux sessions run separate instances of Claude (codecs) for agents, with one dedicated to Claude for git operations like commits, ensuring coordinated work without conflicts.
  • Agents introduce themselves via email in the mailbox, divvying up tasks based on beads, avoiding git worktrees by reserving file access through communication.
  • The workflow involves queuing prompts in Claude to keep agents progressing: selecting next beads, reviewing code, and committing changes with detailed messages.
  • Planning is emphasized as crucial; the speaker iterates plans using GPT-4o Pro, incorporating web searches for latest tech and personal preferences like Python 3.13+ and UV.
  • An agents.md file customizes wisdom and best practices for the project, including specific libraries like Decouple and support docs for tools like the Allen Institute's MOLCR project.
  • The system allows hands-off operation on remote boxes, with periodic human interventions via simple prompts, enabling parallel work without interference on the local machine.

IDEAS

  • AI agents collaborating via email mimic human team dynamics, allowing direct communication to divide tasks efficiently and avoid conflicts, far superior to isolated or indirect methods like shared whiteboards.
  • Converting web pages to images then OCR to markdown enables agents to "browse" without rendering engines, leveraging advanced models like GPT-4o for structured data extraction.
  • Pre-dividing projects into beads from a detailed plan prevents chaos, giving agents a clear roadmap and reducing the need for constant oversight.
  • Using multiple Claude instances in tmux sessions on a remote machine decouples development from local resources, allowing unattended progress for hours.
  • Iterating plans with AI before coding saves time, as revisions are easier in planning phase; cross-model reviews (e.g., GPT vs. Claude) refine tech stacks.
  • Custom agents.md files embed project-specific wisdom, blending general best practices with tailored instructions like library choices and support docs.
  • Git commits generated by dedicated agents ensure detailed, logical histories by analyzing changes without editing code, improving project documentation.
  • Queuing varied prompts like "pick next bead" or "review code" keeps agents productive autonomously, with occasional reviews maintaining quality.
  • Sharing mailboxes via GitHub Pages makes agent interactions transparent and accessible, evolving from initial chatter to structured task allocation.
  • A companion app could automate tmux management and prompt queuing, turning users into CEOs directing agents remotely like a Slack team.

INSIGHTS

  • Effective AI collaboration hinges on human-like communication channels, transforming isolated agents into a cohesive team that sidesteps common pitfalls like file conflicts.
  • Upfront planning with iterative AI refinement is the linchpin of efficient development, as it front-loads complexity and enables smooth autonomous execution.
  • Tool integration like Beads and Agent Mail structures chaos into productivity, proving that predefined tasks outperform ad-hoc agent improvisation.
  • Remote, parallel agent deployment maximizes human bandwidth, allowing focus on ideation while machines handle implementation without local disruption.
  • Customizable wisdom files personalize AI behavior, bridging general intelligence with project-specific needs for more reliable outcomes.
  • Periodic, minimal human nudges sustain momentum, highlighting how simple prompts can orchestrate complex, multi-agent workflows over extended periods.

QUOTES

  • "It's really that simple. Like you just keep spamming this in, add a little like, you know, please review. Um, hit the next bead, keep going, keep going, keep going."
  • "Imagine trying to run a software startup where none of your employees are allowed to communicate with each other because that's basically what you're trying to do."
  • "All the work is in the planning and the really like the thinking of um what would be a good thing to make and then what's a good way to make it."
  • "It's amazing to me that you know people weren't already doing this honest I'm kind kind of amazed that my project's the first one um that I've seen at least to to do this work."
  • "They just need you know a little bit of encouragement and they just keep cranking away and it's um that's it. I mean it's that easy. Like it's just um it's almost seems like cheating."

HABITS

  • Iterating project plans multiple times with AI models like GPT-4o Pro before implementation, incorporating web searches for latest techniques and personal tech preferences.
  • Installing tools like Agent Mail via single commands on remote machines to automate setup and run development unattended.
  • Queuing simple, repetitive prompts in Claude sessions to maintain agent momentum, varying them occasionally for reviews or tests.
  • Using dedicated tmux sessions for multiple agents, including one for git operations, to monitor and direct progress without local interference.
  • Sharing agent mailboxes publicly via GitHub Pages for transparency and feedback, while documenting changes with detailed AI-generated commit messages.

FACTS

  • Agent Mail integrates with codecs and automatically handles installations, enabling quick setup for multi-agent collaboration.
  • The project uses Python 3.13+ with UV for package management and pyproject.toml for configuration, insisting on modern standards.
  • Beads, developed by Steve Yegge, structures projects into subtasks from markdown plans, enhancing agent coordination.
  • The Allen Institute's MOLCR project is leveraged for OCR functionality in the agent web browser.
  • GitHub Pages can deploy agent mailboxes in under a minute, making interactions viewable online without complex tunneling.

REFERENCES

HOW TO APPLY

  • Connect to a remote machine via SSH and install Agent Mail using the provided one-liner command, which automatically sets up dependencies and integrates with tools like codecs.
  • Prepare a detailed markdown plan using AI like GPT-4o Pro, iterating multiple times to refine tech stack, incorporating web searches for best practices and personal constraints like Python version.
  • Have the first agent read all plan documents, agents.md best practices, and support files, then perform initial project setup: create pyproject.toml, install libraries, and establish folder structure.
  • Use Beads to generate subtasks or "beads" from the plan, dividing the project into manageable pieces that agents can claim and work on without overlap.
  • Launch multiple tmux sessions, each running a Claude instance as an agent; include one for git operations, then initiate communication by having agents introduce themselves via the email mailbox.
  • Queue prompts in each session to guide progress: instruct agents to select and work on the next bead, review code periodically, ensure tests pass, and commit changes with detailed messages.
  • Monitor the mailbox for agent interactions, intervening with simple messages like "keep going" or "review everything" to sustain autonomous work, avoiding conflicts through reserved file access.

ONE-SENTENCE TAKEAWAY

Harness AI agents' email collaboration via Agent Mail to automate software building, emphasizing meticulous planning for efficient, hands-off development.

RECOMMENDATIONS

  • Prioritize detailed, iterated planning with AI to define clear tech stacks and subtasks before deploying agents, ensuring alignment and reducing errors.
  • Use remote machines with tmux for multi-agent setups, queuing prompts to enable parallel, unattended progress without local resource strain.
  • Integrate Beads for task division and custom agents.md files to embed project-specific guidelines, enhancing coordination and best practices adherence.
  • Dedicate one agent to git operations for intelligent, detailed commits, maintaining a clean project history while others focus on coding.
  • Share mailboxes publicly via GitHub Pages to observe and debug agent interactions, fostering transparency and iterative improvements in workflows.

MEMO

In a dimly lit setup, developer Dicklesworthstone leans into his screen, demonstrating a revolutionary workflow that turns AI into a bustling software team. What began as a spontaneous idea—a web browser tailored for agents, capturing pages as images and converting them via OCR into editable markdown—unfolds through his Agent Mail system. This isn't solitary coding; it's orchestrated collaboration, where AI agents email each other like colleagues in a startup, divvying tasks and avoiding the pitfalls of disjointed work. Using tools like Claude in multiple sessions, the process starts with a single installation command on a remote machine, instantly priming the environment for action.

The magic lies in preparation. Dicklesworthstone emphasizes crafting a meticulous plan, refined through iterations with GPT-4o Pro, drawing from recent web resources and his non-negotiable standards: Python 3.13 or later, UV for dependencies, and libraries like Decouple. An initial agent absorbs this blueprint, alongside custom wisdom in an agents.md file and support docs for specialized tools like the Allen Institute's MOLCR OCR project. From there, Steve Yegge's Beads breaks the plan into "beads"—bite-sized tasks that agents claim via email, sidestepping git worktree headaches by reserving files through direct chatter. It's a far cry from isolated AI prompts; here, agents introduce themselves, negotiate roles, and progress autonomously.

As tmux windows flicker with activity, the agents hum along, one handling git commits with thoughtful messages, others tackling code reviews and bead completions. Dicklesworthstone queues simple nudges—"pick the next bead," "keep going," "review everything"—watching changes accrue in real time. Conflicts evaporate thanks to email coordination, echoing the inefficiency of a team forbidden to talk. On a remote box, this runs for hours without taxing his local setup, freeing him for ideation. A shared GitHub Pages mailbox reveals the evolving dialogue: from introductory pleasantries to structured task handoffs, painting a vivid picture of emergent teamwork.

Yet, the true insight emerges in the simplicity. All heavy lifting—ideation, planning, tech selection—precedes execution, making the build feel almost illicitly easy. Dicklesworthstone marvels at being first to pioneer this email paradigm for agents, stunned that such human-like efficiency wasn't standard. Looking ahead, his companion app promises even more automation: tmux orchestration, remote directing via phone-like interfaces, all while prioritizing user-controlled security over centralized servers. For developers weary of solo grinds, this workflow reimagines creation as delegation, where AI doesn't just assist but assembles.

The demo culminates in tangible progress: commits stack up with narrative depth, the browser prototype takes shape, blending screenshots with markdown magic. Success stories or frustrations? Dicklesworthstone invites them, hinting at a future where users helm AI firms from afar, prompts as directives. In an era of accelerating tech, Agent Mail doesn't just build software faster—it humanizes the machine, turning code into conversation.

Like this? Create a free account to export to PDF and ePub, and send to Kindle.

Create a free account