New Relic observes systems. Multiplayer fixes bugs. Unsampled, full-stack runtime data for your coding agent without the Ops-focused overhead and vendor lock-in.

Yes, we collect unsampled traces. No, they're not repackaged from your existing APM. Yes, that includes request/response content and headers. No, we don't fill gaps with guesses. There are no gaps.

Sampled, incomplete data means plausible-looking PRs that fail in production. Multiplayer feeds your coding agent full-stack, unsampled runtime data so fixes actually work.

Multiplayer is now open source. The debugging agent that connects your coding agent to production to fix application bugs automatically is publicly available under MIT. 👇 github.com/multiplayer-...

Why Multiplayer's architecture is unique: → Session-based data collection → Local-first architecture that only sends data for new issues → Un-sampled, full-stack data → Automatic data correlation → Intelligent issue grouping, triage and deduplication → Release context and metadata included

The Jellyfish data makes the point cleanly: you can't fix a data problem with more compute. If more tokens and better models produce the same PR quality as before, the bottleneck was not the compute.

How do you capture unknown-unknowns without blanket coverage, all the time? Answer: with session-based collection with broad triggers (any error, any anomaly). You're not deciding in advance what to instrument; you're automatically storing only failure events.

With Multiplayer there’s no proprietary agent lock-in, no bloated telemetry bills, just the runtime data your coding agent needs.

Wouldn’t it be nice to never have to worry about this again? This is the exact type of problem we built the debugging agent to solve. 👀

Yes, there's a lot going on under the hood. No, you don't have to care about any of it. One copy/paste in your terminal and Multiplayer handles the rest: data gathering, triage, deduplication, coding agent prompting, PR creation. You just review and merge.

AI agents generate code that breaks in prod. Use Multiplayer with your favorite coding agent to fix application bugs automatically with full-stack, unsampled runtime data.

Session-based runtime data collection for coding agents. One copy/paste in your terminal, and you're done: npm install -g @multiplayer-app/cli && multiplayer

Watching the debugging agent fix my bugs

Multiplayer produces fewer, better PRs: local-first, full-stack, deduplicated, un-sampled, … better data for any coding agent (or developer).

We capture the actual runtime context you (and your coding agent) need: • User clicks • Session metadata • Network requests • Console messages • Error rate metrics and errors (not sampled!) • Stack traces, spans, and logs (not sampled!) • Req/res headers and content from deep in your system

Targeted capture beats constant collection. Change my mind.

Watching the debugging agent fix bugs in real-time. One copy/paste in your terminal, and you can too: npm install -g @multiplayer-app/cli && multiplayer

One line. That’s it. All you need to start saving hours of debugging time.

Install the Multiplayer debugging agent in your console. Run it locally. No source code access required.

Multiplayer: the debugging agent for developers. We connect your favorite coding agent to prod to fix application bugs automatically. Run us locally and eliminate PR slop.

To go from bug identified to bug fixed, agents need runtime data that observability tools weren't designed to provide. This talk explores that 👀 👇

I'm attending the Cloud Native Computing Foundation (CNCF) Observability Summit today in 📍Minneapolis, Minnesota. If anyone is interesting in discussing agentic coding, debugging, or just have a coffee, find me and @bkstephj1.bsky.social ☕️

Proud to see our Director of Community and DevRel and on stage at @cloudnativedaysitaly.org 💜 The cognitive cost of too much choice is part of why we built our debugging agent to run locally, right next to your coding agent: less context switching, less decision fatigue, more fixing.

The debugging agent is a useful case study. The first generation of coding agents tried to fit into existing manual debugging workflows, using the existing observability data. The result was fixes generated from sampled, aggregated, and missing data that looked plausible and failed in prod.

Partial data frustrates human debuggers. It breaks AI ones. AI agents need full runtime context (unsampled, correlated, complete) to understand what actually went wrong. Especially in distributed systems, where the failure rarely lives where the symptom shows up.

