Cognitive Task Orchestrator

GitOps for AI Agents - Where Code Ships Itself ⚡

💎 Production-Ready AI Development Platform - MCP Protocol Native 💎

Deploy autonomous Claude agents that ship production code via GitHub PRs

🚧 Development Status

This project is under active development. We're working towards a public release that will be available for general use by the end of Q3 2024 (September 2024). The platform is currently in beta and being refined based on internal usage and feedback.

Current Status: ✅ Core platform architecture implemented ✅ MCP server integration working ✅ Kubernetes controllers operational ✅ GitHub Apps authentication system 🔄 Documentation and user experience improvements 🔄 Public release preparation

Meet Your AI Development Dream Team

Five specialized agents with distinct personalities working together 24/7

Morgan

The Knowledge Architect

✍️ Personality: Articulate & organized
📖 Superpower: Explains complex things simply
💬 Motto: "Knowledge shared is knowledge squared!"

Morgan generates comprehensive documentation via docs() MCP calls, creating the foundation for all development work.

Rex

The Backend Powerhouse

🦀 Personality: Hardcore backend engineer
⚡ Superpower: Lightning-fast Rust implementation
💬 Motto: "Zero-cost abstractions, max performance!"

Rex builds APIs, services, and backend infrastructure through play() workflows, specializing in Rust and high-performance systems.

Blaze

The Interface Maestro

🎨 Personality: Creative & UX obsessed
✨ Superpower: Beautiful, responsive interfaces
💬 Motto: "Great UX makes complex simple!"

Blaze creates stunning frontends and user experiences, working alongside Rex for full-stack projects.

Cleo

The Quality Guardian

🎨 Personality: Meticulous & wise
🔍 Superpower: Spots improvements instantly
💬 Motto: "Excellence isn't negotiable!"

Cleo reviews code, refactors for quality, and ensures enterprise-grade standards in the QA phase of play() workflows.

Tess

The Testing Genius

🕵️ Personality: Curious & thorough
🎪 Superpower: Finds edge cases others miss
💬 Motto: "If it can break, I'll find it first!"

Tess creates comprehensive tests, validates functionality, and ensures reliability in the testing phase of play() workflows.

Cipher

The Security Sentinel

🛡️ Personality: Vigilant & protective
🔒 Superpower: Spots vulnerabilities early
💬 Motto: "Trust, but verify everything twice!"

Cipher handles security reviews, vulnerability scanning, and ensures enterprise-grade security across all workflows.

🌟 The Magic: How Your AI Team Collaborates

Watch the magic happen when they work together:

📚 Phase 1
Morgan documents
requirements & architecture

via docs() MCP call

⚡ Phase 2
Rex & Blaze build in parallel
(backend, frontend, or both)

via play() multi-agent workflows

🛡️ Phase 3
Cleo, Tess & Cipher ensure
quality, testing & security

via play() multi-agent orchestration

💡 Project Flexibility:

🦀 Backend Projects Rex builds APIs, services, databases	✨ Frontend Projects Blaze creates UIs, dashboards, apps
🚀 Full-Stack Projects Rex & Blaze work together seamlessly	🛡️ Quality Always Cleo reviews, Tess tests, Cipher secures

🎯 Result: Production-Ready Code

Fast • Elegant • Tested • Documented • Secure

It's like having a senior development team that never sleeps, never argues, and always delivers! 🎭

⚡ What CTO Does

The Cognitive Task Orchestrator provides powerful tools for AI-driven development:

📝 Documentation Generation (`docs()`)

Morgan analyzes your Task Master projects and creates comprehensive documentation automatically.

Task breakdowns with acceptance criteria
Implementation prompts for other agents
Architecture documentation
Automatic GitHub PR submission

🎮 Multi-Agent Play Workflows (`play()`)

The entire team orchestrates complex multi-agent workflows with event-driven coordination.

Phase 1 - Implementation: Rex/Blaze build the core functionality
Phase 2 - Quality Assurance: Cleo reviews and refactors
Phase 3 - Testing & Security: Tess validates, Cipher secures
Event-Driven Coordination: Automatic handoffs between phases
GitHub Integration: Each phase submits detailed PRs

🚀 Project Intake (`intake_prd()`)

