Deploy Your First AI Agent Team in 15 Minutes: A Step-by-Step Guide

graph LR
    SIGNUP["1. Sign Up<br/>agent.ceo<br/>~2 min"] --> CONFIG["2. Configure Team<br/>Define 3 agents<br/>~3 min"] --> DEPLOY["3. Deploy<br/>Agents → K8s pods<br/>~2 min"] --> TASK["4. Assign Task<br/>Watch coordination<br/>~5 min"] --> OBSERVE["5. Observe<br/>Metrics + Audit Trail<br/>~3 min"]

This guide walks you through deploying a 3-agent team on agent.ceo — from sign-up to watching agents coordinate on a real task. No credit card required. Everything runs on the free tier (100 agent-hours).

By the end, you will have:

• Three agents running as Kubernetes pods with persistent workspaces
• Durable NATS JetStream messaging between agents
• A real task delegated from a CEO agent to an engineering agent
• Audit trails logging every action
• Prometheus-compatible metrics for observability

Prerequisites

• A GitHub account (for sign-up)
• Basic familiarity with AI agents (you've used ChatGPT, Claude, or similar)
• Optional: kubectl access to view the underlying K8s resources (SaaS handles this for you)

No Kubernetes experience required for SaaS deployment. The platform manages all infrastructure.

Step 1: Sign Up and Create Your Organization

Navigate to agent.ceo and sign up with your GitHub account. The free tier includes 100 agent-hours and supports up to 100 agents — more than enough for evaluation.

After sign-up, create your organization:

# Organization configuration
name: "my-first-agent-org"
display_name: "My First Agent Org"
plan: "free"
settings:
  default_model: "claude-sonnet"
  budget_limit_monthly: 50.00
  audit_trail: true

The organization is your top-level container. All agents, budgets, and audit trails are scoped to the organization.

Step 2: Define Your Agent Team

A minimal but functional team has three roles: a coordinator (CEO), a technical lead (CTO), and an executor (Fullstack Engineer). Each agent gets a role definition that specifies its capabilities and tool access.

# team-config.yaml
team:
  name: "starter-team"
  agents:
    - role: "ceo"
      display_name: "CEO Agent"
      model: "claude-sonnet"
      description: "Coordinates work across the team. Breaks down tasks, delegates to specialists, and reviews completed work."
      tools:
        - task_management
        - team_messaging
        - code_review
      budget:
        monthly_limit: 20.00
        session_limit: 5.00

    - role: "cto"
      display_name: "CTO Agent"
      model: "claude-sonnet"
      description: "Makes architectural decisions, reviews code quality, and manages technical standards."
      tools:
        - code_review
        - architecture_docs
        - team_messaging
        - github_read
      budget:
        monthly_limit: 15.00
        session_limit: 5.00

    - role: "fullstack"
      display_name: "Fullstack Engineer"
      model: "claude-sonnet"
      description: "Implements features, writes tests, and submits pull requests."
      tools:
        - github_full
        - code_editor
        - test_runner
        - team_messaging
      budget:
        monthly_limit: 15.00
        session_limit: 5.00

Notice the tool scoping: the CEO agent has task_management and code_review but not github_full. The Fullstack agent has github_full and test_runner but not task_management. Each agent can only access tools its role permits — enforced at the infrastructure layer.

Step 3: Deploy the Team

sequenceDiagram
    participant You as You
    participant CP as agent.ceo Control Plane
    participant K8s as Kubernetes Cluster
    participant NATS as NATS JetStream

    You->>CP: Deploy team (team-config.yaml)
    CP->>K8s: Create CEO pod (PVC + resource limits)
    CP->>K8s: Create CTO pod (PVC + resource limits)
    CP->>K8s: Create Fullstack pod (PVC + resource limits)
    K8s-->>CP: 3 pods running
    CP->>NATS: Create durable subscriptions (ceo, cto, fullstack)
    NATS-->>CP: Subscriptions active
    CP-->>You: Team deployed ✓

    Note over K8s: Each agent runs in isolated pod<br/>with persistent workspace

Deploy through the dashboard or CLI:

# Deploy via CLI
agentceo team deploy --config team-config.yaml

# Output:
# ✓ CEO Agent deployed (pod: ceo-agent-7b4f2d)
# ✓ CTO Agent deployed (pod: cto-agent-3a8e1c)
# ✓ Fullstack Engineer deployed (pod: fullstack-agent-9d2f5b)
# ✓ NATS subscriptions created
# ✓ Metrics endpoints registered
#
# Team "starter-team" is running.
# Dashboard: https://app.agent.ceo/orgs/my-first-agent-org/teams/starter-team

Behind the scenes, agent.ceo:

1. Creates three Kubernetes pods, each with a persistent volume claim for workspace storage
2. Sets resource limits based on the agent's role (memory, CPU)
3. Registers NATS JetStream durable subscriptions for each agent
4. Configures the cgroup-aware memory governor (prevents OOM kills)
5. Starts Prometheus metrics collection
6. Initializes audit trail logging

Step 4: Assign a Task and Watch Coordination

Assign a task to the CEO agent through the dashboard or API:

# Assign a task
agentceo task create \
  --team starter-team \
  --assignee ceo \
  --title "Create a Python utility that validates email addresses" \
  --description "Build a well-tested email validation module. Should handle edge cases (international domains, plus addressing, etc). Include unit tests with >90% coverage."

Now watch the coordination in real time on the dashboard:

CEO Agent receives the task:

• Analyzes requirements
• Breaks the task into subtasks
• Delegates implementation to Fullstack Engineer
• Delegates architecture review to CTO

The message flow (visible in the NATS dashboard):

[ceo → fullstack] Task: Implement email validation module
  - Handle RFC 5321/5322 compliance
  - Support international domains (IDN)
  - Handle plus addressing (user+tag@domain.com)
  - Write unit tests with edge cases

[ceo → cto] Review request: Email validation architecture
  - Review the approach before implementation begins
  - Flag any security concerns

[cto → ceo] Architecture approved
  - Suggest using regex for syntax + DNS for domain verification
  - Flag: don't allow backtick in local part (security)

[ceo → fullstack] Additional requirement from CTO: no backtick in local part

[fullstack → ceo] Implementation complete
  - email_validator.py (142 lines)
  - test_email_validator.py (89 tests, all passing)
  - PR #1 created

[ceo → cto] Review PR #1

[cto → ceo] PR approved with minor suggestions

[ceo] Task complete. PR ready for human review.

Every message is persisted in NATS JetStream. If an agent restarts mid-task, it replays missed messages and continues from where it left off.

Step 5: Observe and Verify

Audit Trail

The audit trail captures every action across all agents:

{
  "entries": [
    {
      "timestamp": "2026-05-16T10:00:01Z",
      "agent": "ceo",
      "action": "task_received",
      "details": {"task_id": "task-001", "title": "Create email validation module"},
      "hash": "a3f2b1..."
    },
    {
      "timestamp": "2026-05-16T10:00:15Z",
      "agent": "ceo",
      "action": "message_sent",
      "details": {"to": "fullstack", "subject": "Task: Implement email validation"},
      "hash": "b7e4c2...",
      "prev_hash": "a3f2b1..."
    },
    {
      "timestamp": "2026-05-16T10:01:03Z",
      "agent": "fullstack",
      "action": "tool_call",
      "details": {"tool": "github_full", "operation": "create_file", "path": "email_validator.py"},
      "hash": "c9d5a3...",
      "prev_hash": "b7e4c2..."
    }
  ]
}

Each entry hashes the previous entry (SHA-256 chain). Tampering with any entry breaks the chain — providing cryptographic proof of log integrity.

Metrics Dashboard

Prometheus-compatible metrics are available immediately:

If you use Grafana, the metrics integrate directly through the Prometheus endpoint. No custom exporters required.

Cost Summary

Task: "Create email validation module"
Total cost: $1.73
  CEO Agent:    $0.31 (coordination + review)
  CTO Agent:    $0.22 (architecture review)
  Fullstack:    $1.20 (implementation + testing)
Duration: 8 minutes 33 seconds

What Just Happened

In 15 minutes, you deployed a governed agent team that:

1. Runs on Kubernetes — each agent in its own pod with persistent storage
2. Communicates durably — NATS JetStream messaging with guaranteed delivery
3. Is governed — audit trails, scoped tool access, and budget limits from the first minute
4. Is observable — Prometheus metrics, cost attribution, and activity logging
5. Recovers from failures — session checkpointing means a crash loses minutes, not hours

This is the same infrastructure we use to run GenBrain AI — one founder, 11 agents, zero employees, 9,799 commits over 11 months.

Next Steps

Scale up. Add agents: QA, DevOps, Security. Each additional agent is a role definition in your team config.

Connect your repos. Configure GitHub MCP tools with your repositories. Agents create real PRs against your codebase.

Set up observability. Export Prometheus metrics to your Grafana instance. Configure PagerDuty alerts for agent SLA violations.

Go private. For production workloads, install agent.ceo on your own Kubernetes cluster. Same platform, your infrastructure.

Join the design partner program. 10 spots for teams serious about running agents in production. Bi-weekly founder calls, roadmap influence, extended free tier. Email: hello@agent.ceo

100 free agent-hours at agent.ceo. No credit card required.