How much of your on-call time is spent figuring out what happened vs. actually fixing it?

Decision fatigue is real in cloud-native development and most of it hits before you write a single line of code. The part nobody mentions: every bug that shows up resets the whole process. Even wondering 'Where do I even start?' is its own tax on top of everything else.

It's the same problem with low-quality inputs to coding agents. An agent acting on incomplete or noisy data produces worse outputs and erodes confidence in every bug the agent flags. You can't fix that with a better model. You fix it with better data.

If your coding agent introduced a bug today, how long before you'd know?

Our CTO is heading to Minneapolis to say the quiet part loud. 🎤

Your AI coding agent and your observability tools were designed with completely different objectives. That's your debugging gap.

The next production incident is already in your system. The question is whether you'll have the full context when it surfaces.

📅 Today, Wed, 18 MAR 2026 🕘 10:00 AM PDT | 1:00 PM EDT | 6:00 PM CET A panel on agentic observability with @tomjohnson3.bsky.social, @rustyrazorblade.com orblade.com, @michele.dash0.com, and @renice.bsky.social Hosted by @dash0.com and @leaddev.com Save your spot: leaddev.com/event/a-blue...

Our CTO #Thomas Johnson will be joining @rustyrazorblade.com, @michele.dash0.com, and @renice.bsky.social for a panel on agentic observability, hosted by @dash0.com and @leaddev.com 📅 Tomorrow, WED, 18 MAR 2026 🕘 9:00 AM PST | 12:00 PM EST | 6:00 PM CET

AI wrote the bug. AI needs to fix the bug. But first it needs to see the whole system and understand the bug.

Same vibe: teams spending hours tuning sampling rates, retention policies, and log filters, instead spending a few minutes setting up full stack session recordings. 👀

The hardest bugs to fix aren't the most complex. They're the bugs invisible to every tool you're *currently* using. 👀

Modern session recording tools have evolved beyond user analytics to become essential debugging and development platforms that capture complete request/response payloads, distributed traces, and frontend-backend correlations.

Observability was built on a flawed assumption: collect everything, sample aggressively, hope you caught the right 1%. But this approach breaks completely when an AI agent is the one doing the debugging.

You can't debug what you can't see. Sounds obvious, but here's what's actually happening: developers are asking AI tools to fix production bugs based on sampled logs, redacted payloads, and traces that stop at the system boundary.

The real question isn't "can you capture external API data?" It's "do you capture it reliably, or does it require manual discipline (that often breaks down)?" With custom logging, you CAN technically capture everything. BUT...

By the time you find out about an intermittent bug, the context is gone (sampled away or never captured)… or is it? 😇 Maybe you just don’t have the right tool to automatically record the full-stack, session-based context when the bug occurs.

Quick question: How do you debug code you shipped three hours ago that was generated by AI, barely reviewed, and has no proper instrumentation?

⚠️ Sampling is a cost-management strategy not a faster path to debugging. Collecting more data won't fix your debugging problem if you're collecting the wrong data.

With Multiplayer, you get: ✅ 100% traces (no missing data or outrageous bills) ✅ Full request/response payloads and headers ✅ Internal AND external API calls ✅ User steps and frontend data (annotatable) ✅ Full-stack data correlated by session (no manual stitching)

"When debugging, novices insert corrective code; experts remove defective code." - Richard Pattis 👆 This is now more true than ever with AI vibe coded slop

Complexity is a choice.

Instead of: Here are logs from 6 tools, figure it out. You get: Here's everything that happened in this user's session, already correlated. Here's how. 🧵

What is spec-driven development? The approach: Write comprehensive specs → detailed technical plans → task breakdowns → then let AI generate code. Sound familiar? We used to call this Big Design Up Front (BDUF). We spent decades running away from it. 🧵

Auto-correlation tools solve the data problem at the collection layer, not the analysis layer. 👀 Let’s explain that: 🧵