Automatically process PRDs and create structured TaskMaster projects.

Reads project requirements and architecture
Generates comprehensive task breakdown
Creates TaskMaster structure with tasks.json
Submits project setup as GitHub PR

🔧 Workflow Management

Control and monitor your AI development workflows:

jobs() - List all running workflows with status
stop_job() - Stop any running workflow gracefully
input() - Send live messages to running AI agents
docs_ingest() - Intelligently analyze and ingest documentation from GitHub repos

All operations run as Kubernetes jobs with enhanced reliability through TTL-safe reconciliation, preventing infinite loops and ensuring proper resource cleanup.

🚀 Getting Started

Prerequisites

Access to a Cursor/Claude environment with MCP support
A project with Task Master initialized (.taskmaster/ directory)
GitHub repository for your project

🏗️ Platform Architecture

This is an integrated platform with crystal-clear data flow:

Component Architecture:

MCP Server (cto-mcp): Handles MCP protocol calls from Cursor/Claude with configuration-driven defaults
Controller Service: Kubernetes REST API that manages CodeRun/DocsRun CRDs via Argo Workflows
Argo Workflows: Orchestrates agent deployment through workflow templates
Kubernetes Controllers: Separate controllers for CodeRun and DocsRun resources with TTL-safe reconciliation
Agent Workspaces: Isolated persistent volumes for each service with session continuity
GitHub Apps: Secure authentication system replacing personal tokens

Data Flow:

Cursor/Claude calls MCP tools (docs(), play(), intake_prd(), etc.) via MCP protocol
MCP server loads configuration from cto-config.json and applies defaults
MCP server submits workflow to Argo with all required parameters
Argo Workflows creates CodeRun/DocsRun custom resources
Dedicated Kubernetes controllers reconcile CRDs with idempotent job management
Controllers deploy CLI agents (Claude Code, Cursor, Codex, OpenCode, Factory) as Jobs with workspace isolation
Agents authenticate via GitHub Apps and complete work
Agents submit GitHub PRs with automatic cleanup

📦 Installation

Deploy the Complete Platform

# Add the 5dlabs Helm repository
helm repo add 5dlabs https://5dlabs.github.io/cto
helm repo update

# Install Custom Resource Definitions (CRDs) first
kubectl apply -f https://raw.githubusercontent.com/5dlabs/cto/main/infra/charts/agent-platform/crds/platform-crds.yaml

# Install the agent-platform
helm install agent-platform 5dlabs/agent-platform --namespace agent-platform --create-namespace

# Setup agent secrets (interactive)
wget https://raw.githubusercontent.com/5dlabs/cto/main/infra/scripts/setup-agent-secrets.sh
chmod +x setup-agent-secrets.sh
./setup-agent-secrets.sh --help

Requirements:

Kubernetes 1.19+
Helm 3.2.0+
GitHub Personal Access Token
Anthropic API Key

What you get:

Complete agent-platform platform deployed to Kubernetes
REST API for task management
Separate Kubernetes controllers for CodeRun/DocsRun resources with TTL-safe reconciliation
Agent workspace management and isolation with persistent volumes
Automatic resource cleanup and job lifecycle management
MCP tools that connect to your deployment

Optional: Remote Cluster Access with TwinGate

To access your Kubernetes cluster from anywhere (not just local network), install TwinGate connector:

# Add TwinGate Helm repository
helm repo add twingate https://twingate.github.io/helm-charts
helm repo update

# Install TwinGate connector (replace tokens with your actual values)
helm upgrade --install twingate-weightless-hummingbird twingate/connector \
  -n default \
  --set connector.network="maroonsnake" \
  --set connector.accessToken="your-access-token" \
  --set connector.refreshToken="your-refresh-token"

