# Bluebox: An agent that watches OTel data and files GitHub issues with evidence

> Source: <https://blog.bluebox.ai/get-started-with-bluebox-in-a-single-coffee-break/>
> Published: 2026-09-08 19:40:09+00:00

[Use Case](/beyond-it-works-on-my-machine/)

## Beyond "It Works on My Machine"

Coding agents are genuinely good at understanding a local codebase. Point one at a repository and it can read the architecture, trace the data flow, interpret configuration, and

If you've ever shipped a feature and held your breath waiting to see what broke in production or spent hours re-prompting your coding agent just to get a feature right, Bluebox is for you.

Bluebox connects to your production telemetry and your GitHub repository, watches your runtime services continuously, and when something goes wrong, it investigates automatically: tracing the problem to its root cause and handing your coding agent an evidence-backed fix plan. No manual log searches. No translating alerts into prompts.

Grab a cup of coffee and the repo of one of your apps and let’s get you up and running on Bluebox. You’ll be done before you’ve finished your first cup.

Alright, enough with the coffee talk, let’s get back to tech.

If you're new to observability, [OpenTelemetry](https://opentelemetry.io/?ref=blog.bluebox.ai) is the open standard for capturing data from your running services, distributed traces, logs, and metrics. Bluebox leverages this observability telemetry to detect problems automatically and trace them back to their root cause in your code. If you've never set it up before, don't worry, we’ll cover it in Step 3 and it’s super easy. 

Sign up at [__bluebox.ai__](https://bluebox.ai/?ref=blog.bluebox.ai) with your GitHub account to get started. 

After signing up, Bluebox opens a Setup page in your browser to guide you through the connections and validate your progress.

Select the repository you want Bluebox to monitor and click **Confirm**. This installs the Bluebox GitHub App, which gives Bluebox the ability to read your code and apply its code intelligence to investigate findings and gain code-level context. 

A few things worth knowing:

The easiest way to get set up is to let your coding agent do it. Paste this into your coding agent and it handles the full CLI installation end-to-end, prompting you for steps that need a browser for authentication:

```
Install Bluebox CLI from https://app.bluebox.ai without piping a remote script into a shell. Download the installer for your platform — https://app.bluebox.ai/install.sh for macOS/Linux, https://app.bluebox.ai/install.ps1 for Windows PowerShell, or https://app.bluebox.ai/install.cmd for Windows Command Prompt — to a local file, show me what it will do, then run it to start Bluebox setup.
```

Prefer to do it yourself? Run the interactive installer in your terminal:

**macOS / Linux:** 

```
curl -fsSL https://app.bluebox.ai/install.sh | bash
```

**Windows (PowerShell):** 

```
irm https://app.bluebox.ai/install.ps1 | iex
```

Either way, the installer runs *bluebox* *setup* automatically, which authenticates with GitHub and installs Bluebox's workflow skills into any coding agents it detects. The installer currently works for Claude Code, Cursor, GitHub Copilot, Kiro, OpenCode, but you can take the skills and give them to any coding agent/AI-powered IDE. Once the skills are installed, your coding agent knows how to use Bluebox to query production, instrument your services, and investigate findings. 

One of the core capabilities of Bluebox is to give your coding agents eyes into production. Bluebox needs OpenTelemetry from services to do this and investigate runtime behavior. With the Bluebox skills now installed in your coding agent, this is a single prompt.

Ensure you’re working the most up to date version of your repo in your coding agent (or clone it), and paste:

```
Add OpenTelemetry to this project — use the Bluebox instrumentation skill
```

The agent follows the Bluebox instrumentation skill, which guides the agent through the right OpenTelemetry setup for your language and framework. If you already have OpenTelemetry instrumentation in your app pointing somewhere else, the agent can repoint it to Bluebox instead.

Once done, your coding agent creates a pull request in for you to merge and deploy. Grab your ingest token from the Setup page and provide it to your service as an environment variable or through a secret manager. The token stays in the browser, it never appears in CLI output or gets written to a file, so it can't be accidentally committed.

**Verify telemetry is flowing:** The Setup page confirms when data has arrived. Redeploy or restart your service, then check back. Once Bluebox sees telemetry, it starts monitoring automatically. 

With telemetry flowing and your repo connected, we’re ready to run our first investigation. First make sure there’s some traffic (real or generated) hitting your app so Bluebox has telemetry to monitor.

Bluebox continuously analyzes incoming data and detects when anomalies occur, error rate increases, latency spikes, and repeated failures. When it finds something, it surfaces a **Finding** on the **Overview** page. Since we’ve just spun up Bluebox, it may take some time to baseline performance and detect anomalies. We can also manually kick off an investigation to dig into any current issues.

Click **+ New Investigation** and describe what you want Bluebox to look into. Paste in an error message, reference a service that's been behaving unexpectedly, or just ask what's wrong. The clearer the description, the sharper the investigation. 

Bluebox runs a full root cause analysis: gathering evidence from your traces, metrics, and logs, and tracing the problem back to the specific code path causing it.

When the investigation completes, Bluebox produces a structured report with root cause, evidence, impact, recommended fix, and automatically opens a GitHub issue with everything your coding agent needs to write the fix. From there you can hand it to your coding agent, review the PR, and merge when you're ready. 

You don't need a full investigation to get value. You can just chat with Bluebox to ask questions about how your app is behaving right now. 

A few good starting prompts for Bluebox to sip on: 

Think of it as having a conversation with someone who's been watching your production environment the whole time.

Both investigations and chat work directly inside your coding agent too. With the Bluebox skills installed, you can ask production questions, trigger investigations, and pass those insights straight to your agent without leaving your coding environment. Whether you're fixing a live issue or building something new, Bluebox's production context is right there where you're working.

If you followed along, your coffee's still warm and Bluebox is already watching your app. It’s that quick and easy.

Every new finding gets surfaced automatically. Every investigation produces an evidence trail your coding agent can use. And the loop from incident to validated fix closes without you in the middle translating alerts into prompts.

Bluebox, Kiro, and AWS DevOps Agent bring production intelligence directly into AI-driven software delivery. By connecting development and operations with shared runtime context, teams can build, deploy,

When AI makes implementation faster, context, decision-making, and trust become the real constraints. Here is what we are learning while building Bluebox. This post is part of