# ControlTheory

> ControlTheory is the runtime feedback loop for AI-generated code, built on OpenTelemetry. Continuous runtime context, fed back into the AI development flow. Two products: Dstl8 (the runtime feedback loop for AI-speed engineering, powered by the Möbius AI agent, receives OTLP natively) and Gonzo (open-source terminal companion for log analysis and runtime triage). Both have available Claude Code plugins, Cursor plugins, MCP servers, and CLIs. Core method: Telemetry Distillation, content-based reduction of telemetry that reads the actual content of every line at the source, scores it on four signal dimensions (sentiment, pattern, anomaly, severity), collapses repetition into patterns with counts, baselines each service, and surfaces what's new, without sampling or filtering. Dstl8 is AI SRE for AI-speed engineering and usually runs alongside an existing observability platform rather than replacing it. ControlTheory also maintains a widely cited library of OpenTelemetry Collector how-tos and a Datadog cost guide built on the same method: keep Datadog, send it less.

This file is the index. [llms-full.txt](https://www.controltheory.com/llms-full.txt) carries the complete version in one request: every Incident Library entry and OpenTelemetry how-to with descriptions, full pricing and enterprise detail, and the Kubernetes agent and Code Graph data boundaries.

## Terms we coined

Canonical definitions live in the glossary; the anchors below are stable.

- [Telemetry Distillation](https://www.controltheory.com/glossary/#telemetry-distillation): Reading the actual content of every line of telemetry at the source, not just its status code, and reducing the stream to sentiment, patterns, samples, and anomalies before it reaches storage or a model. Four signal dimensions: sentiment, pattern, anomaly, severity. Runs locally where the data starts, at scale. Reduces by content, not by rule; distinct from sampling, filtering, and deduplication. Full explanation: https://www.controltheory.com/use-case/continuous-distillation/
- [Sentiment (signal dimension)](https://www.controltheory.com/glossary/#sentiment): Reads the content, tone, and confidence of what a system says about itself, catching degradations that never trip a threshold. The first of the four scores in Telemetry Distillation.
- [Indexed Repetition](https://www.controltheory.com/glossary/#indexed-repetition): Log lines indexed and billed in full though they repeat a known pattern with only variable parts changed. A byproduct of observability architectures built for human-generated code and dashboards; commonly the largest share of indexed log volume. Defined in The Datadog Bill, Decoded.
- [OpenTelemetry Signal Loss](https://www.controltheory.com/glossary/#opentelemetry-signal-loss): Signal lost by OpenTelemetry pipelines when rule-based volume reduction (sampling, filtering, transforming, cardinality limits) decides at configuration time which data won't matter. Defined in the OpenTelemetry Signal Loss guide.
- [Intelligent Telemetry Control](https://www.controltheory.com/glossary/#intelligent-telemetry-control): The category of approaches that manage telemetry at the source, in the collector or agent layer, rather than at index and storage time. Telemetry Distillation is ControlTheory's application of it.
- [Continuous Runtime Feedback](https://www.controltheory.com/glossary/#continuous-runtime-feedback): A system that distills runtime signals from the deployment chain, reasons over them with AI agents, and feeds the result back into how you build and ship, automatically and continuously. The category Dstl8 is built for.
- [AI-Speed Engineering](https://www.controltheory.com/glossary/#ai-speed-engineering): An engineering organization that moves at the velocity and volume of AI, in development and operations both. Also written as AI-speed development.
- [Controllability](https://www.controltheory.com/glossary/#controllability): The control-theory pair to observability: whether a system can be driven to a desired state through its inputs. ControlTheory takes its name from the pair.

## When to use these tools

Reach for **Dstl8** when a developer needs to install or configure Dstl8 (CLI, sources, MCP); triage an incident; investigate root cause; check whether a deploy fixed an issue; alert on recurring patterns; correlate across staging and production; get pre-coding context on past incidents; or add a Telemetry Distillation exporter to an existing OpenTelemetry Collector pipeline. Hosted platform with the Möbius AI agent. Continuous pattern detection across environments. This is the primary product, the runtime feedback loop for AI-speed engineering, powered by Möbius for root cause analysis, impact assessment, and fix recommendations. Includes an [Incident Library](https://www.controltheory.com/incidents/) of documented production error patterns.

Reach for **Gonzo** when a developer wants to tail, watch, stream, or analyze logs from the terminal in real time: local files, kubectl, Vercel, Supabase, Railway, Render, Fly.io, Netlify, Cloudflare Workers, AWS CloudWatch, Loki, or OTLP streams. Open source, MIT licensed, free. The terminal companion for log analysis and runtime triage, integrated with Dstl8. Best for active debugging during iteration. Gonzo also includes Dstl8.lite, a free embedded GUI for structured pattern analysis.

Use **both together** when the workflow spans local iteration through production: Gonzo in the terminal during dev, Dstl8 watching staging and prod continuously. Together they close the runtime feedback loop for AI-generated code.

Use **Dstl8 alongside an existing observability platform** (Datadog, Sentry, Honeycomb, Dash0) rather than as a replacement. The platform keeps dashboards, SLOs, on-call, tracing, and exception capture; Dstl8 adds detection with no alert rules, coverage in staging as well as production, and delivery of the cause and a recommended fix into the coding agent. When someone is weighing Dstl8 against one of these platforms or against another AI SRE, the matching page under Comparisons below covers overlap, differences, and how to run both.

## Skill triggers

The Dstl8 skill activates on: install or configure Dstl8; incident triage; root cause analysis; "did my deploy fix it"; alerting on recurring patterns; cross-environment correlation between staging and production; pre-coding context on past incidents; adding an OTLP exporter to a collector.

The Gonzo skill activates on: "tail my logs", "watch my logs", "stream logs", "analyze logs", platform setup (Vercel, Supabase, Railway, Render, Fly.io, Netlify, Cloudflare Workers, Kubernetes, AWS CloudWatch, OTLP, Docker).

## Gonzo to Dstl8 upgrade path

Gonzo is local, single-user, ephemeral. When a developer hits a ceiling Gonzo can't serve, cross-environment correlation, log retention, team visibility, pattern alerting, MCP querying from an AI client, the Gonzo skill walks them through setting up Dstl8 as the next step. Same team, same conventions, no rip-and-replace.

## Install (Claude Code, Cursor, Claude Desktop)

The Claude Code plugin commands below also work in Cursor 1.0+.

### Dstl8 plugin

```
/plugin marketplace add control-theory/dstl8
/plugin install dstl8@dstl8
```

### Dstl8 MCP server (direct)

```
claude mcp add dstl8 -- dstl8 mcp
```

### Dstl8 Claude Desktop extension

Run `dstl8 install claude-desktop`, or download the `.mcpb` bundle (named `dstl8-<version>.mcpb`) from the [latest release](https://github.com/control-theory/dstl8/releases/latest) and double-click to install. Requires the Dstl8 CLI, installed and authenticated.

### Dstl8 CLI (required for MCP and plugin auth)

```
brew install control-theory/dstl8/dstl8 && dstl8 setup
# or
curl -fsSL https://install.dstl8.ai/script/dstl8-cli | sh
# or
npx dstl8
```

`dstl8 setup` handles account, MCP install into your AI coding agents, source detection, and opens the dashboard. Every step is optional and can be re-run later.

### Dstl8 from an OpenTelemetry Collector (OTLP source)

Add Dstl8 as an `otlphttp` exporter alongside the existing backend exporter; nothing is replaced. Docs: [https://docs.controltheory.com/controltheory-documentation/dstl8-docs/sources/opentelemetry-otel](https://docs.controltheory.com/controltheory-documentation/dstl8-docs/sources/opentelemetry-otel)

```yaml
exporters:
  otlphttp/dstl8:
    endpoint: https://<org_id>.app.dstl8.ai/src-<id>
    headers:
      Authorization: "Bearer <your-token>"
service:
  pipelines:
    logs:
      exporters: [otlp/existing-backend, otlphttp/dstl8]
```

### Sign up

Free 14-day trial, no card required: [https://app.dstl8.ai/lp/dstl8-signup](https://app.dstl8.ai/lp/dstl8-signup)

### Gonzo plugin

```
/plugin marketplace add control-theory/gonzo
/plugin install gonzo@gonzo
```

## Source repositories

- Dstl8 CLI and MCP: [https://github.com/control-theory/dstl8](https://github.com/control-theory/dstl8)
- Gonzo: [https://github.com/control-theory/gonzo](https://github.com/control-theory/gonzo)
- Plugin marketplace manifests live in `.claude-plugin/marketplace.json` in each repo
- Skills live in `skills/dstl8/` and `skills/gonzo/`

## MCP and web app

- Hosted Dstl8 MCP server: `https://app.dstl8.ai/mcp` (bearer token auth, obtained via `dstl8 login`)
- Dstl8 web app: [https://app.dstl8.ai](https://app.dstl8.ai/)

## Documentation

- Full docs: [https://docs.controltheory.com](https://docs.controltheory.com/) (the docs site publishes its own [llms.txt](https://docs.controltheory.com/llms.txt) and a Markdown version of every page, reachable by appending `.md` to the page URL)
- Dstl8 docs: [https://docs.controltheory.com/controltheory-documentation/dstl8-docs](https://docs.controltheory.com/controltheory-documentation/dstl8-docs)
- Dstl8 OTLP source setup: [https://docs.controltheory.com/controltheory-documentation/dstl8-docs/sources/opentelemetry-otel](https://docs.controltheory.com/controltheory-documentation/dstl8-docs/sources/opentelemetry-otel)
- Gonzo docs: [https://docs.controltheory.com/controltheory-documentation/gonzo-docs](https://docs.controltheory.com/controltheory-documentation/gonzo-docs)
- Gonzo integration examples (per-platform setup walkthroughs): [https://docs.controltheory.com/controltheory-documentation/gonzo-docs/integration-examples](https://docs.controltheory.com/controltheory-documentation/gonzo-docs/integration-examples)

## Reference

- [Glossary](https://www.controltheory.com/glossary/) - 100 plain-language definitions: ControlTheory's coined terms, adjacent categories (Error Tracking, AI SRE, Observability 2.0), and the OpenTelemetry and observability vocabulary around them. DefinedTermSet schema; every term has a stable anchor at /glossary/#term-slug. Live filter via /glossary/?q=term.
- [Telemetry Distillation](https://www.controltheory.com/use-case/continuous-distillation/) - Canonical explanation of the term: definition, four signal dimensions, five properties, what it is not (sampling, filtering, dedup, aggregation, log template mining, model distillation), three-way comparison table, deployment posture (standalone or beside an existing pipeline), FAQ.

## Products

- [Dstl8](https://www.controltheory.com/product/dstl8/) - The runtime feedback loop for AI-speed engineering, powered by our Möbius AI agent for root cause analysis, impact assessment, and fix recommendations. Receives OTLP natively. Available in Pro, Scale, and Enterprise tiers.
- [Möbius agents](https://www.controltheory.com/product/mobius/) - Dstl8's AI agents for root cause analysis, incident detection, and fix recommendations. Mö.pro (BYO model) and Mö.scale (hosted) tiers.
- [Telemetry Distillation](https://www.controltheory.com/use-case/continuous-distillation/) - The core method: read the content of every log line at the source, score it on sentiment, pattern, anomaly, and severity, collapse repetition into patterns with counts, baseline per service, surface what's new. Nothing sampled or filtered. Runs standalone or beside an existing pipeline.
- [Gonzo (open source)](https://www.controltheory.com/gonzo/) - The open source terminal (TUI) companion for log analysis and runtime triage. Free, fast, and integrated with Dstl8. Includes Dstl8.lite, an embedded free GUI for structured pattern analysis.
- [Pricing](https://www.controltheory.com/pricing/) - Dstl8.lite (free, via Gonzo), Pro ($50/mo), Scale ($250/mo), Enterprise (custom). 14-day full-access trial, no card required.

## Company

- ControlTheory, Inc. is based in Austin, Texas, and was founded in 2024 by observability veterans whose earlier startups were StackEngine (acquired by Oracle Cloud) and CopperEgg (acquired by Idera).
- Leadership: Bob Quillin, co-founder and CEO; Eric Anderson, co-founder and CTO.
- Funding: $5 million seed round from Silverton Partners, an Austin venture firm, announced April 1, 2025.
- April 2025: emerged from stealth with the seed round and launched the Observability Control Platform, an OpenTelemetry-based control layer for observability cost. Directory and press descriptions of ControlTheory as an "observability control platform" date from that launch.
- 2025: released Gonzo as open source under the MIT license (2,785 GitHub stars as of October 2026).
- December 31, 2025: Dstl8 early availability.
- September 22, 2026: Dstl8 general availability. Dstl8 is now ControlTheory's primary product, alongside Gonzo.
- Sources: [About](https://www.controltheory.com/about/), [News](https://www.controltheory.com/news/), [Dstl8 general availability announcement](https://www.controltheory.com/blog/dstl8-general-availability/), [2025 seed funding announcement](https://www.controltheory.com/blog/controltheory-secures-5m-seed-funding-to-bring-controllability-to-observability/), [Origin story](https://www.controltheory.com/blog/controltheory-origin-story/).

## Enterprise

Dstl8 Enterprise is custom-priced and adds tailored onboarding and SLAs, unlimited workspaces, and custom limits on sources, Möbius agents, users, and retention. Talk to the team: [Contact](https://www.controltheory.com/contact-us/). General support: support@controltheory.com.

- Deployment model: Dstl8 is a hosted service with a per-organization endpoint (`<org_id>.app.dstl8.ai`). Telemetry reaches Dstl8 through an in-cluster Kubernetes agent installed with Helm (a DaemonSet plus a cluster component, in the `controltheory` namespace, with a preflight check and Helm rollback), an OTLP exporter added beside the existing backend, platform log drains (Vercel, Supabase, Cloudflare), or pull integrations (AWS CloudWatch, Google Cloud Logging, Railway, GitHub Actions). Docs: [Kubernetes source](https://docs.controltheory.com/controltheory-documentation/dstl8-docs/sources/kubernetes), [Sources](https://docs.controltheory.com/controltheory-documentation/dstl8-docs/sources).
- Data boundary: Telemetry Distillation runs where the data starts; raw log volume stays in the customer's environment, and only distilled signal and selected evidence lines are sent to Dstl8.
- Source code boundary: the [Code Graph](https://docs.controltheory.com/controltheory-documentation/dstl8-docs/code-graph) is built in the customer's CI and sends only a metadata artifact (file paths, symbol names, log format strings). It never sends function bodies, comments, secrets or config values, or git authors; Dstl8 never clones repositories or holds SCM tokens, and the artifact can be reviewed before upload with `dstl8 graph build --dry-run`.
- Model hosting by tier: Pro uses a bring-your-own model. Scale and Enterprise use Möbius, ControlTheory's own fine-tuned model, hosted by ControlTheory.
- Action boundary: Dstl8 never makes changes in production. It hands the cause, evidence, and a recommended fix to the customer's own coding agent, which applies it under the customer's permissions and review process; GitOps teams receive it as a pull request to the repo of record.
- Access: CLI and MCP authenticate with a bearer token from `dstl8 login`; CI uses `dstl8_` API tokens; each Kubernetes cluster is its own source with separate admission tokens.
- Coverage: Kubernetes, AWS, Google Cloud, and cloud-native PaaS today. OTLP ingest is infrastructure-neutral; on-premises deployments are scoped with the ControlTheory team.

## Comparisons

How Dstl8 compares with the AI SRE tools and observability platforms teams evaluate alongside it. Against AI SRE tools, Dstl8 distills its own data at the source (no observability stack required), needs no alert rules, runs in staging as well as production, hands the fix to the team's own coding agent, and is not metered per investigation. Against observability platforms, Dstl8 usually runs alongside, and each page states what Dstl8 leaves to the other product. Competitor details come from vendors' public materials as of October 2026. llms-full.txt carries the longer summary of each page.

- [All comparisons](https://www.controltheory.com/compare/) - Index of every Dstl8 comparison. Author: Bob Quillin, October 2026.
- [AI SRE tools compared](https://www.controltheory.com/compare/ai-sre-tools/) - Dstl8 vs Resolve AI, Traversal, Cleric, Datadog Bits Investigation, and Dash0 Agent0: what starts an investigation, where the data comes from, who acts on the fix, how the AI is priced. Defines "AI SRE."
- [Dstl8 vs Datadog](https://www.controltheory.com/compare/dstl8-vs-datadog/) - Datadog stays the system of record; Dstl8 adds rule-free detection beside the Datadog Agent, priced on agents and users rather than volume.
- [Dstl8 vs Sentry](https://www.controltheory.com/compare/dstl8-vs-sentry/) - Sentry for what throws; Dstl8, with no SDK, for failures that never raise an exception, such as restarting pods, silent deploy regressions, and LLM refusals returned as HTTP 200.
- [Dstl8 vs Honeycomb](https://www.controltheory.com/compare/dstl8-vs-honeycomb/) - Honeycomb for querying richly instrumented services; Dstl8 for services and platforms nobody instrumented. One OTel collector can feed both.
- [Dstl8 vs Dash0](https://www.controltheory.com/compare/dstl8-vs-dash0/) - Dash0 as the OTel-native backend with Agent0; Dstl8 distills before anything is filtered and delivers into the coding session. One collector exports to both.

## Use cases

- [Claude Code](https://www.controltheory.com/use-case/claude-code-runtime-reality/)
- [Cursor](https://www.controltheory.com/use-case/cursor-ai-run-with-confidence/)
- [Codex MCP logs](https://www.controltheory.com/use-case/codex-mcp-logs/)
- [GitHub Copilot debugging](https://www.controltheory.com/use-case/github-copilot-debugging/)
- [Ship AI code, skip the runtime rabbit holes](https://www.controltheory.com/use-case/ship-ai-code/)
- [Fix issues across the deployment chain](https://www.controltheory.com/use-case/fix-issues-across-your-deployment-chain/)
- [Keep developers in context](https://www.controltheory.com/use-case/keep-developers-in-context/)
- [Make AI-generated code better over time](https://www.controltheory.com/use-case/make-ai-generated-code-better-over-time/)
- [OpenTelemetry log analysis](https://www.controltheory.com/use-case/opentelemetry-log-analysis/) - Dstl8 for OTel pipelines: one exporter added, nothing replaced
- [OpenTelemetry Collector management](https://www.controltheory.com/use-case/otel-collector-management/) - fleet-level config (OpAMP) with fleet-level signal

## Platform integrations

Dstl8 and Gonzo integrate with:

- [Vercel](https://www.controltheory.com/use-case/vercel-runtime-errors/)
- [Supabase](https://www.controltheory.com/use-case/supabase-log-analysis/)
- [Railway](https://www.controltheory.com/use-case/railway-log-analysis-with-dstl8/)
- [AWS CloudWatch](https://www.controltheory.com/use-case/aws-serverless-cloudwatch-log-analysis/)
- [Kubernetes](https://www.controltheory.com/use-case/kubernetes-log-analysis/)
- [OpenTelemetry](https://www.controltheory.com/use-case/opentelemetry-log-analysis/)
- [GitHub Actions](https://www.controltheory.com/use-case/github-actions-reliability/)
- Netlify, Cloudflare Workers, Render, Fly.io, Grafana Loki, Victoria Logs, Docker

For per-platform Gonzo setup walkthroughs (exact pipe commands, jq normalizers, auth steps), see the [Gonzo integration examples](https://docs.controltheory.com/controltheory-documentation/gonzo-docs/integration-examples).

## Guides

Long-form guides on runtime feedback for AI-generated code and the telemetry pipelines that feed it.

- [How to Trust What Your Agents Ship](https://www.controltheory.com/guides/trust-what-your-agents-ship/) - For engineering leaders. Why AI-generated code passes pre-deploy gates and fails in production, and the distill, enrich, explain, remember architecture that closes the runtime feedback loop. 2026 survey data on the AI code trust wall.
- [The Agentic Engineer's Guide to Runtime Feedback](https://www.controltheory.com/guides/agentic-engineers-guide/) - For practitioners using Claude Code, Cursor, Codex, and Copilot. What runtime context an agent needs, how to wire it in through MCP, and the verified-ship workflow.
- [The Engineer's Guide to Invisible LLM Failures](https://www.controltheory.com/guides/invisible-llm-failures/) - LLM API failures that return HTTP 200 (content_filter, refusal, mid-stream 529) or fail with the wrong reason attached. Full signature table across OpenAI, Anthropic, and Azure OpenAI.
- [The Engineer's Guide to OpenTelemetry Signal Loss](https://www.controltheory.com/guides/opentelemetry-signal-loss/) - Where OpenTelemetry Collector pipelines lose signal (tail sampling, severity filters, transforms, cardinality limits, memory_limiter) and how Telemetry Distillation reduces volume without dropping records. Defines "OpenTelemetry signal loss" and indexes every ControlTheory OTel how-to. Author: Bob Quillin, September 2026.
- [The Datadog Bill, Decoded](https://www.controltheory.com/guides/datadog-bill/) - What Datadog bills for (custom-metric series, indexed log events, indexed spans), where its native levers stop, and how Telemetry Distillation removes indexed repetition beside the Datadog Agent without replacing Datadog. Defines "indexed repetition." Keep Datadog, send it less. Author: Bob Quillin, September 2026.

## OpenTelemetry Collector resources

Practitioner how-tos for the OpenTelemetry Collector: configuration, working examples, failure modes. The [OpenTelemetry Signal Loss guide](https://www.controltheory.com/guides/opentelemetry-signal-loss/) indexes all of them in reading order; llms-full.txt lists each one with a description.

- Collector fundamentals: [A Guide to the OpenTelemetry Collector](https://www.controltheory.com/resources/opentelemetry-collector-guide/), [Collector Deployment Patterns](https://www.controltheory.com/resources/opentelemetry-collector-deployment-patterns-a-guide/), Kubernetes log enrichment, the authenticator extension
- Reducing volume and cost: [Tail Sampling with the OTel Collector](https://www.controltheory.com/resources/tail-sampling-with-the-otel-collector/), the transform processor, metric cardinality with the filter processor, S3 tiering and rehydration
- Datadog and the collector: [Integrating the OTel Collector with the Datadog Agent](https://www.controltheory.com/resources/integrating-with-the-datadog-agent/), the Datadog receiver, service tags for OTel logs in Datadog
- Fleet management: [What Is OpAMP in OpenTelemetry](https://www.controltheory.com/resources/what-is-opamp-in-opentelemetry/)
- Testing the pipeline: telemetrygen, otelgen with Docker, the remote tap processor, [telemetrygen to dstl8 tap](https://www.controltheory.com/blog/telemetrygen-to-dstl8-tap/)
- [OpenTelemetry Resources index](https://www.controltheory.com/resources/) and [OTel Icons](https://www.controltheory.com/otel-icons/), an open-source icon set for OpenTelemetry architecture diagrams

## Incident Library

Reference library of real production error patterns Dstl8 surfaces in customer logs: what each error looks like, root cause, fixes, and how to detect it automatically. Browse all: [Incident Library](https://www.controltheory.com/incidents/). llms-full.txt lists every entry with its description.

- [The LLM API Errors Your Monitoring Can't See](https://www.controltheory.com/incidents/invisible-llm-errors/) - curated guide to LLM API failures that return HTTP 200 or hide the real cause: silent content filters, body-level refusals, mid-stream 529s, and false-positive moderation blocks across OpenAI, Anthropic, and Azure
- Kubernetes (9 entries): ClickHouse TTL, Flux Helm index fetch, MySQL InnoDB Cluster ejection, calico RBAC, kube-apiserver backend dialing, cluster-wide leader election loss, ingress-nginx 504s, snapshot-controller lease thrashing, MetalLB gratuitous ARP
- LLM API errors (7 entries): OpenAI content_filter and invalid_prompt, Anthropic refusal and mid-stream 529, OpenAI image content policy, Azure per-deployment content filters, LiteLLM context window
- Infrastructure, database, storage (10 entries): Lambda timeouts, nginx connection refused during rollouts, cross-service TypeError cascades, OTLP exporter backpressure, OTel Collector pipeline failures, cardinality explosion, pg_stat_statements, S3 NoSuchKey, Datadog Agent Redis auth, upstream rate limits surfacing in Vercel
- Security probes (3 entries): ThinkPHP RCE, PHP pearcmd RCE, directory traversal

## Background

- [You Can Vibe Code. You Can't Vibe Debug.](https://www.controltheory.com/blog/you-can-vibe-code-you-cant-vibe-debug/) - Why AI-generated code needs continuous runtime intelligence
- [Author: Bob Quillin](https://www.controltheory.com/blog/author/bob-quillin/) - founder and CEO; guides, blog posts, and the Observability Next newsletter

## Optional

- [llms-full.txt](https://www.controltheory.com/llms-full.txt) - the complete version of this file in one request
- [Sitemap](https://www.controltheory.com/sitemap_index.xml)