Important: After installation, add your Kubernetes service CIDR as resources in TwinGate admin panel. This enables the MCP tools to reach the agent-platform service using internal Kubernetes service URLs (e.g., http://agent-platform.agent-platform.svc.cluster.local) from anywhere.

Install MCP Server

For Cursor/Claude integration, install the MCP server:

# One-liner installer (Linux/macOS)
curl --proto '=https' --tlsv1.2 -LsSf https://github.com/5dlabs/cto/releases/download/v0.2.0/tools-installer.sh | sh

# Verify installation
cto-mcp --help   # MCP server for Cursor/Claude integration

What you get:

cto-mcp - MCP server that integrates with Cursor/Claude
Multi-platform support (Linux x64/ARM64, macOS Intel/Apple Silicon, Windows x64)
Automatic installation to system PATH

⚙️ Configuration

Configure Project Settings

Create a cto-config.json file in your project root to configure agents, models, tool access, and workflow defaults:

{
  "version": "1.0",
  "defaults": {
    "docs": {
      "model": "claude-opus-4-1-20250805",
      "githubApp": "5DLabs-Morgan",
      "includeCodebase": false,
      "sourceBranch": "main"
    },
    "play": {
      "model": "claude-sonnet-4-20250514",
      "cli": "claude",
      "implementationAgent": "5DLabs-Rex",
      "qualityAgent": "5DLabs-Cleo",
      "testingAgent": "5DLabs-Tess",
      "repository": "your-org/your-repo",
      "service": "your-service",
      "docsRepository": "your-org/your-docs-repo",
      "docsProjectDirectory": "docs"
    },
    "intake": {
      "githubApp": "5DLabs-Morgan",
      "primary": {
        "model": "opus",
        "provider": "claude-code"
      },
      "research": {
        "model": "opus",
        "provider": "claude-code"
      },
      "fallback": {
        "model": "gpt-5",
        "provider": "openai"
      }
    },
    "docs_ingest": {
      "model": "claude-sonnet-4-20250514",
      "docServerUrl": "http://doc-server-agent-docs-server.mcp.svc.cluster.local:80"
    }
  },
  "agents": {
    "morgan": {
      "githubApp": "5DLabs-Morgan",
      "cli": "claude",
      "model": "claude-sonnet-4-20250514",
      "tools": {
        "remote": [
          "memory_create_entities",
          "memory_add_observations",
          "brave_search_brave_web_search",
          "rustdocs_query_rust_docs"
        ],
        "localServers": {
          "filesystem": {
            "enabled": true,
            "tools": ["read_file", "write_file", "list_directory", "search_files", "directory_tree"]
          },
          "git": {
            "enabled": true,
            "tools": ["git_status", "git_diff", "git_log", "git_show"]
          }
        }
      }
    },
    "rex": {
      "githubApp": "5DLabs-Rex",
      "cli": "codex",
      "model": "gpt-5-codex",
      "tools": {
        "remote": [
          "memory_create_entities",
          "memory_add_observations",
          "rustdocs_query_rust_docs"
        ],
        "localServers": {
          "filesystem": {
            "enabled": true,
            "tools": ["read_file", "write_file", "list_directory", "search_files", "directory_tree"]
          },
          "git": {
            "enabled": true,
            "tools": ["git_status", "git_diff", "git_log", "git_show"]
          }
        }
      }
    },
    "cleo": {
      "githubApp": "5DLabs-Cleo",
      "cli": "claude",
      "model": "claude-sonnet-4-20250514",
      "tools": {
        "remote": ["memory_create_entities", "memory_add_observations", "rustdocs_query_rust_docs"],
        "localServers": {
          "filesystem": {"enabled": true, "tools": ["read_file", "write_file", "list_directory", "search_files", "directory_tree"]},
          "git": {"enabled": true, "tools": ["git_status", "git_diff", "git_log", "git_show"]}
        }
      }
    },
    "tess": {
      "githubApp": "5DLabs-Tess",
      "cli": "claude",
      "model": "claude-sonnet-4-20250514",
      "tools": {
        "remote": ["memory_create_entities", "memory_add_observations"],
        "localServers": {
          "filesystem": {"enabled": true, "tools": ["read_file", "write_file", "list_directory", "search_files", "directory_tree"]},
          "git": {"enabled": true, "tools": ["git_status", "git_diff"]}
        }
      }
    }
  }
}

Agent Configuration Fields:

githubApp: GitHub App name for authentication
cli: Which CLI to use (claude, cursor, codex, opencode, factory)
model: Model identifier for the CLI
tools (optional): Fine-grained tool access control
- remote: Array of remote tool names from Toolman
- localServers: Local MCP server configurations
  - Each server specifies enabled and which tools the agent can access

Benefits:

CLI Flexibility: Different agents can use different CLIs
Model Selection: Each agent can use its optimal model
Tool Profiles: Customize tool access per agent
Security: Restrict agent capabilities as needed

Configure Cursor MCP Integration

After creating your configuration file, configure Cursor to use the MCP server by creating a .cursor/mcp.json file in your project directory:

{
  "mcpServers": {
    "cto-mcp": {
      "command": "cto-mcp",
      "args": [],
      "env": {}
    }
  }
}

Usage:

Create the cto-config.json file in your project root with your specific settings
Create the .cursor/mcp.json file to enable MCP integration
Restart Cursor to load the MCP server
All MCP tools will be available with your configured defaults

Benefits of Configuration-Driven Approach:

Simplified MCP Calls: Most parameters have sensible defaults from your config
Dynamic Agent Lists: Tool descriptions show available agents from your config
Consistent Settings: All team members use the same model/agent assignments
Easy Customization: Change defaults without modifying MCP server setup

🎨 Multi-CLI Support

The platform supports multiple AI coding assistants with the same unified architecture. Choose the CLI that best fits your workflow:

Claude Code

Official Anthropic CLI

Native Integration
Best for Claude models
Enterprise-ready

Cursor

Popular AI editor

VS Code-based
Rich IDE features
Excellent UX

Codex

Multi-model support

Provider Agnostic
Flexible configuration
OpenAI, Anthropic, more

OpenCode

Open-source CLI

Community Driven
Extensible architecture
Full transparency

Factory

Autonomous AI CLI

Auto-Run Mode
Unattended execution
CI/CD optimized

How It Works:

Each agent in cto-config.json specifies its cli and model
Controllers automatically use the correct CLI for each agent
All CLIs follow the same template structure
Seamless switching between CLIs per-agent

Example Multi-CLI Configuration:

{
  "agents": {
    "morgan": {
      "githubApp": "5DLabs-Morgan",
      "cli": "claude",
      "model": "claude-opus-4-20250514",
      "tools": {
        "remote": ["brave_search_brave_web_search", "rustdocs_query_rust_docs"]
      }
    },
    "rex": {
      "githubApp": "5DLabs-Rex",
      "cli": "factory",
      "model": "gpt-5-factory-high",
      "tools": {
        "remote": ["memory_create_entities", "rustdocs_query_rust_docs"]
      }
    },
    "blaze": {
      "githubApp": "5DLabs-Blaze",
      "cli": "opencode",
      "model": "claude-sonnet-4-20250514",
      "tools": {
        "remote": ["brave_search_brave_web_search"]
      }
    },
    "cleo": {
      "githubApp": "5DLabs-Cleo",
      "cli": "cursor",
      "model": "claude-sonnet-4-20250514",
      "tools": {
        "localServers": {
          "filesystem": {"enabled": true, "tools": ["read_file", "write_file"]}
        }
      }
    },
    "tess": {
      "githubApp": "5DLabs-Tess",
      "cli": "codex",
      "model": "gpt-4o",
      "tools": {
        "remote": ["memory_add_observations"]
      }
    }
  }
}

Each agent independently configured with its own CLI, model, and tool access.

🔧 MCP Tools Reference

The platform exposes 7 powerful MCP tools for AI-driven development:

1. `docs()` - Morgan's Documentation Magic

Analyzes your Task Master project and creates comprehensive documentation.

// Minimal call using config defaults
docs({
  working_directory: "projects/my-app"
});

// Override specific parameters if needed
docs({
  working_directory: "projects/my-app",
  agent: "morgan",
  model: "claude-opus-4-20250514",
  include_codebase: true
});

What Morgan does: ✅ Analyzes all tasks in your Task Master project
✅ Generates comprehensive documentation
✅ Creates implementation guidance for other agents
✅ Submits a GitHub PR with all documentation

2. `play()` - Multi-Agent Orchestration

Executes complex multi-agent workflows with event-driven coordination.

// Minimal call - the whole team collaborates!
play({
  task_id: 1
});

// Customize agent assignments
play({
  task_id: 1,
  implementation_agent: "rex",
  quality_agent: "cleo",
  testing_agent: "tess",
  repository: "myorg/my-project"
});

What the team does: ✅ Phase 1 - Implementation: Rex/Blaze builds the feature
✅ Phase 2 - Quality: Cleo reviews and refactors
✅ Phase 3 - Testing: Tess validates and tests
✅ Event-Driven: Automatic phase transitions
✅ GitHub Integration: PRs from each phase

3. `intake_prd()` - Project Intake Automation

Process PRDs and create structured TaskMaster projects.

// Process a new project
intake_prd({
  project_name: "my-awesome-app"
});

// Customize models and agents
intake_prd({
  project_name: "my-awesome-app",
  github_app: "5DLabs-Morgan",
  primary_model: "claude-opus-4-20250514"
});

What intake does: ✅ Reads PRD from {project_name}/intake/prd.txt
✅ Analyzes requirements and architecture
✅ Generates comprehensive task breakdown
✅ Creates TaskMaster structure with tasks.json
✅ Submits project setup as GitHub PR

4. `jobs()` - Workflow Status

List all running Argo workflows with simplified status info.

// List all workflows
jobs();

// Filter by type
jobs({
  include: ["play", "intake"]
});

// Specify namespace
jobs({
  namespace: "agent-platform"
});

Returns: List of active workflows with type, name, phase, and status

5. `stop_job()` - Workflow Control

Stop any running Argo workflow gracefully.

// Stop a specific workflow
stop_job({
  job_type: "play",
  name: "play-workflow-abc123"
});

// Stop with explicit namespace
stop_job({
  job_type: "intake",
  name: "intake-workflow-xyz789",
  namespace: "agent-platform"
});

Workflow types: intake, play, workflow

6. `input()` - Live Agent Communication

Send messages to running AI agents in real-time.

// Send message to active job
input({
  text: "Please add error handling for edge cases"
});

// Route by specific job name
input({
  text: "Update the API endpoint to use /v2",
  name: "code-5dlabs-cto-task-5",
  job_type: "code"
});

// Route by user label
input({
  text: "Can you explain your approach?",
  user: "jonathon"
});

Use cases: Provide guidance, answer questions, steer implementation

7. `docs_ingest()` - Documentation Analysis

Intelligently analyze GitHub repos and ingest documentation.

// Ingest repository documentation
docs_ingest({
  repository_url: "https://github.com/cilium/cilium",
  doc_type: "cilium"
});

// Custom doc server
docs_ingest({
  repository_url: "https://github.com/solana-labs/solana",
  doc_type: "solana",
  doc_server_url: "http://my-doc-server:80"
});

What it does: ✅ Uses Claude to analyze repository structure
✅ Determines optimal ingestion strategy
✅ Processes documentation intelligently
✅ Stores in searchable format for agents

📋 Complete MCP Tool Parameters

`docs` Tool Parameters

Required:

working_directory - Working directory containing .taskmaster folder (e.g., "projects/simple-api")

Optional (with config defaults):

agent - Agent name to use (defaults to defaults.docs.githubApp mapping)
model - Model to use for the docs agent (defaults to defaults.docs.model)
source_branch - Source branch to work from (defaults to defaults.docs.sourceBranch)
include_codebase - Include existing codebase as context (defaults to defaults.docs.includeCodebase)

`play` Tool Parameters

Required:

task_id - Task ID to implement from task files (integer, minimum 1)

Optional (with config defaults):

repository - Target repository URL (e.g., "5dlabs/cto") (defaults to defaults.play.repository)
service - Service identifier for persistent workspace (defaults to defaults.play.service)
docs_repository - Documentation repository URL (defaults to defaults.play.docsRepository)
docs_project_directory - Project directory within docs repository (defaults to defaults.play.docsProjectDirectory)
implementation_agent - Agent for implementation work (defaults to defaults.play.implementationAgent)
quality_agent - Agent for quality assurance (defaults to defaults.play.qualityAgent)
testing_agent - Agent for testing and validation (defaults to defaults.play.testingAgent)
model - Model to use for play-phase agents (defaults to defaults.play.model)

🎨 Template Customization

The platform uses a template system to customize agent behavior, settings, and prompts. Templates are Handlebars (.hbs) files rendered with task-specific data at runtime. Multi-CLI support lives alongside these templates so Claude, Codex, and future CLIs follow the same structure.

Model Defaults: Models are configured through cto-config.json defaults (and can be overridden via MCP parameters). We ship presets for Claude (claude-sonnet-4-20250514), Codex (gpt-5-codex), and Factory (gpt-5-factory-high), but any supported model for a CLI can be supplied via configuration.

Template Architecture

All templates now live under infra/charts/controller/agent-templates/ with CLI-specific subdirectories:

Docs Tasks (Claude today)

Prompts: Rendered from docs/claude/prompt.md.hbs into the ConfigMap
Settings: docs/claude/settings.json.hbs controls model, permissions, tools
Container Script: docs/claude/container.sh.hbs handles Git workflow and CLI execution

Code Tasks (multi-CLI)

Claude: code/claude/**
- Settings: code/claude/settings.json.hbs
- Container: code/claude/container.sh.hbs
Codex: code/codex/**
- Agents memory: code/codex/agents.md.hbs
- Config: code/codex/config.toml.hbs
- Container scripts: code/codex/container*.sh.hbs
Factory: code/factory/**
- Agents memory: code/factory/agents*.md.hbs
- Config: code/factory/factory-cli-config.json.hbs
- Container scripts: code/factory/container*.sh.hbs
Shared assets: code/mcp.json.hbs, code/coding-guidelines.md.hbs, and code/github-guidelines.md.hbs

Play Workflows: Multi-agent orchestration with event-driven coordination

Workflow Template: play-workflow-template.yaml defines the multi-phase workflow
Phase Coordination: Each phase triggers the next phase automatically
Agent Handoffs: Seamless transitions between implementation → QA → testing phases

How to Customize

1. Changing Agent Settings

Edit the settings template files directly:

# For docs (Claude) agents
vim infra/charts/controller/agent-templates/docs/claude/settings.json.hbs

# For code (Claude) agents
vim infra/charts/controller/agent-templates/code/claude/settings.json.hbs

# For code (Codex) agents
vim infra/charts/controller/agent-templates/code/codex/config.toml.hbs

Settings control:

Model selection (claude-opus-4, claude-sonnet-4, etc.)
Tool permissions and access
MCP tool configuration
Enterprise managed settings

See Claude Code Settings for complete configuration options.

2. Updating Prompts

For docs tasks (affects all documentation generation):

# Edit the docs prompt template
vim infra/charts/controller/agent-templates/docs/claude/prompt.md.hbs

For code tasks (affects specific task implementation):

# Edit task-specific files in your docs repository
vim {docs_project_directory}/.taskmaster/docs/task-{id}/prompt.md
vim {docs_project_directory}/.taskmaster/docs/task-{id}/task.md
vim {docs_project_directory}/.taskmaster/docs/task-{id}/acceptance-criteria.md

3. Customizing Play Workflows

For play workflows (affects multi-agent orchestration):

# Edit the play workflow template
vim infra/charts/controller/templates/workflowtemplates/play-workflow-template.yaml

The play workflow template controls:

Phase sequencing and dependencies
Agent assignments for each phase
Event triggers between phases
Parameter passing between phases

4. Adding Custom Hooks

Hooks are shell scripts that run during agent execution. Add new hook files beneath the CLI you are extending:

# Create new hook script (docs/Claude example)
vim infra/charts/controller/agent-templates/docs/claude/hooks/my-custom-hook.sh.hbs

# Create new hook script (code/Codex example)
vim infra/charts/controller/agent-templates/code/codex/hooks/my-custom-hook.sh.hbs

Hook files are automatically discovered and rendered. Ensure the hook name matches any references in your settings templates.

See Claude Code Hooks Guide for detailed hook configuration and examples.

5. Deploying Template Changes

After editing any template files, redeploy the agent-platform:

# Deploy template changes
helm upgrade agent-platform infra/charts/controller -n agent-platform

# Verify ConfigMap was updated (fullname = <release>-controller)
kubectl get configmap agent-platform-controller-agent-templates -n agent-platform -o yaml

Important: Template changes only affect new agent jobs. Running jobs continue with their original templates.

Template Variables

Common variables available in templates:

{{task_id}} - Task ID for code tasks
{{service_name}} - Target service name
{{github_user}} - GitHub username
{{repository_url}} - Target repository URL
{{working_directory}} - Working directory path
{{model}} - Claude model name
{{docs_repository_url}} - Documentation repository URL

💡 Best Practices

Configure cto-config.json first to set up your agents, models, tool profiles, and repository defaults
Always generate docs first to establish baseline documentation using docs()
Choose the right tool for the job:
- Use docs() for documentation generation
- Use play() for full-cycle development (implementation → QA → testing)
- Use intake_prd() for new project setup from PRDs
- Use jobs() / stop_job() / input() for workflow management
Mix and match CLIs - assign the best CLI to each agent based on task requirements
Customize tool access - use the tools configuration to control agent capabilities
Use minimal MCP calls - let configuration defaults handle most parameters
Review GitHub PRs promptly - agents provide detailed logs and explanations
Update config file when adding new agents, tools, or changing project structure

🛠️ Building from Source (Development)

# Build from source
git clone https://github.com/5dlabs/cto.git
cd cto/controller

# Build MCP server
cargo build --release --bin cto-mcp

# Verify the build
./target/release/cto-mcp --help   # MCP server

# Install to your system (optional)
cp target/release/cto-mcp /usr/local/bin/

🆘 Support

Check GitHub PRs for detailed agent logs and explanations
Review Task Master project structure in .taskmaster/ directory
Verify cto-config.json configuration and GitHub Apps authentication setup
Ensure Argo Workflows are properly deployed and accessible

📄 License

This project is licensed under the GNU Affero General Public License v3.0 (AGPL-3.0). This means:

You can use, modify, and distribute this software freely
You can use it for commercial purposes
⚠️ If you deploy a modified version on a network server, you must provide source code access to users
⚠️ Any derivative works must also be licensed under AGPL-3.0

The AGPL license is specifically designed for server-side software to ensure that improvements to the codebase remain open source, even when deployed as a service. This protects the open source nature of the project while allowing commercial use.

Source Code Access: Since this platform operates as a network service, users interacting with it have the right to access the source code under AGPL-3.0. The complete source code is available at this repository, ensuring full compliance with AGPL-3.0's network clause.

For more details, see the LICENSE file.

🔗 Related Projects

Task Master AI - The AI-powered task management system that works perfectly with this platform. Task Master AI helps you break down complex projects into manageable tasks, which can then be implemented using this platform's play() and intake_prd() MCP tools.

🚀 Roadmap

See our ROADMAP.md for upcoming features and planned enhancements to the platform.

🌟 Join the AI Development Revolution


⭐ Star Support project	🍴 Fork Build with us	💬 Discord Join community	🐦 X Get updates
📺 YouTube Watch tutorials	📖 Docs Learn more	🐛 Issues Report bugs	💡 Discuss Share ideas

Built with ❤️ and 🤖 by the 5D Labs Team

The platform runs on Kubernetes and automatically manages Claude agent deployments, workspace isolation, and GitHub integration. All you need to do is call the MCP tools and review the resulting PRs.

Name		Name	Last commit message	Last commit date
Latest commit History 2,184 Commits
.github		.github
controller		controller
docs		docs
infra		infra
mcp		mcp
scripts		scripts
sidecar		sidecar
.gitignore		.gitignore
.markdownlint.yaml		.markdownlint.yaml
.mcp.json		.mcp.json
.pre-commit-config.yaml		.pre-commit-config.yaml
.stop-hook-executed		.stop-hook-executed
.yamllint.yaml		.yamllint.yaml
AGENTS.md		AGENTS.md
LICENSE		LICENSE
README.md		README.md
ROADMAP.md		ROADMAP.md
client-config.json		client-config.json
cto-config-example.json		cto-config-example.json
cto-config.json		cto-config.json
cto-config.template.json		cto-config.template.json

🦀 Backend Projects Rex builds APIs, services, databases	✨ Frontend Projects Blaze creates UIs, dashboards, apps
🚀 Full-Stack Projects Rex & Blaze work together seamlessly	🛡️ Quality Always Cleo reviews, Tess tests, Cipher secures

Uh oh!

License

5dlabs/cto

Folders and files

Latest commit

History

Repository files navigation