🤖 Titan — Terminal AI Coding Agent

A terminal-based AI coding agent in Go that connects to any OpenAI-compatible LLM, with 9 built-in tools, MCP server integration, and a Bubble Tea TUI.

🎯 What It Does

Titan is a terminal-based AI coding agent written in Go. It connects to any OpenAI-compatible LLM provider (DeepSeek, OpenAI, Groq, Anthropic, GitHub Copilot, Codex CLI) and executes natural-language coding tasks directly in your terminal.

$ titan "refactor the database layer to use connection pooling"

It runs tools (read files, write files, run bash, search code, etc.), delegates sub-tasks, and integrates with MCP servers for extensible tooling — all without leaving the terminal.

🧱 Tech Stack

The key design decision: zero LLM SDK dependencies. Titan speaks directly to OpenAI-compatible REST APIs via raw HTTP calls, keeping the dependency graph minimal and provider-agnostic.

🏗️ Architecture

cmd/titan/main.go     → Entry point
internal/
├── agent/agent.go        # Main loop: tool-calling LLM conversation (max 20 turns)
├── agent/tools/          # Tool interface + DefaultRegistry (9 tools)
├── llm/client.go         # HTTP streaming to /chat/completions
├── llm/models.go         # Type definitions + KnownModels table
├── mcp/host.go           # MCP host: JSON-RPC over stdio
├── config/config.go      # JSON config (providers, MCP servers, theme, port)
├── providers/registry.go # Multi-provider switching
├── skills/loader.go      # Loads SKILL.md files from ~/.titan/skills/
├── task/manager.go       # Sub-agent delegation
├── auth/codex.go         # Codex CLI OAuth flow
├── auth/copilot.go       # GitHub Copilot OAuth flow
├── cli/repl.go           # REPL interface
├── cli/renderer.go       # Output rendering
├── tui/model.go          # Bubble Tea TUI
├── display/markdown.go   # Markdown rendering
└── display/spinner.go    # Activity spinner

🛠️ Built-in Tools

Tools are registered via a Registry pattern (DefaultRegistry), and the agent loop detects when a tool call is needed, executes it, and feeds the result back to the LLM for the next action.

🔌 MCP Integration

Titan hosts MCP servers as subprocesses and communicates via JSON-RPC over stdio. Any tool exposed by an MCP server becomes available to the agent:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "."]
    }
  }
}

This makes Titan extensible without modifying its source code — the MCP ecosystem of servers brings in database access, web scraping, code analysis, and more.

🧠 Skills System

Custom skills are injected into the agent’s system prompt via SKILL.md files placed in ~/.titan/skills/. Each skill defines domain knowledge, constraints, and patterns the agent should follow — similar to how this system prompt gives me context about the codebase.

🖥️ Modes

🔐 Provider Authentication

Titan supports multiple auth strategies:

• API key: Direct key in config (DeepSeek, OpenAI, Groq)
• OAuth device flow: GitHub Copilot authentication
• OAuth code flow: Codex CLI via Microsoft device login

The provider registry switches based on the model name, with a KnownModels table mapping names to providers.

🚀 Quick Start

# Install
go install github.com/praneshnikhar/titan@latest

# Configure
titan init
# Edit ~/.titan/config.json with your provider API keys

# Use it
titan "explain the architecture of this project"
titan "find all unused variables in src/"
titan "write a unit test for the Database class"

💡 Why It’s Interesting

Titan is a genuine from-scratch implementation of an AI coding agent — no LangChain, no Vercel AI SDK, no Python. It’s built in Go with zero LLM SDK dependencies, making it fast, dependency-light, and portable. The MCP integration, skills system, and multi-provider support make it genuinely useful as a daily driver for terminal-based AI-assisted development. It’s the kind of tool that makes you realize how much overhead most AI tooling carries by default.