Every tool your team needs,
inside your app.
Buoy ships 15+ tools inside your React Native or Flutter app — and lets your developers add their own. Devs stop rebuilding to add a log. QA triggers error states in one tap. Support impersonates the customer who's stuck.
$ npm i @buoy-gg/core
import { FloatingDevTools } from '@buoy-gg/core'
<FloatingDevTools /> // the whole team, on devicefree forever on device · $9/mo for desktop & MCP · no account to start
one session · phone, desktop & agent · nothing leaves your machine
shipping in production apps at
+ moreNot just the people who built the app.
One install puts the same menu in front of your whole product team. Pick a seat and see what changes.
today
A bug only happens in production. You add a console.log, ship a build, wait, and guess again.
with buoy
- Read every request, header and body while the app runs
- See which prop caused a re-render, and how often
- Benchmark two implementations on a real device and diff them
- Hand the whole live session to Claude or Cursor to drive
The best tool for your team is one you write yourself.
Register any React component in the same on-device menu. A refund button for support, an order-state switcher for QA, a flag panel for product — shipped with the app, gated however you like.
- for supportRefund the last order
- for QAForce order state
- for productFlip a feature flag
- for dataSeed a test basket
<FloatingDevTools
customTools={[
{
name: 'Refund',
component: RefundPanel,
icon: '💸',
},
]}
/>
// now support has a Refund button
// in the same menu, on their phoneNo magic. One local broker.
The tools run inside your app's process. A small broker on your machine mirrors them to the desktop app and hands them to any MCP client as real tool calls — never through our servers.
A floating menu inside the app
One component, and every installed tool appears in a dial on the device. No cable, no desktop app, no proxy, no certificate — which is why QA and support can use it without help.
free foreverEvery tool, full screen
Buoy Desktop mirrors the same session to macOS, Windows and Linux, with a live perf HUD. Devices connect on their own — physical phones included.
Pro · free downloadClaude and Cursor, wired in
The MCP server hands your agent real tool calls against the live app. It reads the state, taps the UI, and reproduces the bug itself.
Pro · npx @buoy-gg/mcp init16+ tools. Install only what you need.
Every one is its own package, and every one streams to all three surfaces. These are real captures from a real app.
Network
@buoy-gg/networkEvery request the app makes — headers, bodies, timings — without a proxy, a certificate, or a rebuild.
- fetch, Axios, GraphQL and gRPC-web captured automatically
- Full request & response bodies with syntax highlighting
- Filter by status, sort by duration, search by GraphQL operation
- Copy any request as cURL in one tap
Your agent doesn't read screenshots. It drives the app.
Buoy's MCP server gives Claude Code, Cursor, or any MCP editor real tool calls against the running app — structured state in, actions out. No pixel-guessing, no copy-pasting logs into a chat window.
- Read live network, state, query cache, storage and console
- Tap elements, navigate screens and mutate state to reproduce a bug
- Run on-device benchmarks and get back a ranked report
- Runs against your local broker — no code or data leaves the machine
npx @buoy-gg/mcp init{ "error": "TAX_RATE_NULL",
"region": "CA-QC" }● Quebec tax rates are missing from the config — here's the fix.
Ships in production.
On purpose.
The bugs that matter are the ones you can't reproduce locally — and the people who hit them first are usually support, not engineering. Buoy runs where they are, and one condition in your own code decides who sees it.
- Show it to internal users, admins or beta testers — your flag, your rule
- Nothing leaves the device — there is no remote connection to make
- Modular packages tree-shake out of anything you don't install
import { FloatingDevTools } from '@buoy-gg/core'
<>
{/* your app */}
{user.isStaff && <FloatingDevTools />}
</>44 things Buoy does that you'd otherwise build yourself.
Not a roadmap — this is what's in the packages today, across all three surfaces.
- fetch, XHR & Axios
- GraphQL queries & mutations
- gRPC-web
- Request & response bodies
- Request & response headers
- Status, duration & payload size
- Console logs, warns & errors
- Image loads & cache verdicts
- Navigation events
- Render commits & counts
- Storage reads & writes
- Redux, Zustand & Jotai changes
- Body syntax highlighting
- JSON tree view
- Full-text search
- Filter by status code
- Sort by duration
- Search by GraphQL operation name
- Ignored domains & URL patterns
- Before / after state diffs
- Event history per storage key
- Re-render cause: props, state or parent
- Env type & value validation
- Live navigation stack
- Impersonate any user
- Edit any storage value
- Delete or bulk-clear keys
- Force loading, empty & error states
- Refetch & invalidate queries
- Dispatch Redux actions
- Set Zustand & Jotai state
- Navigate to any route
- Tap any element by testID
- Pin a design mockup over the app
- Register your own custom tools
- Remote control from the desktop
- Live JS FPS, CPU & memory HUD
- Record & compare benchmark runs
- Ranked batch reports
- Per-component render durations
- Copy any request as cURL
- Copy storage or state as JSON
- LLM-ready session export
- One timeline across every tool
Built for where the others couldn't go.
You know Flipper, Reactotron and RN Debugger. Here's why teams move.
| feature | buoy | flipperarchived | reactotron | rn debugger |
|---|---|---|---|---|
| Still maintained in 2026 | ||||
| On-device — no desktop app required | ||||
| Usable by QA & support, not just devs | ||||
| Add your own custom tools | ||||
| Works in production builds | ||||
| AI agent control (MCP) | ||||
| Live perf HUD (FPS / CPU / memory) | ||||
| Zero-config setup | ||||
| Network inspector | ||||
| Query cache (TanStack) |
Full write-ups: Buoy vs Flipper · Buoy vs Reactotron · the best RN debugging tools in 2026
Plays nice with your stack: Sentry and PostHog tell you what broke. Buoy lets anyone on the team reproduce it on a live device — the exact request, state and route.
Free on the device. $9 for the rest.
The in-app tools are free for your whole team — devs, QA and support alike. Individuals pay $9/mo for the desktop dashboard and agent control; companies license per seat.
Every tool, inside your app, for everyone who installs the build.
- All 15+ in-app tools
- Your own custom tools
- Unlimited devices & people
- No account required
Adds the desktop dashboard, agent control, and production builds.
- Everything in Free
- Buoy Desktop — every tool, full screen
- MCP server for Claude & Cursor
- Remote control & unlimited history
The same tools on a company license — priority everything included.
- Everything in Solo
- Expense it — invoice-friendly billing
- Priority fixes & custom tools built for you
- Volume pricing & site licenses
volume pricing from 10 seats · cancel anytime · no credit card to start
Questions, answered.
Do QA and support need to know how to code?
No. Everything is taps inside the app — force a loading state, edit a value, impersonate a user, jump to a screen. The only person who touches code is the developer who installs it once.
Can support really impersonate a customer?
Yes. The Impersonate tool injects impersonation headers into every network request, so the app behaves as that user without anyone logging out or sharing a password. You wire it to your own user-search API, so your rules and your auth decide who can do it.
Can we build our own tools?
Yes, and this is where most teams get the biggest win. Register any React component in the customTools array and it appears in the same on-device menu — a refund button, an order-state switcher, a flag panel.
Does it really run in production?
Yes. Buoy runs entirely on-device and never phones home. Gate it behind your own flag so only staff see it — or strip it from release builds entirely.
Do I need a proxy or a certificate?
No. The network tool runs inside your app’s process, so there is no proxy to configure, no root certificate to trust, and nothing to set up on the device. That is what makes it usable by non-engineers.
Does the free tier expire?
Never. The in-app tools are free forever for as many people as you like. You only pay for the desktop dashboard, agent control and production debugging — $9/mo for individuals, per-seat for companies.
What about our users' data?
Nothing leaves the device by default. The desktop app and MCP server connect over a local broker on your own machine — never through our servers.
Does it work with Flutter?
The Flutter suite is in beta and streams to the same desktop dashboard and MCP server as React Native.
One install. The whole
team stops guessing.
A developer adds one component. From then on everyone who ships your app — engineering, QA, support — can see it and change it while it runs.
$ npm i @buoy-gg/core
import { FloatingDevTools } from '@buoy-gg/core'
<FloatingDevTools /> // the whole team, on devicefree forever on device · Pro 14-day trial · cancel anytime
or download Buoy Desktop for macOS, Windows & Linux