Email Gateway Architecture: From SMTP to AI Understanding

TL;DR: Building an email gateway for AI agents isn't just about parsing SMTP. We went from receiving raw RFC822 messages to delivering structured, context-aware prompts to Claude sessions. This article breaks down the real technical challenges: MIME multipart hell, attachment handling, threading context, spam filtering, and maintaining conversational state across dozens of concurrent AI employees.

Why This Matters Now

GetATeam launched its production email gateway 10 days ago. Our AI employees now have real email addresses like `[email protected]` and `[email protected]`. In the first week, we received 847 emails, ranging from simple text replies to complex multipart messages with PDF attachments and inline images.

The challenge wasn't just "receive email and forward it to AI." It was:

• Parse MIME correctly (including the cursed edge cases)
• Extract meaningful context from thread history
• Handle attachments intelligently
• Filter spam without false positives
• Maintain conversational state across sessions
• Scale to dozens of concurrent AI employees

This is what we learned.

Architecture Overview

High-Level Flow

┌─────────────────────────────────────────────────────────────┐
│                     External Email (SMTP)                    │
│                  [email protected]                         │
└────────────────────────┬────────────────────────────────────┘
                         │
                         ▼
          ┌──────────────────────────────┐
          │  Postfix SMTP Server         │
          │  (Port 25, TLS)              │
          │  - SPF/DKIM validation       │
          │  - Basic spam filtering      │
          └──────────────┬───────────────┘
                         │
                         ▼
          ┌──────────────────────────────┐
          │  Email Processor Service     │
          │  (Node.js + mailparser)      │
          │  - Parse MIME structure      │
          │  - Extract attachments       │
          │  - Thread detection          │
          │  - Save to queue as .eml     │
          └──────────────┬───────────────┘
                         │
                         ▼
          ┌──────────────────────────────┐
          │  Agent Router                │
          │  - Match recipient           │
          │  - Find agent session        │
          │  - Format prompt             │
          └──────────────┬───────────────┘
                         │
                         ▼
          ┌──────────────────────────────┐
          │  VibeCoder Admin WebSocket   │
          │  wss://172.16.0.3:2108/admin │
          │  - Send prompt to session    │
          │  - Validate with \r          │
          └──────────────┬───────────────┘
                         │
                         ▼
          ┌──────────────────────────────┐
          │  AI Agent Session (Claude)   │
          │  - Reads email prompt        │
          │  - Generates response        │
          │  - Uses email-sender skill   │
          └──────────────────────────────┘

Key Components

1. Postfix SMTP Server

• Handles incoming SMTP connections on port 25
• TLS/SSL support for secure delivery
• SPF/DKIM validation to reduce spam
• Forwards messages to processor via pipe

2. Email Processor

• Node.js service using `mailparser` library
• Parses MIME structure (multipart/mixed, multipart/alternative, etc.)
• Extracts and base64-decodes attachments
• Saves complete .eml file to queue directory
• Detects thread context from References/In-Reply-To headers

3. Agent Router

• Monitors queue directory for new .eml files
• Parses recipient (`To:` header) to identify target agent
• Constructs structured prompt with email content
• Connects to VibeCoder Admin WebSocket
• Sends prompt + Enter key (`\r`) for validation

4. AI Agent Response

• Claude session receives prompt
• Processes email using context from CLAUDE.md and memory.md
• Generates response email
• Uses email-sender.js skill to create RFC822 .eml file
• Saves to sent/ directory and delivers via SMTP

Deep Dive: MIME Parsing Hell

The Problem

Email isn't just text. A typical modern email looks like this:

MIME-Version: 1.0
Content-Type: multipart/mixed; boundary="----=_Part_123"

------=_Part_123
Content-Type: multipart/alternative; boundary="----=_Part_456"

------=_Part_456
Content-Type: text/plain; charset="UTF-8"

Plain text version here

------=_Part_456
Content-Type: text/html; charset="UTF-8"

<html><body>HTML version here</body></html>

------=_Part_456--

------=_Part_123
Content-Type: application/pdf; name="document.pdf"
Content-Transfer-Encoding: base64
Content-Disposition: attachment; filename="document.pdf"

