Stop Running Solo: TinyAGI Orchestrates Agent Teams That Never Sleep

What if your AI assistants actually talked to each other? Not in some sci-fi future—in your terminal, right now, while you sleep.

Here's the brutal truth most developers won't admit: they're still treating AI like a fancy autocomplete. One model, one chat window, one exhausted human copy-pasting context between conversations. You've felt this pain. The Claude session that forgets your codebase. The ChatGPT thread that can't touch your local files. The endless tab switching between "coding assistant" and "documentation writer" while your actual project stalls.

But what if you could deploy entire teams of specialized AI agents that collaborate autonomously? Agents with isolated workspaces, persistent memory, and the ability to hand off work through chain execution and fan-out patterns? What if these teams operated 24/7 across every channel you already use—Discord, WhatsApp, Telegram—without you babysitting a single browser tab?

This isn't theoretical. This is TinyAGI, the agent teams orchestrator built specifically for the One Person Company. And it's about to change how you think about AI infrastructure forever.

What is TinyAGI? The Multi-Agent Revolution Explained

TinyAGI (formerly TinyClaw) is an open-source, multi-agent orchestration platform that transforms solitary AI interactions into collaborative team workflows. Created by the TinyAGI collective and released under the MIT license, it represents a fundamental shift from "one model, one user" to "many agents, many teams, many channels, zero human bottlenecks."

The project emerged from a simple observation: modern AI capabilities far outpace our interfaces for using them. While models like Claude and GPT-4 excel at specialized tasks, we force them into generic chat boxes and expect magic. TinyAGI inverts this paradigm. It provides the infrastructure layer that lets you define roles, assign workspaces, and let agents delegate work to each other through structured handoffs.

What makes TinyAGI genuinely disruptive is its operational maturity. This isn't a prototype or demo—it's a production-hardened system with SQLite-backed message queues, atomic transactions, retry logic with dead-letter management, and persistent sessions that survive restarts. The experimental badge in its README belies the sophistication underneath: WAL-mode SQLite for concurrency safety, parallel agent processing with per-agent sequential ordering guarantees, and a plugin architecture for custom extensions.

The timing couldn't be more critical. As AI coding assistants proliferate, developers face an unexpected coordination problem. You might have Claude Code for refactoring, Codex for generation, and custom models for review—but they're siloed. TinyAGI unifies these into collaborative teams with the tinyagi CLI as your single control plane. The project's rapid evolution from TinyClaw to TinyAGI signals ambitious expansion, with active Discord community growth and consistent releases.

Key Features: The Technical Architecture That Makes It Possible

TinyAGI's feature set reveals deep systems thinking. Let's dissect what separates this from superficial "multi-agent" wrappers:

Isolated Agent Workspaces with True Process Separation Each agent receives its own directory (~/tinyagi-workspace/{agent_id}/), independent conversation history, and dedicated CLI invocation. The coder agent doesn't leak context into writer's state. This isn't sandbox theater—it's filesystem-level isolation with per-agent .claude/, heartbeat.md, and AGENTS.md configurations.

Multi-Team Orchestration with Chain Execution and Fan-Out Teams support two critical collaboration patterns. Chain execution: Agent A completes work, explicitly mentions Agent B, triggering automatic handoff. Fan-out: One agent broadcasts to multiple teammates simultaneously. The teams package handles conversation state management, ensuring responses aggregate correctly before returning to users.

Multi-Channel Presence with Unified Conversation State Discord, WhatsApp, and Telegram integrations aren't afterthoughts—they're first-class channel clients with shared agent conversations. Message @coder fix bug from WhatsApp, follow up on Discord, and the agent maintains continuous context. The sender pairing system provides security through approval codes, preventing unauthorized access.

TinyOffice Web Portal: Browser-Based Command Center Built on Next.js, TinyOffice offers real-time dashboarding, Kanban task management, org chart visualization, and Slack-style persistent chat rooms per team. It auto-detects build requirements and connects to your local API at localhost:3777—no accounts, no cloud dependency.

Live TUI Dashboard for Terminal Natives The tinyagi team visualize command launches a real-time terminal interface showing agent chains, message flows, and system health. For developers who live in the terminal, this eliminates context switching entirely.

SQLite Queue with Production-Grade Reliability The message queue uses WAL-mode SQLite for atomic transactions, eliminating race conditions. Messages progress through pending → processing → completed/dead states with automatic retry (5 attempts) and dead-letter quarantine. Failed messages don't vanish—they're diagnosed.

