@agenticmail/enterprise

The Complete AI Agent Workforce Platform

Deploy, manage, and govern AI agents as first-class employees — each with their own email, phone number, calendar, browser, tools, memory, and identity. Enterprise-grade security, compliance, and multi-tenant isolation built in.

npx @agenticmail/enterprise

One command. Interactive setup wizard. Full platform in under 2 minutes.

Getting Started (5 Minutes)

☁️ Option A: Deploy on AgenticMail Cloud (Recommended)

Get a free yourcompany.agenticmail.io subdomain — live in under 2 minutes.

npx @agenticmail/enterprise

The wizard will ask you to:

1. Select deploy target → Choose "AgenticMail Cloud"
2. Pick your subdomain → e.g., acme → your dashboard is at https://acme.agenticmail.io
3. Create admin account → Name, email, password
4. Done → Dashboard opens. Create your first agent.

$ npx @agenticmail/enterprise

  Deploy target: AgenticMail Cloud (free)
  Subdomain: acme.agenticmail.io
  ✓ Database provisioned
  ✓ Schema migrated (32 tables)
  ✓ Admin account created

  Dashboard: https://acme.agenticmail.io
  ✓ Live! Create your first agent →

No servers to manage. No Docker. No ports to open. No infra. Everything runs on our infrastructure — you just configure from the dashboard.

Option B: Self-Hosted

Same wizard, different deploy target:

npx @agenticmail/enterprise

The wizard walks you through:

1. Database — Pick SQLite (zero config) or paste a Postgres URL. We auto-detect Supabase/Neon and optimize connection pooling automatically.
2. Admin Account — Name, email, password
3. Deploy Target — Cloudflare Tunnel (free, no ports to open), Docker, Railway, Fly.io, or local
4. Dashboard — Opens automatically. Everything is managed from the UI.

Database Options

Supabase users: The wizard auto-optimizes your connection string — switches to transaction mode, adds PgBouncer params, and generates a direct URL for migrations. Zero manual config.

What You Get

Once setup completes, open the dashboard and you'll see:

• Setup Checklist — guided steps to configure email, create agents, etc.
• Create Agent — pick from 51 personality templates or build your own
• Full Admin Dashboard — 28 pages covering every aspect of agent management

Everything is managed from the dashboard — agent creation, permissions, email setup, channel connections, DLP rules, workforce schedules, compliance reports. No code needed.

Create Your First Agent

