Launch HN: HyperProbe (YC S26) – Agents that do read-only debugging in prod

34 pointsposted 6 hours ago
by shailendraht
(hyperprobe.co)

24 Comments

jaggederest

2 hours ago

Interesting technology but your landing page screams "I put no work into this design", probably want to rebrand away from generic claude design orange-on-brown.

A useful adjunct to this kind of production in-memory debugging is a read-only agent locked down role in AWS or equivalent. I believe amazon has just set up some kind of a wizard for configuring a role like this. It really gives agents the ability to relatively safely look at the prod setup without exposing sensitive details or making changes, especially with e.g. terraform

karanraina

2 hours ago

I agree, having an agent safely inspect infrastructure config and Terraform state via a read-only IAM role pairs really well with what we're doing. AWS roles handle the "how is the cloud environment configured?" question, while we handle the "what is happening inside the running process heap/memory?" question.

Also thanks for the candid feedback! (And fair call on the design — we definitely prioritized shipping core functionality over UI polish, but point taken on the orange/brown palette, we'll change it)

tptacek

an hour ago

Counterpoint: nobody is going to care what the front page looks like designwise, as long as the words are right.

jaggederest

an hour ago

Normally I would completely agree with you, but default claude design makes people close tabs before they read a word. A `text/plain` markdown file would be better.

sgarland

4 hours ago

> You "fixed" the incident. You have no idea how.

If you don’t know how it broke, and you don’t know how you fixed it, what exactly is it you think you understand about your application?

karanraina

3 hours ago

> If you don’t know how it broke, and you don’t know how you fixed it, what exactly is it you think you understand about your application?

what we wanted to convey is that sometimes people confuse "the symptom went away" with "the root cause was fixed"

I have seen that a rollback, a quick redeploy, or a temporary drop in tenant load makes the alerts go away and issue is considered resolved. specially true for larger teams with many engineers and services

a real example: a dev got OOMed after a release that coincided with a flash sale. he increased memory limits, and containers stopped crashing and it was "fixed". Actualy, a newly introduced internal module had a memory leak. adding RAM just hid the leak until the next traffic spike.

hyperprobe exists to capture actual in-memory runtime state during live traffic so you can prove the root cause before changing code or scaling infra in this case

tcdent

4 hours ago

Agents wrote the code, agents tested the code, agents reviewed the diff, a human reviewed the diff, agents verified it made it to production correctly.

But when the pipeline fails (bugs happen that's fine) re-running the exact same process may not be the solution.

Where does the additional intelligence that wasn't there before come from? We ran the pipeline that got it to prod on the same exact models you have access to. So the value prop is that you read the logs automatically instead of a developer directing a debug session?

karanraina

4 hours ago

the value prop is not reading logs automatically

your coding agent will have access to your code and can see what logs you have enabled, if indeed that would help in debugging, going that route helps. it can take your agents a bunch of retries but it might get there if the answer is in logs

what we provide your coding agent is a detailed snapshot of all your variables at any line it feels would help debugging. and not just in the current call frame.. even the variables of the callers of your current function, like a debugger.

suupose funcA() -> funcB() -> funcC() -> yourCurrentFn()

we'll provide all the variables that were set in all 4 functions to your agent. debugging using this would be a lot more accurate and you just one snapshot like this instead of looking at a thousand log lines to understand why something is not working the way you want to.

this kind of data is missing from your logs and and even your traces because it will be impractical for privacy and performance.

vitorbaptistaa

4 hours ago

Congratulations on the launch! Looks very neat.

For people that don't have these neat observability tools (like me), I've been using https://shellshare.net (disclaimer: I made it).

This is a single command to share a terminal live with e2e encryption. Originally it was for teaching classes or helping colleagues, but it's also very helpful for agents. I SSH into prod and run:

> npx shellshare exec --json -- tail /var/log/my-app.log

This generates a URL, then I can tell any agent:

> monitor <URL>, instructions in https://shellshare.net/llms.txt

They can see the output live. No need to install anything in the agent's machine. Next shellshare version it will be just "monitor <URL>" and the agent's instructions will be in the URL itself.

Nothing even near what you've guys done, but it has been helpful for me. Best of luck in your startup!

dshubham

4 hours ago

Congrats on the launch. You mention probes are read-only by design, which makes sense for debugging. Curious about the flip side: when an agent does make a write that turns out wrong, have you thought about extending the same approach toward capturing state before the write, so it's actually reversible? Seems like similar instrumentation (in-process, no redeploy) could apply, but the reversibility side seems mostly unsolved right now.

karanraina

4 hours ago

Thanks!

It could work, the technology isnt the limitation.

But we were clear from day one that we cant let our sdks change the memory. Even if it helped solve a real problem.. say for example resetting a bad env variable or a feature flag without redeployment.

I might be biased from my experience, but i would prefer having a bug in my system for longer that i can reliably reason with than having it solved dynamically within the app which adds another thing to keep in my mind.

for me, bug -> fails -> good bug + dynamic patch -> works -> bad

also we dont think that we ourselves wont have any downtime ever, so we design for it. we'd not want to become as critical for your app as say your database.

As of now, your app works even if our servers are down/blocked/slow, adding the ability to change memory on the fly could change this

MdJasimuddin

5 hours ago

Congrats on the launch! The ability to drop read-only probes into a live service without triggering a painful redeploy is a massive time-saver. Since my workflow relies heavily on cloud-based development, I am curious—how does your SDK handle serverless environments where the container lifecycle is extremely short? Really great concept!

karanraina

4 hours ago

Thanks!

You're correct, serverless is a bit tricky. CPU gets suspended the moment your function returns. The way it works is that you wrap your functions with a wrapper in our sdk.

that wrapper is supposed to track if there's telemetry to be sent, if so.. it sends it, otherwise, return as usual

this makes sure that when there's no active probe, there's no latency added. But when there's an active probe.. ~100-200ms could be added in the worst case if the probe is just before the return.

again, this isnt a problem in non serverless worloads because the CPU is always on.

but since probes are bounded by time and count, this will go away as soon as the time or count condition meets. beats adding new logs and redeploying in my opinion

bluelightning2k

4 hours ago

You wrap it but there must be some kind of call you're making to your API. So are you saying that call fires immediately, races the main wrapped execution, and is therefore done when the execution is finished, therefore neglible latency except for cold starts on extremely short functions?

How does the probe function technically. Inspector API I believe is unavailable on CloudFlare etc.

I once wrote something like this which could work on serverless platforms without the Inspector API. It used Typescript AST transforms to insert no-op listeners at every line, so they would dynamically eval or dump breakpoint style if a listenToLine parameter equalled their line, otherwise no-op. So trivial but not technically zero runtime cost.

karanraina

4 hours ago

yup, it races the main wrapped function.

makes no difference if its cold or warm start. (The latency because of us, not latency in general)

Using AST, that's clever actually! I thought along somewhat similar lines. User tree-sitter. But it needs a build step! not sure how people feel about that :D It changes your source code itself so we'd need a 2 tiered source resolution. Dirty, but doable.

And instead of having this at every line, i did this at "lines of interest" before and after every scope ends.

so at the start/end of an if condition, start/end of fn definiton. it sort of worked, but it slowed down our synthetic benchmarks for "no effect when probes arent there" by more than what i wanted to tolerate and it depended of eval which i thought devs wont accept. and using node-vm slowed it further

But will give another try again. thanks for sharing this!

bluelightning2k

4 hours ago

If I was building this for serverless I would transform with two copies of the code: instrumented and not. Then do one single if statement between them.

If you are transforming anyway you're looking at virtually zero dev time cost and runtime cost when no probe is active of less than 1 ms.

This approach survives any environment I know of and has almost zero runtime cost.

bluelightning2k

5 hours ago

This debugging in production thing has always been interesting to me. Rookout, etc.

How does it work? Using the NodeJs inspector API or other language equivalent to drop breakpoints? Those APIs are unavailable in many serverless environments and are challenging to use alongside bundlers.

karanraina

4 hours ago

YES!!! for nodejs, inpector API is used. But if you're adding dynamic logs or metrics, we dont even call the inspector completely. we return an expression that will always evaluate to false and safely evaluate our the log/metric. saves time and computations happen in the same cpu cycle

You're correct inpector API is not available in many non-v8 targets. Bun also has somewhat of a partial support for inpector API but at least has a programmable debugger interface. It's not going to be as fast as native inspector but its better than nothing i guess :P

for python sys.monitoring. for JVM, we do bytecode manipulation itself.

bundlers are not an issue because we support sourcemaps. We just need mappings, not code in the sourcemaps and we do sourcemap resolutions out of process so that your app doesnt spend ~200 MB of memory for parsing sourcemaps

bluelightning2k

4 hours ago

I like your product and team. j think you have something here.

anigbrowl

2 hours ago

There are two pieces. An SDK that runs inside your service, and an MCP server your coding agent talks to. The SDK is what makes setting probes (virtual breakpoints, log or metric) possible without a redeploy. In Node and Python it hooks in-process. In Java it attaches as a JVM agent, instrumenting at the bytecode level. Either way the service keeps running and serving traffic. Nothing pauses.

Consider putting this near the beginning rather than 2/3 of the way down your pitch. I nearly stopped reading because these dramatic 1-2 sentence paragraphs are unpleasantly like listening to TV commercials. I think your target audience should not be CTOs or their direct reports, but engineers themselves, and I think you need a more focused pitch that takes less time to get to the point.

Anyway, an MCP-managed passive debugger seems like a useful tool. Best of luck with it.

karanraina

an hour ago

Appreciate the feedback, will try to highlight the how instead of why specially to devs

Although, our primary sell is debugging, the context from production on how things work currently helps ai agents during feature development and code reviews as well.

Natalia724

5 hours ago

The in-process redaction design is the part I would want to evaluate first. Is there a way to audit which values were captured and which redaction rule matched for each probe hit?