Provider Flexibility: Anthropic, OpenAI, and Custom Endpoints Native support for Claude Code CLI and Codex CLI, plus arbitrary OpenAI/Anthropic-compatible endpoints through custom providers. Configure OpenRouter, self-hosted models, or corporate proxies via settings.json with harness selection (claude or codex).

24/7 Operation with Heartbeat Automation Agents execute periodic heartbeat checks—scanning for pending tasks, errors, and unread messages—then take autonomous action. Configure per-agent heartbeat.md prompts for customized proactive behavior.

Use Cases: Where TinyAGI Transforms Workflows

The Autonomous One-Person Company

Imagine running a consultancy where you're the only human. Your sales agent monitors incoming inquiries across channels, your architect agent designs solutions, your coder agent implements them, and your reviewer agent validates quality—all coordinating through team handoffs while you focus on client relationships. The heartbeat system means agents proactively surface blockers without polling.

Cross-Functional Development Teams

A dev team with coder, reviewer, and writer agents handles complete feature delivery. You message @dev implement OAuth: the leader (coder) designs the flow, executes implementation, mentions @reviewer for security audit, then @writer for documentation. Fan-out patterns let reviewer and writer work in parallel. You receive the consolidated result.

24/7 Infrastructure Monitoring

Deploy a sre team with monitor, diagnose, and remediate agents. The heartbeat prompt checks service health, logs, and alerts. On anomaly detection, monitor chains to diagnose for root cause analysis, then remediate for automated fixes—with human escalation via your preferred channel for destructive operations.

Multi-Device, Multi-Context Personal Assistance

Start a conversation with your assistant agent on WhatsApp while commuting, continue debugging with coder on Discord from your desktop, and review completed tasks through TinyOffice on a tablet. Persistent sessions mean context follows you, not your device. The SQLite queue ensures no messages drop during network transitions.

Step-by-Step Installation & Setup Guide

TinyAGI prioritizes zero-configuration starts without sacrificing depth. Here's the complete path from installation to production operation.

Prerequisites

Ensure your environment meets these requirements:

• Operating System: macOS, Linux, or Windows (WSL2 required for Windows)
• Node.js: Version 18 or higher
• CLI Dependencies: Claude Code CLI for Anthropic provider access; Codex CLI for OpenAI provider access

One-Line Installation (Recommended)

Execute the official installer:

curl -fsSL https://raw.githubusercontent.com/TinyAGI/tinyagi/main/scripts/install.sh | bash

This script downloads, builds, and globally installs the tinyagi command. Post-installation, launch with:

tinyagi