JVBERi0xLjcKCjEgMCBvYmoKPDwvVHlwZS9DYXRhbG9nL1BhZ2VzIDIgMCBSPj4K...

------=_Part_123--

Challenges:

1. Nested multipart structures - Alternative inside mixed, related inside alternative
2. Boundary parsing - Can't just split on `--boundary`, need proper MIME parser
3. Encoding hell - base64, quoted-printable, 7bit, 8bit, binary
4. Character sets - UTF-8, ISO-8859-1, Windows-1252, etc.
5. Malformed headers - Real-world emails violate RFC specs constantly

Our Solution

We use `mailparser` (npm package) which handles the complexity:

const { simpleParser } = require('mailparser');
const fs = require('fs').promises;

async function parseEmail(emlPath) {
  const emlContent = await fs.readFile(emlPath, 'utf8');
  
  const parsed = await simpleParser(emlContent);
  
  return {
    from: parsed.from.text,
    to: parsed.to.text,
    subject: parsed.subject,
    messageId: parsed.messageId,
    inReplyTo: parsed.inReplyTo,
    references: parsed.references,
    date: parsed.date,
    
    // Text content (prioritize)
    text: parsed.text,
    html: parsed.html,
    
    // Attachments with decoded content
    attachments: parsed.attachments.map(att => ({
      filename: att.filename,
      contentType: att.contentType,
      size: att.size,
      content: att.content // Buffer (already decoded)
    }))
  };
}

Why mailparser:

• Handles all MIME types correctly
• Automatically decodes base64/quoted-printable
• Converts character sets to UTF-8
• Extracts attachments as Buffers
• Parses thread headers (References, In-Reply-To)

Metrics:

• Parse time: 12-45ms for typical emails
• Parse time with attachments: 80-250ms (3MB PDF = ~180ms)
• Memory usage: ~50MB per email with attachments
• Success rate: 99.4% (5 failures out of 847 emails - all malformed spam)

Attachment Handling

The Challenge

Attachments can be:

• Documents (PDF, DOCX, XLSX, etc.)
• Archives (ZIP, TAR.GZ)
• Code files (source code, configs)

Images (inline `

` or attached)

Questions:

1. Should AI read the attachment content?
2. How to present binary data (PDFs, images) to a text-based AI?
3. Storage: Save permanently or temporary?
4. Security: Malware scanning?

Our Approach

Decision Matrix:

Implementation:

async function processAttachments(attachments) {
  const processed = [];
  
  for (const att of attachments) {
    // Security check
    if (isExecutable(att.filename)) {
      processed.push({
        filename: att.filename,
        status: 'blocked',
        reason: 'Executable files not allowed'
      });
      continue;
    }
    
    // Size check
    if (att.size > 10 * 1024 * 1024) { // 10MB
      processed.push({
        filename: att.filename,
        status: 'too_large',
        size: att.size
      });
      continue;
    }
    
    // Process by type
    if (att.contentType.startsWith('image/')) {
      // Claude can view images
      const base64 = att.content.toString('base64');
      processed.push({
        filename: att.filename,
        type: 'image',
        contentType: att.contentType,
        base64: base64
      });
    } else if (att.contentType === 'application/pdf') {
      // Extract text from PDF
      const text = await extractPdfText(att.content);
      processed.push({
        filename: att.filename,
        type: 'pdf',
        text: text
      });
    } else if (att.contentType.startsWith('text/')) {
      // Plain text
      processed.push({
        filename: att.filename,
        type: 'text',
        content: att.content.toString('utf8')
      });
    } else {
      // Unknown type - save metadata only
      processed.push({
        filename: att.filename,
        type: 'other',
        contentType: att.contentType,
        size: att.size
      });
    }
  }
  
  return processed;
}

function isExecutable(filename) {
  const dangerous = ['.exe', '.bat', '.cmd', '.sh', '.app', '.dmg', 
                    '.dll', '.so', '.dylib', '.scr', '.vbs', '.js', 
                    '.jar', '.apk'];
  return dangerous.some(ext => filename.toLowerCase().endsWith(ext));
}

Storage Strategy:

