Glassbrain

What is Glassbrain?

Glassbrain is a visual debugging tool for AI-powered applications. It captures each step of an AI run—from user input through parsing, retrieval, and LLM calls to the final output—and renders that sequence as an interactive, clickable trace tree.

When the output is wrong or something fails in production, Glassbrain helps you understand why by letting you inspect the data behind any step, adjust inputs, and replay from that point without redeploying. It also provides fix suggestions that focus on what to change rather than just reporting the error.

Key Features

• Visual Trace Tree of the reasoning chain: View the full workflow as nodes (e.g., input, parser, retriever, document store, LLM call, formatter, final output) to pinpoint where things went off track.
• Interactive node inspection: Hover or select parts of the trace to inspect intermediate data instead of reading long raw logs.
• Time-Travel Replay: Click any node, swap the input, and replay the run from that point to verify potential fixes without redeploying.
• Side-by-side Diff View: Compare “before” and “after” results so improvements and changes are visible.
• AI Fix Suggestions: Generate concrete proposals for what to adjust (for example, changing temperature or enabling strict JSON mode), based on what failed.
• Shareable debugging sessions: Create a URL for a debugging session so teammates can review the same trace and context.
• One-line setup for tracing: Install and add a single import (npm install glassbrain) to start capturing traces.

How to Use Glassbrain

1. Install the package with npm install glassbrain and add one import to your app so Glassbrain can capture traces.
2. Reproduce the issue in your AI application (e.g., a wrong answer or a failed run).
3. Open the session in Glassbrain to view the trace tree and identify the broken step.
4. Inspect and replay: click the relevant node, change the input, and replay from that point to test fixes quickly.
5. Review results using the before/after diff view and then share the debugging link with your team.

Use Cases

• Support chatbot accuracy review: When users report an incorrect response (e.g., a return-policy window mismatch), use the trace tree to find where the model’s reasoning or retrieval led to the wrong output.
• Production failure diagnosis: For errors like rate limiting during an OpenAI API call, inspect the trace to determine the root cause and see the impact of retry behavior.
• Prompt or generation parameter iteration: If the output format is inconsistent, apply suggested changes (such as enabling strict JSON mode or lowering temperature) and validate the effect with replay and diff view.
• LLM workflow debugging across retrieval steps: When issues stem from earlier stages (parsing, retrieval, or document store interactions), diagnose at the correct node rather than treating the final output as the only signal.
• Team-based incident response: Share a link to the debugging session so teammates can inspect the same trace and collaborate on the replay/fix decisions.

FAQ

What is Glassbrain capturing?

Glassbrain captures steps of an AI run, from user input through parsing, retrieval, document storage, LLM calls, formatting, and the final output, and presents them in an interactive trace tree.

What does time-travel replay mean?

Time-travel replay means you can click a node in the trace, change the input for that step, and replay from that point without redeploying.

Which model and framework stacks does Glassbrain support?

The site states support for OpenAI, Anthropic, and LangChain, along with LlamaIndex, plus an OpenTelemetry-compatible endpoint for custom stacks.

Can I share a debugging session with my team?

Yes. Glassbrain generates a shareable link (a URL for the debugging session) so others can view the trace and context.

Is Glassbrain free to try?

Yes. The page lists Free plans with $0/month and no credit card required.

Alternatives

• Observability/telemetry tools using logs and traces (e.g., OpenTelemetry-based workflows): Useful for capturing system activity, but typically require manual log analysis and may not provide the same node-level replay and interactive trace tree workflow.
• LLM application monitoring platforms (trace and evaluation oriented): Similar in collecting trace data for AI workflows; differences usually come down to whether they offer time-travel replay, before/after diffing, and session sharing as part of the core UX.
• Traditional error debugging with SDK-level instrumentation: Can help identify failures in API calls, but often lacks a unified visual trace of the full AI pipeline from input to final output.
• Prompt-focused debugging and evaluation tools: Useful when the main issue is prompt behavior, but may not cover end-to-end workflow steps like retrieval and document store interactions in the same way.