🚧 Early Development

Root cause in seconds, not hours

The open-source AI debugger for distributed apps. Give your AI assistant "hands" inside your running code — profile live services, trace functions, and capture traffic without redeployment.

Get Started View on GitHub

terminal

$ coral ask "Why is the payment API slow?"

🤖 Analyzing host metrics and continuous profiles...

Host: api-v1-pod-abc (CPU: 12%, Mem: 45%)
Service: payment-api (P95: 2.3s)

Initial findings: High "Off-CPU" wait time detected in process.

Executing coral_profile_functions (strategy: critical_path)...

Analysis of 30s capture:
• ProcessPayment() total: 2.1s
└─ Mutex Contention: 1.8s (Blocked by Logger.Write)
└─ VFS Write (Disk I/O): 1.7s (Wait on /var/log/app.log)

Root Cause:
Synchronous logging to a slow disk volume is blocking the main execution thread.

⏱️ Root cause in seconds, zero code changes

$ coral ask "Why is the order-processor using 10GB of RAM?"

🤖 Analyzing host metrics and continuous memory profiles...

Host: worker-node-5 (CPU: 18%, Mem: 85% - 10.2GB)
Service: order-processor (Heap growth: +200MB/hour)

Memory leak detected. Analyzing allocation patterns...

Executing coral_profile_memory...

Top Memory Allocators (30s sample):
• cache.Store: 45.2% (523 MB/s)
└─ No TTL-based eviction detected

Root Cause:
cache.Store retains entries indefinitely, causing unbounded memory growth.

⏱️ <1 second analysis using your own LLM

The Problem: Debugging Is Still Manual

Modern distributed systems don’t fail in obvious ways. They fail across interactions — between services, retries, network calls, and kernel behavior.

Observability shows you symptoms. Engineers still have to investigate the cause.

🧩The Context Gap

Metrics spike. A trace looks slow. Logs look noisy. But none of them explain why. You jump between dashboards, correlate timestamps by hand, and try to reconstruct what actually happened.

🔁The Escalation Gap

When surface data isn’t enough, you add logs, enable tracing, redeploy, or attach a profiler. Each step is reactive, disruptive, and often changes the very behavior you're trying to observe.

⏱️Passive Tools, Active Toil

Traditional observability tools collect data. They don’t investigate. Finding the right question — across services and layers — is still a human task, and it dominates MTTR.

One Interface for Everything

👁️Observe

Passive, always-on data collection:

Zero-config eBPF metrics: Rate, Errors, Duration (RED)
Host health: Continuous monitoring of CPU, memory, disk, and network
Continuous profiling: Always-on CPU and memory profiling (<1% overhead)
OTLP ingestion: For apps using OpenTelemetry
Auto-discovered dependencies: Service connection mapping

🔍Explore

Deep introspection and investigation tools:

Remote execution: Run standard tools like netstat, curl, and grep on any agent
Remote shell: Jump into any agent's shell
On-demand profiling: High-frequency CPU profiling with Flame Graphs for line-level analysis
Live debugging: Attach eBPF uprobes to specific functions to capture args and return values
Traffic capture: Sample live requests to understand payload structures

🤖Diagnose

AI-powered insights for intelligent Root Cause Analysis (RCA):

Profiling-enriched summaries: AI gets metrics + code-level hotspots in one call
Regression detection: Automatically identifies performance shifts across deployment versions
Built-in assistant: Use coral ask directly from your terminal
Universal AI integration: Works with Claude Desktop, IDEs, any MCP client
Real-time data access: AI queries live observability data, not stale dashboards

MCP Integration: Use Any AI Assistant

Bring your own LLM - Claude Desktop, VS Code, Cursor, or custom apps

🤖

External AI

Claude • VS Code • Cursor

⌨️

Coral Ask

Built-in Terminal AI

MCP Protocol

🧠

Colony Server

MCP Server & Analytics

Encrypted Mesh

👁️

Agents

eBPF & OTLP Collection

Instrumentation & OTEL

📦

Application

SDK & Runtime

What Makes Coral Different?

A shift in how debugging works

Mode

You explore dashboards

Coral investigates systems

Escalation

You add logs & redeploy

Coral attaches live probes

Instrumentation

Pre-instrument everything

Instrument only when needed

Outcome

Symptoms

Root cause with evidence

How It Works

From observability to insights - a complete journey through Coral's architecture

Observe Everywhere

Progressive integration levels - start with zero-config, add capabilities as needed

Level 0

📡eBPF Probes

Zero-config RED metrics · No code changes required

Level 1

🔭OTLP Ingestion

Rich traces if using OpenTelemetry · Optional

Level 2

📊Continuous Intel

Always-on host metrics & continuous profiling · Low overhead

Level 3

🎯Deep Introspection

On-demand profiling, function tracing & active investigation

Agents collect locally

Aggregate Intelligently

Colony receives and stores data from all agents across your distributed infrastructure

→ DuckDB storage for fast analytical queries

→ Cross-agent correlation discovers dependencies

→ Encrypted mesh connects fragmented infrastructure

MCP Server exposes tools

Query with AI

Colony exposes MCP server for universal AI integration

→ Works with any MCP client: Claude Desktop, VS Code, Cursor, custom apps

→ Bring your own LLM: Anthropic, OpenAI, or local Ollama

→ Natural language queries: "Why is checkout slow?" instead of PromQL

Insights delivered

Act on Insights

Get actionable recommendations in natural language, execute with approval

→ Root cause analysis in <1 second

→ Actionable recommendations with evidence

→ Human-approved execution for safety

Get Started in Minutes

Install Coral

                            # macOS / Linux
brew install coral # COMING SOON

# Or download from GitHub Releases
                        

Start the Colony

coral colony start

Start Agent & Connect Services

coral agent start

Ask Questions

coral ask "What's happening with the API?"