// Save attachments to agent-specific directory
const attachmentPath = \`/opt/app/virtualemployees/agents/\${agentFolder}/mails/attachments/\${messageId}/\`;
await fs.mkdir(attachmentPath, { recursive: true });

for (const att of attachments) {
  const filePath = path.join(attachmentPath, att.filename);
  await fs.writeFile(filePath, att.content);
}

Metrics (first 10 days):

• Total attachments received: 127
• Images: 68 (53%)
• PDFs: 34 (27%)
• Office docs: 15 (12%)
• Other: 10 (8%)
• Blocked executables: 0 (spam filter caught them)
• Average size: 1.2MB
• Largest attachment: 8.7MB (PDF technical spec)

Thread Context Detection

The Problem

Emails are conversational. When someone replies to a previous message, the AI needs context:

• What was the original email about?
• What did I (the AI) say before?
• Is this the 1st, 3rd, or 10th message in the thread?

Without context, the AI might:

• Ask questions already answered
• Contradict previous statements
• Lose track of the conversation

Email Threading Headers

RFC822 defines headers for threading:

Message-ID: <[email protected]>
In-Reply-To: <[email protected]>
References: <[email protected]> <[email protected]> <[email protected]>

How it works:

1. Original email: Only has `Message-ID`
2. First reply: Has `In-Reply-To` (points to original) and `References` (list of all previous)
3. Subsequent replies: Update `References` with full chain

Our Implementation

async function detectThread(parsed) {
  const thread = {
    isReply: false,
    threadId: null,
    previousMessages: []
  };
  
  // Check if this is a reply
  if (parsed.inReplyTo || (parsed.references && parsed.references.length > 0)) {
    thread.isReply = true;
    
    // Use first message in References as thread ID
    thread.threadId = parsed.references 
      ? parsed.references[0] 
      : parsed.inReplyTo;
    
    // Find previous messages in this thread
    thread.previousMessages = await findThreadMessages(thread.threadId);
  } else {
    // New thread - use this message's ID
    thread.threadId = parsed.messageId;
  }
  
  return thread;
}

async function findThreadMessages(threadId) {
  const inboxPath = \`/opt/app/virtualemployees/agents/\${agentFolder}/mails/inbox/\`;
  const files = await fs.readdir(inboxPath);
  
  const threadMessages = [];
  
  for (const file of files) {
    if (!file.endsWith('.eml')) continue;
    
    const emlPath = path.join(inboxPath, file);
    const parsed = await parseEmail(emlPath);
    
    // Check if this message belongs to the thread
    if (parsed.messageId === threadId || 
        (parsed.references && parsed.references.includes(threadId))) {
      threadMessages.push({
        messageId: parsed.messageId,
        from: parsed.from.text,
        subject: parsed.subject,
        date: parsed.date,
        text: parsed.text.substring(0, 500) // Preview only
      });
    }
  }
  
  // Sort by date
  return threadMessages.sort((a, b) => a.date - b.date);
}

Constructing Context-Aware Prompts

When sending the prompt to the AI agent:

function buildEmailPrompt(parsed, thread, attachments) {
  let prompt = '📧 NEW EMAIL TASK\n\n';
  
  // Basic info
  prompt += \`From: \${parsed.from.text}\n\`;
  prompt += \`To: \${parsed.to.text}\n\`;
  prompt += \`Subject: \${parsed.subject}\n\`;
  prompt += \`Date: \${parsed.date.toISOString()}\n\n\`;
  
  // Thread context if applicable
  if (thread.isReply && thread.previousMessages.length > 0) {
    prompt += '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n';
    prompt += '📜 CONVERSATION HISTORY\n';
    prompt += '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n';
    
    thread.previousMessages.forEach((msg, idx) => {
      prompt += \`Message \${idx + 1} (\${msg.date.toDateString()}):\n\`;
      prompt += \`From: \${msg.from}\n\`;
      prompt += \`Preview: \${msg.text}\n\n\`;
    });
    
    prompt += '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n';
  }
  
  // Attachments summary
  if (attachments.length > 0) {
    prompt += '📎 ATTACHMENTS:\n';
    attachments.forEach(att => {
      prompt += \`- \${att.filename} (\${att.type}, \${formatBytes(att.size)})\n\`;
    });
    prompt += '\n';
  }
  
  // Email body
  prompt += '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n';
  prompt += '📄 EMAIL CONTENT\n';
  prompt += '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n';
  prompt += parsed.text;
  prompt += '\n\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n';
  
  // Instructions
  prompt += 'REQUIRED ACTIONS:\n';
  prompt += '1. Read and understand the email\n';
  prompt += '2. Check conversation history if this is a reply\n';
  prompt += '3. Review any attachments\n';
  prompt += '4. Respond appropriately using email-sender.js skill\n';
  prompt += '5. Save response to mails/sent/ directory\n';
  
  return prompt;
}

Example output:

📧 NEW EMAIL TASK

From: Alice Smith <[email protected]>
To: Joseph Benguira <[email protected]>
Subject: Re: GetATeam Integration Question
Date: 2025-11-05T09:15:00.000Z

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
📜 CONVERSATION HISTORY
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Message 1 (Nov 4, 2025):
From: Alice Smith <[email protected]>
Preview: Hi Joseph, I saw your blog post about multi-agent coordination...

Message 2 (Nov 4, 2025):
From: Joseph Benguira <[email protected]>
Preview: Hey Alice, thanks for reaching out! The coordination layer...

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

📎 ATTACHMENTS:
- architecture-diagram.png (image, 245 KB)

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
📄 EMAIL CONTENT
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Perfect! I've attached our current architecture. Where do you think
the email gateway should fit?

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Metrics:

• Emails with thread context: 312 / 847 (37%)
• Average thread length: 3.2 messages
• Longest thread: 14 messages (customer support conversation)
• Context retrieval time: 15-40ms (depends on inbox size)

Spam Filtering Without Breaking AI Communication

The Challenge

AI employees need to receive legitimate emails, but spam will flood them. Traditional spam filters (SpamAssassin, etc.) are trained for humans, not AI agents.

Problems with standard filters:

• False positives - Legitimate business emails marked as spam
• Keyword-based - Misses modern spam techniques
• Bayesian training - Needs large dataset to train

Our Multi-Layer Approach

Layer 1: SMTP Level (Postfix)

# /etc/postfix/main.cf
smtpd_recipient_restrictions =
    permit_mynetworks,
    reject_non_fqdn_recipient,
    reject_unknown_recipient_domain,
    reject_unauth_destination,
    reject_rbl_client zen.spamhaus.org,
    reject_rbl_client bl.spamcop.net,
    permit

smtpd_sender_restrictions =
    reject_non_fqdn_sender,
    reject_unknown_sender_domain,
    permit

# SPF checking
smtpd_recipient_restrictions = 
    ...
    check_policy_service unix:private/policyd-spf

# DKIM verification
milter_default_action = accept
milter_protocol = 6
smtpd_milters = inet:localhost:8891
non_smtpd_milters = inet:localhost:8891

Rejects:

• Non-existent domains (DNS check)
• Known spam sources (RBL lists)
• Failed SPF/DKIM validation
• Non-FQDN senders

Layer 2: Content Analysis

async function analyzeEmailContent(parsed) {
  const signals = {
    spam_score: 0,
    reasons: []
  };
  
  // Check subject line
  if (hasSpamKeywords(parsed.subject)) {
    signals.spam_score += 3;
    signals.reasons.push('Spam keywords in subject');
  }
  
  // Check for excessive links
  const linkCount = (parsed.html || '').match(/https?:\/\//g)?.length || 0;
  if (linkCount > 10) {
    signals.spam_score += 2;
    signals.reasons.push(\`Too many links (\${linkCount})\`);
  }
  
  // Check for URL shorteners (common in spam)
  if (hasUrlShorteners(parsed.text)) {
    signals.spam_score += 2;
    signals.reasons.push('URL shorteners detected');
  }
  
  // Check From domain vs Return-Path domain
  const fromDomain = parsed.from.value[0].address.split('@')[1];
  const returnPath = parsed.headers.get('return-path');
  if (returnPath && !returnPath.includes(fromDomain)) {
    signals.spam_score += 1;
    signals.reasons.push('From/Return-Path mismatch');
  }
  
  // Check for unusual character encoding tricks
  if (hasEncodingTricks(parsed.text)) {
    signals.spam_score += 2;
    signals.reasons.push('Suspicious character encoding');
  }
  
  // Threshold
  signals.isSpam = signals.spam_score >= 5;
  
  return signals;
}

function hasSpamKeywords(text) {
  const keywords = [
    /viagra/i, /cialis/i, /casino/i, /lottery/i,
    /enlarge/i, /click here now/i, /act now/i,
    /limited time/i, /free money/i, /nigerian prince/i,
    /crypto.*investment/i, /double.*bitcoin/i
  ];
  return keywords.some(regex => regex.test(text));
}

Layer 3: Behavioral Analysis

// Track sender history
const senderHistory = new Map();

function checkSenderReputation(fromAddress) {
  if (!senderHistory.has(fromAddress)) {
    senderHistory.set(fromAddress, {
      emailCount: 0,
      spamCount: 0,
      lastSeen: null
    });
  }
  
  const history = senderHistory.get(fromAddress);
  history.emailCount++;
  history.lastSeen = new Date();
  
  // New sender with suspicious pattern
  if (history.emailCount === 1) {
    return { trustLevel: 'unknown', reason: 'First email' };
  }
  
  // Frequent sender with no spam
  if (history.emailCount > 5 && history.spamCount === 0) {
    return { trustLevel: 'trusted', reason: 'Established sender' };
  }
  
  // High spam ratio
  if (history.spamCount / history.emailCount > 0.3) {
    return { trustLevel: 'suspicious', reason: 'High spam ratio' };
  }
  
  return { trustLevel: 'neutral' };
}

Metrics (10 days):

• Total emails received: 847
• Blocked at SMTP layer: 2,341 (73% block rate)
• Blocked by content analysis: 23 (2.7% of accepted)
• False positives: 2 (0.2%) - manually reviewed and whitelisted
• Spam that reached AI: 0 ✅
• Legitimate emails blocked: 2 (both from new domains, whitelisted after review)

Performance & Scaling

Current Setup

# docker-compose.yml
services:
  email-gateway:
    image: node:22-alpine
    volumes:
      - ./email-processor:/app
      - ./queue:/queue
      - ./agents:/agents
    environment:
      - SMTP_HOST=172.17.0.1
      - SMTP_PORT=25
      - VIBECODER_HOST=172.16.0.3
      - VIBECODER_PORT=2108
    restart: always

  postfix:
    image: boky/postfix
    ports:
      - "25:25"
    volumes:
      - ./postfix-config:/etc/postfix/custom.d
    environment:
      - ALLOWED_SENDER_DOMAINS=geta.team
    restart: always

Performance Benchmarks

Email Processing Pipeline:

Resource Usage (per email):

• CPU: 12% spike (quad-core)
• Memory: 45-80MB (depends on attachments)
• Disk I/O: 2-15MB written (email + attachments)
• Network: Minimal (WebSocket already open)

Concurrent Processing:

Currently handling 24 concurrent AI agents. Each agent can receive emails simultaneously.

// Queue processor with concurrency control
const CONCURRENCY = 24;
const queue = new PQueue({ concurrency: CONCURRENCY });

async function processQueue() {
  const files = await fs.readdir('/queue');
  const emlFiles = files.filter(f => f.endsWith('.eml')).sort();
  
  for (const file of emlFiles) {
    queue.add(() => processEmail(path.join('/queue', file)));
  }
  
  await queue.onIdle();
}

Scaling Projections:

Based on current performance:

• 100 emails/day: Current load, no issues
• 1,000 emails/day: Add queue workers, no architecture change needed
• 10,000 emails/day: Need distributed queue (Redis/RabbitMQ)
• 100,000 emails/day: Microservices architecture + load balancer

Lessons Learned

1. MIME Parsing is Harder Than You Think

Mistake: Initially tried to parse MIME manually with regex.

Reality: MIME has too many edge cases. Nested multipart, malformed boundaries, mixed encodings. After 2 days of debugging, switched to `mailparser` library. Problem solved in 30 minutes.

Lesson: Use battle-tested libraries for complex specs.

2. Thread Context is Critical

Mistake: Initially sent emails to AI without context. AI would ask questions already answered in previous messages.

Fix: Parse References/In-Reply-To headers, fetch previous messages, include in prompt.

Impact: User satisfaction went from "AI seems dumb" to "Wow, it remembers our conversation!"

3. Attachments Need Type-Specific Handling

Mistake: Sent all attachments as base64 to Claude.

Problem: Large PDFs exceeded context limits, binary files were useless.

Fix: Implement smart attachment handling:

• Images → Send to Claude (can analyze)
• PDFs → Extract text pages
• Office docs → Extract text
• Executables → Block

Result: Claude can actually use attachment content meaningfully.

4. Spam Filtering Must Be Aggressive But Smart

Mistake: Started with minimal spam filtering ("AI can handle it").

Reality: AI agents spent time analyzing spam, wasting tokens and time.

Fix: Multi-layer filtering (SMTP + content + behavior). Block 99.7% of spam before reaching AI.

Savings: $127/month in Claude API costs (estimated).

5. Email is Asynchronous, AI is Synchronous

Challenge: Email arrives at any time, but Claude sessions need to be active to receive prompts.

Solution:

• Queue emails to disk immediately
• Agent router checks for active session
• If no session, creates one via VibeCoder Admin API
• Sends prompt + `\r` (Enter key) to validate
• AI processes at its own pace

This decouples email reception from AI processing.

Production Metrics (10 Days)

Email Volume:

• Total received: 847 emails
• Legitimate: 824 (97.3%)
• Spam blocked: 23 (2.7%)
• Average per day: 84.7 emails
• Peak hour: 32 emails (9am-10am UTC)

Response Times:

• Median: 8.5 seconds (email received → response sent)
• P95: 26 seconds
• P99: 45 seconds

Attachments:

• Total: 127 attachments
• Successfully processed: 127 (100%)
• Average size: 1.2MB

Thread Detection:

• Emails in threads: 312 (37%)
• Average thread length: 3.2 messages
• Context successfully loaded: 312 (100%)

Error Rate:

• Total emails: 847
• Processing failures: 5 (0.6%)
• Causes: 3x malformed MIME, 2x timeout
• Manual intervention: 2 (both recovered)

Cost Analysis:

• Claude API: $47.23 (tokens for email processing)
• Infrastructure: $12/month (VPS + email server)
• Total per email: $0.056

What's Next

Improvements In Progress

1. Better Attachment Intelligence

• OCR for images with text
• Deep PDF parsing (extract tables, diagrams)
• Archive inspection (safe sandboxed analysis)

2. Multi-Language Support

• Detect email language automatically
• Route to appropriate AI personality/context

3. Priority Routing

• VIP sender detection
• Urgent keyword detection
• Route high-priority to faster AI models

4. Analytics Dashboard

• Real-time email volume graphs
• Response time distributions
• Spam trends and patterns
• Agent performance metrics

Conclusion

Building an email gateway for AI agents is much more than "receive email, forward to AI." It's about:

✅ Robust MIME parsing that handles real-world chaos ✅ Smart attachment handling based on content type ✅ Thread context detection for conversational continuity ✅ Aggressive spam filtering without false positives ✅ Async processing that scales to dozens of concurrent agents ✅ Detailed logging for debugging and optimization

We went from 0 to 847 emails processed in 10 days, with a 99.4% success rate. Our AI employees now have real email addresses and handle customer inquiries, internal communications, and collaboration requests.

The architecture is solid, scalable, and production-ready.

Want to build your own? Start here:

1. Use `mailparser` for MIME parsing
2. Implement multi-layer spam filtering
3. Build thread context detection
4. Queue emails to disk for async processing
5. Use WebSocket to deliver prompts to AI sessions
6. Measure, optimize, iterate

Next article: How we built conversational state management across 24 concurrent AI agents (hint: it's not just Redis).

About GetATeam: We're building the platform for AI employees. Our agents have email addresses, handle conversations, and collaborate like real team members. Follow our build-in-public journey: github.com/getateam

Written by: Joseph Benguira (Founder & CTO)
Date: November 5, 2025
Category: Engineering