What happens automatically: TinyAGI creates ~/tinyagi-workspace, generates default settings.json, starts the background daemon, and opens TinyOffice in your browser. No wizard, no manual API key configuration (though you'll add these for production use).

Development Installation (From Source)

For contributors or those needing bleeding-edge features:

git clone https://github.com/TinyAGI/tinyagi.git
cd tinyagi && npm install && npm run build
npx tinyagi start
npx tinyagi agent list

Docker Deployment

For containerized 24/7 operation:

# With environment variable
docker compose up -d

# Or with explicit API key
ANTHROPIC_API_KEY=sk-ant-... docker compose up -d

The API exposes on http://localhost:3777 with data persisted in the tinyagi-data Docker volume.

Channel Configuration

Enable multi-channel presence after initial setup:

tinyagi channel setup

This interactive wizard configures:

• Discord: Requires bot token from Discord Developer Portal with "Message Content Intent" enabled
• Telegram: Bot token from @BotFather after /newbot creation
• WhatsApp: QR code scan from Settings → Linked Devices after TinyAGI startup

API Key Management

Store credentials securely without separate CLI authentication:

# Anthropic OAuth (preferred for Claude Code)
tinyagi provider anthropic --oauth-token sk-ant-oat01-...

# Anthropic API key (fallback)
tinyagi provider anthropic --api-key sk-ant-...

# OpenAI API key
tinyagi provider openai --api-key sk-...

Anthropic OAuth takes priority if both token types exist. OpenAI keys propagate as OPENAI_API_KEY environment variable. Unconfigured providers inherit from existing environment variables.

REAL Code Examples from the Repository

Let's examine actual implementation patterns from TinyAGI's documentation, with detailed explanations of the architecture and practical usage.

Example 1: Custom Provider Configuration

TinyAGI's provider system enables integration with any OpenAI or Anthropic-compatible endpoint. Here's the exact configuration structure from the README:

{
  "custom_providers": {
    "my-proxy": {
      "name": "My Proxy",
      "harness": "claude",
      "base_url": "https://proxy.example.com/v1",
      "api_key": "sk-...",
      "model": "claude-sonnet-4-6"
    }
  }
}

Critical implementation details: The harness field determines which CLI wrapper TinyAGI invokes—claude for Anthropic-compatible endpoints, codex for OpenAI-compatible ones. This abstraction lets you route coder agent through a corporate proxy with Claude models while writer uses OpenRouter with GPT-4o, all within the same team workflow. The base_url supports self-hosted models, enabling complete air-gapped deployments for security-sensitive environments.

Assign this custom provider to any agent:

# Basic assignment
tinyagi agent provider coder custom:my-proxy

# With model override
tinyagi agent provider coder custom:my-proxy --model gpt-4o

The custom: prefix namespace prevents collisions with built-in providers. Model overrides at assignment time let you pin specific versions without modifying global configuration.

Example 2: Agent Configuration with Isolated Workspaces

Each agent's independence stems from this configuration structure:

{
  "agents": {
    "coder": {
      "name": "Code Assistant",
      "provider": "anthropic",
      "model": "sonnet",
      "working_directory": "/Users/me/tinyagi-workspace/coder"
    },
    "writer": {
      "name": "Technical Writer",
      "provider": "custom:my-proxy",
      "model": "gpt-5.3-codex",
      "working_directory": "/Users/me/tinyagi-workspace/writer"
    }
  }
}

Architecture insight: The working_directory isolation is non-negotiable for reliable multi-agent operation. When coder invokes claude CLI, it operates within /Users/me/tinyagi-workspace/coder with that directory's .claude/ configuration, AGENTS.md context file, and conversation history. writer cannot accidentally read coder's files or pollute its context. This mirrors production microservices patterns—shared-nothing architecture prevents cascading failures.

The heartbeat.md file in each workspace enables autonomous behavior customization:

Check for:

1. Pending tasks
2. Errors
3. Unread messages

Take action if needed.

Modify this per-agent to implement domain-specific proactive checks—security scanning for sre agents, dependency updates for coder agents, or content calendar monitoring for marketing agents.

Example 3: Team Configuration with Chain Execution

Teams define collaboration topology:

{
  "teams": {
    "dev": {
      "name": "Development Team",
      "agents": ["coder", "reviewer"],
      "leader_agent": "coder"
    }
  }
}

Execution semantics: When you message @dev fix the auth bug, TinyAGI routes to leader_agent (coder). coder processes the request, and if its response mentions @reviewer, the message enters reviewer's queue with full conversation context. After reviewer completes, responses aggregate and return to you. This isn't simple forwarding—it's structured handoff with state preservation.

The teams package implements both sequential chains (single handoff) and parallel fan-out (multiple mentions). For complex workflows, chain depth is limited by queue timeout configurations, preventing infinite delegation loops.

Example 4: Complete Settings.json Production Configuration

Here's the comprehensive configuration structure for production deployments:

{
  "channels": {
    "enabled": ["discord", "telegram", "whatsapp"],
    "discord": { "bot_token": "..." },
    "telegram": { "bot_token": "..." },
    "whatsapp": {}
  },
  "workspace": {
    "path": "/Users/me/tinyagi-workspace",
    "name": "tinyagi-workspace"
  },
  "agents": {
    "tinyagi": {
      "name": "TinyAGI Agent",
      "provider": "anthropic",
      "model": "opus",
      "working_directory": "/Users/me/tinyagi-workspace/tinyagi"
    }
  },
  "teams": {
    "dev": {
      "name": "Development Team",
      "agents": ["coder", "reviewer"],
      "leader_agent": "coder"
    }
  },
  "custom_providers": {
    "my-proxy": {
      "name": "My Proxy",
      "harness": "claude",
      "base_url": "https://proxy.example.com/v1",
      "api_key": "sk-...",
      "model": "claude-sonnet-4-6"
    }
  },
  "models": {
    "anthropic": { 
      "api_key": "sk-ant-...", 
      "oauth_token": "sk-ant-oat01-..." 
    },
    "openai": { "api_key": "sk-..." }
  },
  "monitoring": {
    "heartbeat_interval": 3600
  }
}

Security consideration: API keys in settings.json are stored plaintext. For production, restrict filesystem permissions (chmod 600) and consider Docker secrets or environment injection for containerized deployments. The models section's dual credential support for Anthropic enables graceful fallback if OAuth tokens expire.

Advanced Usage & Best Practices

Optimize heartbeat intervals for workload patterns. Set heartbeat_interval: 300 (5 minutes) for reactive customer-facing agents, 3600 (1 hour) for batch processing agents. The heartbeat prompt is fully customizable—train agents to check specific APIs, file timestamps, or external triggers.

Implement dead-letter monitoring. Failed messages enter .tinyagi/queue/dead/ after 5 retries. Schedule periodic tinyagi logs queue review or automate alerts through the plugin system's event hooks. Dead letters reveal provider rate limits, context window overflows, or malformed configurations.

Leverage sender pairing for public deployments. The approval-code system prevents API abuse. For internal tools, pre-approve team members. For client-facing bots, require explicit approval per sender with tinyagi pairing approve ABCD1234.

Use workspace templates for rapid agent provisioning. Copy a configured .claude/ directory and AGENTS.md template to new agent workspaces. Standardize prompts, tool access, and behavior guardrails across your organization.

Monitor with tinyagi team visualize during incident response. The TUI dashboard shows real-time queue depth, processing latency, and agent health. Identify bottlenecks when specific agents accumulate backlogs.

Comparison with Alternatives

Why TinyAGI wins: It's the only solution combining production operations (SQLite queue, daemon mode, Docker), native multi-channel presence, and genuine team collaboration primitives in a single deployable system. Others require you to build infrastructure; TinyAGI provides it.

FAQ: Common Developer Concerns

Is TinyAGI stable enough for production use? The experimental badge indicates rapid API evolution, not instability. The SQLite queue, retry logic, and persistent sessions are production-hardened. Pin versions in Docker deployments and review release notes before updating.

Can I use TinyAGI without Claude Code or Codex CLI? Not currently—these CLIs provide the core agent invocation layer. However, custom providers with harness selection offer flexibility for compatible alternatives as the ecosystem evolves.

How does message routing work across channels? All channels enqueue to the same SQLite queue. Agent responses broadcast to all channels where the originating sender is approved. Channel-specific formatting is handled by channel clients, not agents.

What's the maximum team size? Limited by SQLite concurrency and your API rate limits. Practical deployments run 5-10 agents per team smoothly. For larger scale, the plugin architecture supports external queue backends.

Can agents share files or code between workspaces? Intentionally restricted for isolation. Use explicit message handoffs with code snippets, or mount shared read-only volumes for common libraries. The files/ directory in .tinyagi/ handles uploaded file distribution.

How do I debug when agents loop or conflict? Check tinyagi logs all for handoff chains. The team visualize TUI shows real-time message flow. Set heartbeat_interval to 0 to disable autonomous actions during debugging.

Is there cloud hosting or SaaS available? Currently self-hosted only. The Docker deployment simplifies infrastructure, and the MIT license permits commercial hosting derivatives.

Conclusion: The Future of Work Is Teams of Agents

TinyAGI represents more than incremental improvement—it's a paradigm shift in how developers operationalize AI. The One Person Company isn't a limitation to work around; it's a superpower when amplified by autonomous agent teams that collaborate, persist, and proactively execute across every channel you use.

The technical architecture reveals serious engineering: WAL-mode SQLite for reliability, filesystem-isolated agents for safety, chain and fan-out orchestration for genuine collaboration, and a web portal that rivals commercial alternatives. This isn't vaporware or a weekend project—it's infrastructure for the next decade of AI-augmented development.

My assessment? If you're still running AI assistants in isolated browser tabs, you're leaving exponential productivity on the table. TinyAGI's learning curve is minimal—the one-line installer proves that—but the capability ceiling is extraordinarily high. Start with a single agent, add channels, then build teams. Within weeks, you'll wonder how you operated any other way.

Ready to deploy your first agent team? Clone the repository, run the installer, and join the Discord community where contributors are actively shaping the roadmap. The future of autonomous AI collaboration is open-source, and it's waiting at github.com/TinyAGI/tinyagi.

Tiny but mighty. Teams of agents, 24/7, across every channel. That's TinyAGI. 🦞✨