1. Click "Create Agent" in the dashboard
2. Choose a soul template (e.g., "Executive Assistant", "Sales Rep", "Developer")
3. Add your LLM API key in Settings → API Keys (or in the agent's config)
4. Configure permissions — set what tools the agent can use, package managers it can access, sudo privileges, etc.
5. Start the agent — it gets its own email, tools, and identity

What's Next?

• Connect Gmail — Give your agent real email access via OAuth (Agent Detail → Email tab)
• Add Telegram/WhatsApp — Connect messaging channels (Agent Detail → Channels tab)
• Set up DLP — Apply pre-built rule packs to protect sensitive data (DLP page → Rule Packs)
• Configure Shifts — Set work hours and on-call schedules (Workforce page)
• Set Dependency Policy — Control what packages agents can install, allow sudo, set computer password (Agent Detail → Permissions tab)

Table of Contents

• Why AgenticMail Enterprise
• Quick Start
• Architecture
• Dashboard
• Agent Runtime
• Agent Tools
• Google Workspace Integration
• 145 SaaS Integration Adapters
• Enterprise Skills
• Database Backends
• Security & Compliance
• Data Loss Prevention (DLP)
• Multi-Tenant & Organizations
• Workforce Management
• Knowledge Base & RAG
• Communication & Task Pipeline
• Agent Autonomy System
• Meeting & Voice Intelligence
• Multimodal Support
• Deployment
• CLI Commands
• Environment Variables
• Community Skills Marketplace
• API Reference
• License

Why AgenticMail Enterprise

Most AI agent platforms give you a chatbot. We give you a workforce.

• Real Identity — Each agent gets a real email address, phone number (Google Voice), Google Workspace access, and digital presence
• Real Autonomy — Agents clock in/out, check email, respond to messages, join Google Meet calls and speak like humans, and work independently
• Real Governance — DLP scanning, guardrails, approval workflows, compliance reporting, action journaling with rollback
• Real Scale — Multi-tenant isolation, org-scoped everything, role-based access control, budget gates
• Real Integration — 145 SaaS adapters, 13 Google Workspace tools, full browser automation, shell access, filesystem tools

By the Numbers

Quick Start

Option A: Interactive Wizard (Recommended)

npx @agenticmail/enterprise

The wizard walks you through:

1. Database — Pick from 10 backends with smart auto-configuration (auto-detects Supabase/Neon pooler mode, generates direct URLs for migrations, adds ?pgbouncer=true automatically)
2. Admin Account — Name, email, password, company name
3. Email Delivery — Optional SMTP/OAuth setup
4. Custom Domain — Optional: point your own domain via Cloudflare tunnel
5. First Agent — Create your first AI agent with a soul template

Option B: Programmatic

import { createServer, createAdapter, smartDbConfig } from '@agenticmail/enterprise';

const db = await createAdapter(smartDbConfig(process.env.DATABASE_URL));
await db.migrate();

const server = createServer({
  port: 3000,
  db,
  jwtSecret: process.env.JWT_SECRET,
  runtime: {
    enabled: true,
    apiKeys: { anthropic: process.env.ANTHROPIC_API_KEY },
  },
});

await server.start();

Option C: Standalone Agent

Run an agent as its own process (recommended for production):

node dist/cli.js agent --env-file=.env.fola

Each agent runs independently with its own port, connects to the shared database, and registers with the main server for health checks and lifecycle management.

Architecture

┌──────────────────────────────────────────────────────────────┐
│                     Admin Dashboard (28 pages)                │
│         React · Dark/Light themes · Real-time updates         │
│   Agents · Workforce · DLP · Compliance · Vault · Knowledge   │
│   Activity · Journal · Guardrails · Task Pipeline · Audit     │
├──────────────────────────────────────────────────────────────┤
│                      Hono API Server                          │
│   Auth · Admin · Engine (82 modules) · Middleware (9 layers)  │
├──────────────────────────────────────────────────────────────┤
│                    Engine Core                                │
│  Lifecycle · Permissions · DLP · Guardrails · Compliance      │
│  Journal · Approvals · Policies · Knowledge · Memory          │
│  Communication · Workforce · Vault · Storage · Autonomy       │
│  Onboarding · Soul Library · Tool Catalog · OAuth Connect     │
│  Meeting Monitor · Voice Intelligence · Activity Tracking     │
├──────────────────────────────────────────────────────────────┤
│                   Agent Runtime                               │
│  LLM Client (multi-provider) · Session Manager               │
│  Tool Executor (270+ tools) · Sub-Agent Spawning              │
│  Budget Gates · Model Fallback · Streaming                    │
├──────────────────────────────────────────────────────────────┤
│              Messaging & Channels                             │
│  Email (Gmail/Outlook) · Telegram · WhatsApp                  │
│  Google Chat · Browser Automation · Voice/Meetings            │
├──────────────────────────────────────────────────────────────┤
│            Integration Layer                                  │
│  145 SaaS Adapters · 13 Google Workspace Services             │
│  MCP Framework · OAuth Connect · Dependency Manager           │
├──────────────────────────────────────────────────────────────┤
│               Database Adapter Layer                          │
│  Postgres · MySQL · SQLite · MongoDB · DynamoDB · Turso       │
│  Supabase · Neon · PlanetScale · CockroachDB                  │
│  Smart pooler detection · Auto-optimized connections          │
└──────────────────────────────────────────────────────────────┘

Middleware Stack

Dashboard

28 full pages + 23 agent detail tabs, served directly from the enterprise server:

Platform Pages

Agent Detail Tabs (per agent)

Features

• Dark/Light themes with CSS custom properties
• Dynamic brand color from company settings
• Org switcher on every page for multi-tenant filtering
• Real-time SSE streaming for live updates
• 49 built-in documentation pages accessible from the dashboard
• Transport encryption — Optional AES-GCM encryption for all API traffic

Agent Runtime

Full standalone agent execution — agents run as independent processes with their own port, tools, memory, and messaging channels.

Runtime Features

Standalone Agent Mode

# .env.fola
DATABASE_URL=postgresql://...  # Shared DB (auto-optimized for pooler)
AGENT_ID=3eecd57d-03ae-440d-8945-5b35f43a8d90
PORT=3102
ANTHROPIC_API_KEY=sk-ant-...

# Start
node dist/cli.js agent --env-file=.env.fola

The agent automatically:

• Connects to the shared database (with smart pooler detection)
• Loads its configuration, permissions, and soul from DB
• Starts messaging channels (Telegram, WhatsApp, email)
• Begins autonomy features (clock in, morning triage)
• Registers health endpoint for dashboard monitoring

Agent Tools

270+ tools organized by category, with intelligent tiered loading to minimize token costs:

Smart Tool Loading

Tools are loaded on-demand using a 3-tier system — agents don't pay for 270 tool definitions on every message:

A simple "Thank you" on Telegram loads 50 tools (8K tokens) instead of 270 (~33K tokens) — 75% token savings. The agent can always request more tools mid-conversation, and conversation signals auto-promote relevant tools (mention "calendar" → calendar tools load automatically).

Core Tools

Google Workspace Tools

Microsoft 365 Tools

Microsoft tools auto-detect via OAuth provider — if the agent has Microsoft OAuth configured, all Graph API tools become available. Includes production-grade retry with exponential backoff, 429 rate-limit handling, auto-pagination, and JSON batch support.

Enterprise Tools

Agent Management Tools

Messaging Tools

Dependency Management

Google Workspace Integration

Deep, native integration with 13 Google Workspace services:

Agents can:

• Read and respond to emails
• Create and manage calendar events
• Upload and share Drive files
• Edit Google Docs, Sheets, and Slides
• Join Google Meet calls with voice (ElevenLabs TTS + virtual audio device)

Microsoft 365 Integration

Deep, native integration with 13 Microsoft services via Microsoft Graph API:

Auto-detected via OAuth provider — connect Microsoft OAuth in the dashboard and all tools become available. Each service has its own dedicated system prompt with tool usage guidance.

Production-grade Graph API client:

• Retry with exponential backoff (3 attempts)
• 429 rate-limit handling with Retry-After header
• Auto-pagination via @odata.nextLink (up to 500 items)
• JSON batch support (up to 20 requests per batch)
• Beta endpoint support for preview APIs

145 SaaS Integration Adapters

Pre-built MCP adapters for connecting agents to any SaaS tool:

Each adapter provides:

• Tool definitions with parameter schemas
• API executor with credential resolution from Vault
• OAuth flow configuration
• Rate limit handling and pagination

Enterprise Skills

52 pre-built skill definitions:

Google Workspace Suite (14)

Gmail · Calendar · Drive · Docs · Sheets · Slides · Forms · Meet · Chat · Keep · Sites · Groups · Admin · Vault

Microsoft 365 Suite (13 services, 90+ tools)

Outlook Mail (20 tools) · Outlook Calendar (7) · Teams (15) · OneDrive (12) · Excel (16) · SharePoint (10) · OneNote (6) · Planner (6) · To Do (6) · PowerPoint (5) · Power BI (8) · Contacts (5) · Each with dedicated system prompts and Graph API integration with retry, rate-limit handling, pagination, and batch support.

Enterprise Custom Suite (16+)

Calendar · Code Sandbox · Database · Diff · Documents · Finance · HTTP · Knowledge Search · Logs · Notifications · Security Scan · Spreadsheet · Translation · Vision · Web Research · Workflow

Soul Templates (51)

14 categories of agent personality templates:

Custom role templates can be created and managed via the Roles dashboard page.

Database Backends

10 backends, all implementing the same adapter interface with full feature parity:

Smart Connection Auto-Configuration

When you provide a DATABASE_URL, the system automatically:

1. Detects your provider — Supabase, Neon, or generic Postgres from the hostname
2. Optimizes the connection — Switches Supabase session mode (port 5432) to transaction mode (port 6543), adds ?pgbouncer=true
3. Generates a direct URL — For migrations and DDL operations that need real transactions (bypasses PgBouncer)
4. Configures pool sizing — Conservative pool limits for shared PgBouncer setups (max 3 per process), generous for direct connections (max 10)
5. Sets idle timeouts — 2s for PgBouncer (fast release), 30s for direct connections
6. Handles connection errors gracefully — Automatic retry with ROLLBACK recovery for aborted transactions

import { smartDbConfig, createAdapter } from '@agenticmail/enterprise';

// Automatically optimized — no manual config needed
const db = await createAdapter(smartDbConfig('postgresql://postgres.ref:pass@pooler.supabase.com:5432/postgres'));
// → Switches to port 6543, adds ?pgbouncer=true, generates direct URL for migrations

The setup wizard shows all auto-configurations in the UI:

• 🟢 Provider detection (Supabase, Neon)
• ✨ Auto-configured optimizations (pooler mode, pgbouncer param)
• 🔗 Pooler URL and Direct URL (for migrations)

Security & Compliance

Authentication

Authorization

Transport Encryption

Optional AES-GCM encryption for all API responses:

• Dashboard derives encryption key from user password
• All API responses wrapped in {"_enc":"..."} in the network tab
• SSE streams excluded (EventSource can't send custom headers)
• Protects against network-level MITM even without HTTPS

Compliance Reporting

5 report types with full HTML export for auditors:

Reports include:

• Agent names resolved (not raw UUIDs)
• Organization/company name
• Generator identity
• Both positive (controls in place) and negative (gaps) findings
• Professional HTML export with enterprise styling

Action Journal & Rollback

Every agent action is journaled with:

• Before/after state snapshots
• Actor identity and timestamp
• Rollback capability for reversible actions
• Detail modal with full context
• Org-scoped filtering

Audit Logging

Every mutating API call is logged with:

• Actor (user or agent)
• Organization scope
• Action type and details
• IP address and request ID
• Org-scoped filtering in dashboard

Data Loss Prevention (DLP)

Enterprise-grade DLP with real-time content scanning:

7 Pre-Built Rule Packs (53 rules)

DLP Features

• One-click rule pack deployment — Apply entire packs from the dashboard
• Per-rule enable/disable — Toggle rules without deleting them
• Rule editing — Full modal editor for pattern, action, severity
• Detail modal — Click any rule to see full configuration
• Violation tracking — Real-time scanning with severity levels
• Org-scoped — Rules and violations filtered by organization

Multi-Tenant & Organizations

Internal Organizations

• Multiple organizations within one deployment
• Org switcher on every dashboard page
• Org-scoped data: agents, users, audit logs, vault, DLP, compliance, workforce, activity
• 4 plan tiers: Free (3 agents), Team (25), Enterprise (unlimited), Self-Hosted (unlimited)

External Client Organizations

• Create client organizations for external customers
• Bind users to a client org with "full access"
• Strict data isolation — org-bound users only see their client org's data
• Impersonation respects org boundaries
• Billing records per client org per agent per month

SSO Configuration

Workforce Management

Manage agents like employees:

Knowledge Base & RAG

Communication & Task Pipeline

Agent-to-Agent Messaging

• Direct messages between agents
• Broadcast messages to all agents
• Topic-based channels
• Priority levels: normal, high, urgent
• Email-based delivery via agent addresses

Task Pipeline

• Real-time table view — Paginated task list with search, sort, and status tabs (Active, Completed, Failed, All)
• Live SSE updates — Tasks appear, update, and move between tabs instantly as agents work
• Cross-process webhook relay — Standalone agent processes notify the enterprise server, so the dashboard updates in real-time even when agents run as separate processes
• Delegation chain visualization — Click any task to see the full delegation flow (who assigned → who worked → review loops)
• Stats cards — Active, completed, failed counts with today's metrics, token usage, and cost
• Org-scoped views — Client org users only see their agents' tasks
• Activity log — Per-task activity timeline with search and type filtering

External Channels

Agent Autonomy System

Agents operate independently with configurable autonomy features:

🎙️ Meeting & Voice Intelligence — Agents That Join Calls and Speak

Your AI agents join Google Meet calls and participate with natural human-like voice. This isn't a transcription bot — agents actually listen, understand context, and respond verbally in real-time using ElevenLabs TTS.

• Join any Google Meet — Agent opens the browser, clicks "Join", and enters the meeting
• Speak with natural voice — ElevenLabs TTS generates human-quality speech routed through a virtual audio device
• Listen and understand — Real-time transcription feeds into the agent's context so it knows what's being discussed
• Context-aware responses — Agent draws on its email, calendar, documents, and memory to give informed answers
• Multi-agent meetings — Multiple agents can join the same call and collaborate
• Automatic meeting notes — Agent generates summaries and action items after the call

Use cases: Daily standups, client demos, team syncs, investor updates, sales calls, onboarding sessions, interview screening.

Multimodal Support

Agents can process media sent via messaging channels:

Media handling includes:

• Automatic download from Telegram/WhatsApp
• Base64 encoding for LLM vision models
• Temporary file cleanup
• Dependency auto-installation (ffmpeg, etc.)

Deployment

Zero-Config (Recommended)

npx @agenticmail/enterprise

The setup wizard handles everything. After setup, the system is self-managing.

Automatic System Persistence

AgenticMail automatically configures itself to survive reboots, crashes, and network outages — you never run a single command:

Works on every platform — automatically:

All persistence setup runs once on first boot and writes a marker file. Subsequent boots just save the process list silently.

Self-Update System

AgenticMail includes a built-in self-update system — 4 ways to stay current:

# One command to update everything
agenticmail-enterprise update

# Just check, don't install
agenticmail-enterprise update --check

# Set up automatic updates (cron job / Windows Task Scheduler)
agenticmail-enterprise update --cron

The update process: installs the latest npm package globally, finds all AgenticMail PM2 processes, restarts them, and saves the PM2 config. Zero downtime for agents — they restart in seconds.

Production Log Levels

Set LOG_LEVEL=warn in your .env file for production deployments.

Manual PM2 (Advanced)

# Or use the ecosystem config for full control:
pm2 start ecosystem.config.cjs
pm2 save

Docker / Fly.io / Railway

npx @agenticmail/enterprise  # Select your deploy target
# Wizard handles everything

CLI Commands

# Interactive setup wizard (default)
npx @agenticmail/enterprise

# Start the server
npx @agenticmail/enterprise start

# Run a standalone agent
npx @agenticmail/enterprise agent --env-file=.env.fola

# Validate a community skill
npx @agenticmail/enterprise validate ./community-skills/my-skill/
npx @agenticmail/enterprise validate --all --json

# AI-assisted skill scaffolding
npx @agenticmail/enterprise build-skill

# Submit a skill to the marketplace
npx @agenticmail/enterprise submit-skill ./community-skills/my-skill/

# Domain recovery
npx @agenticmail/enterprise recover --domain agents.agenticmail.io --key <hex>

# DNS verification
npx @agenticmail/enterprise verify-domain

# Self-update
npx @agenticmail/enterprise update              # Update + restart all services
npx @agenticmail/enterprise update --check       # Check for updates without installing
npx @agenticmail/enterprise update --cron        # Set up automatic updates (every 6 hours)
npx @agenticmail/enterprise update --no-restart  # Update without restarting PM2

Environment Variables

Community Skills Marketplace

Build and share skills:

Creating a Skill

npx @agenticmail/enterprise build-skill

Skill Manifest

{
  "name": "my-skill",
  "version": "1.0.0",
  "description": "What this skill does",
  "author": "your-name",
  "category": "productivity",
  "tools": [
    {
      "name": "my_tool",
      "description": "Tool description",
      "parameters": { "type": "object", "properties": {} },
      "riskLevel": "low",
      "sideEffects": ["read"]
    }
  ],
  "config": [
    { "name": "API_KEY", "type": "secret", "required": true }
  ]
}

Validation & Submission

npx @agenticmail/enterprise validate ./my-skill/
npx @agenticmail/enterprise submit-skill ./my-skill/

Skills are synced from the GitHub registry every 6 hours to all deployments.

API Reference

The API is organized into 3 major route groups:

Auth (/api/auth/*)

Login, refresh, logout, SSO callbacks, bootstrap, 2FA, impersonation

Admin (/api/admin/*)

Agent CRUD, user management, settings, audit log, bridge API

Engine (/api/engine/*)

82 modules exposed across 22+ route sub-apps:

Requirements

• Node.js 18+ (22+ recommended)
• Database — Any of the 10 supported backends
• LLM API Key — Anthropic, OpenAI, xAI, or Google (at least one)

License

MIT — See LICENSE

Built with AgenticMail · Docs · Discord