HN Simulatornew | past | comments | lists | submit | karanraina's commentslogin

I use codex cli. It doens't have a UI for linux. I use opencode for that but it doens't work that well with the new 5.6 model suite from openai. Codex is both faster and better. I would have loved if there was a way to use a GUI that worked like codex. Gave this a try. I think this might be it.

Please consider atleast adding MCP support if you can. That'll help


Here you are:

"Codex in ChatGPT desktop app for Linux is now in preview" https://community.openai.com/t/codex-in-chatgpt-desktop-app-...


Thanks! Yes, adding MCP support and preserving skills is definitely a priority for us right now.


thanks for pointing that out. I did see some weird comments yesterday. some of them got removed before i could reply. some later i guess. But whatever, we didnt ask people to comment here :)


ptrace is too low level and will freeze your process. it cant be used for production debugging i feel.

we work at the application layer by hooking into production grade tooling if available (inspector in v8, sys.monitoring in python) or bytecode manipulation(jvm)

since we arent controlling the application for a different process, we dont need to freeze the app to get the current app state

requirements we had in mind in order of importance

1. safety -> user app needs to function as usual no matter what happens, there shouldnt be an error in the user's app because of us

2. zero idle footprint -> if no probe is active, cpu/memory differency in the user app should be immeasurable

3. zero latency footprint at non probe paths while other probes are active

4. measure mem/cpu footprint directly or via a proxy like eventloop lag and have guardrails around it. suspend probes or even lose snapshot data if guardrail conditions meet

5. minimal mem/cpu footprint for active probes

6. minimal latency foot print for active probe paths


yes, for example we dont have connectors for k8s yet, so we are blind to memkills triggered due to sidecars.

trying to debug using our tool might even lookup some memleak candidates in your primary container, but there wont be conclusive evidence for it and it would say so.

for in app errors all we do is hypothesize and either prove/disprove that using data from running system.

and whenever we do report something we give have the evidence for it. its not fool proof but just asking does this hypothesis gets proved with this evidence in a subagent mostly does the trick


"Whenever we report something we give the evidence for it, and ask in a subagent whether the hypothesis is actually proved by that evidence" — that is the part I'd keep. It makes the verdict falsifiable out loud, which is rarer than it should be.

The class I never solved sits one level below that: a check that runs, passes, and is looking at the wrong object. My top-level health signal was green for three days while zero artifacts shipped. Sixteen daemons alive, backend responding, auth token valid — every organ it polled was genuinely healthy, and nothing measured the thing leaving the building. A missing k8s connector would not have helped; the data was all there and all correct.

Related one from the same eight months: 29 quality gates, written and unit-tested and committed, none of which was ever called, because nothing was a runner. The tests proved the gates worked. Nothing proved they were wired.

Do you see that shape at customers — monitoring correct, conclusion still wrong because it describes the process instead of the result? I ask because it decides what your diagnosis agent should be sceptical of: if the input signals can be individually true and jointly meaningless, evidence-checking inside the hypothesis does not catch it.


i just gave the k8s example to show that we wont be able to find root cause of every issue.

our snapshots give evidence, whether or not its helpful is determined by the engineer/ai agent

I'm not saying every issue would be diagnosed this way, sometimes, it might well be beyond your control like a VM on a noisy neighbour hogging shared CPU

we might get things wrong as well.


we have a lot of guardrails (https://docs.hyperprobe.co/how-it-works#built-in-safety-guar...)

if any guardrails fails, we suspend probes till cooldown.

also 1. every probe is bounded by hits/expiry time (whichever comes earlier) 2. hit budgeting happens with a token bucket at a global level, per probe was an overkill (numbers are configurable) 3. we even measure the execution time that probes have when active and suspend if that that takes longer than threshold (again configurable) 4. we even have budgets for the network bandwidth it would take (approximated by the size of payloads) 5. collection itself is bounded by max no of total snapshots we can keep in memory. 6. every snapshot has a size limit as well, every variable has a size limit as well. 7. depth of objects, no of objects, size of lists is capped by default.

latency delta varies by platform under load but is mostly negligible

nodejs: ~7-10ms python: ~4-9ms java: 1-2ms

the main reason for this is guardrails suspending probes, having loosened guardrails will increase this under load

regarding localization of failures.. absolutely we even report the error in the probe snapshot (confirmed by adding side effects in an expression and commenting out the guardrails during testing)

huge payload size doesnt matter.. we limit the objects depth, list length, remove duplicate refs from data etc.. even string length is truncated., but even if it happens, your request would still survive.

also, even if the collector dies or there's a network failure, your service remains unaffected, we just are unable to collect telemetry

we are boring under extreme conditions :)


by defalut, probes basically tell the fileName/className and lineNo/methad name to attach to (in additon to metadata like serviceId, environemnt name etc)

This is readonly and safe by default.

expressions come into play for conditonal probes

read only safety guarantees here depend on the runtime

NodeJS: handled implicitly by using `throwOnSideEffect: true` any side possible effects are prevented using this

Python and Java: As of now, we don't let conditions have method invocations at all and only allow a subset of comparator operators. no assignment allowed

usually property can invoke getter which usually should be safe to execute by design, but since we cant guarantee how it would have been written, we dont allow that as well for now.

order.total > 50 => not allowed

total > 50 => allowed

to get around this we use multiple probes, agrregated by the current context's traceId (if avaliable)

we plan to eliminate this problem by adding a custom DSL + AST parsing which can act as the policy layer to dissallow condtional probes

Audit trail is in our roadmap. As of now, you can delete the data that's collected by probes. the only problem we have with audit trail is what if you capture something sensitive and that remains in your audit trail.. so we need some immutability that registers audit trails.. but then have enough flexibility to remove the data collected.. can be done


> How is HyperProbe different from existing tools like AppSignal, Rollbar, and Embrace?

These work only on either uncaught exceptions or wrapping up caught exceptions with their sdk. These tools will not help you with silent failures, like logic bugs where code executes cleanly without throwing, but produces the wrong business state. If every problem in your app ends up as an exception, sure you'll be able to catch the symptoms of where the exception got thrown. we can deal with these too, but these tools cant deal with the messy bugs where no exception fires.

> Such very mature tools exist that auto-instrument, collect variables from the call stack, and pinpoint error causes.

That is true for python using frame.f_locals (we use this as well)

nodejs only gives it only till the lasy async boundary, after that v8 itself drops this data. java only gives you the current frame, to get variables beyond that you would needs JDI/JVMTI which would block your threads, usually unnacceptable in production

To get around this safely, we add multiple probes all across the call chain and collate collected data using the traceId from the context (or thread id as a fallback);

> Does this tool only exist to shore up poor system design?

Returning 200 OK on a silent failure is 100% bad system design, I completely agree. But real-world production systems are full of legacy edge cases. (if that weren't true, L1/L2/L3 support team shenanigans wouldn't exist)

Also, the exception will tell you that an exception occured in order service in GET /orders/{id}/payment, your trace will tell you payment service is giving 404 for that order ID

what it wont tell you it happened becuase the webhook endpoint that your payment gateway calls is now receiving a new payment state called 'PENDING' and that you dont handle but still mark the payment as 'processed' for idempotency check. and now your order service is calling the payment service and its giving 404 because it never got written

Bad design. 100% Agree, but has happened IRL.

> putting engineers in a situation where debugging requires accessing unknown amounts of live sensitive customer data is generally considered bad practice (even if it happens often IRL)

I think tells that teams would go to these extents to fix issues. Not ideal. I agree.

> in a hurry to debug, it's easy to miss that a property should have been redacted; by then it's too late and sensitive data is exposed

fair critique. we currently use in-process rule engines to filter known sensitive patterns, and users can add on to it. but we are also building out-of-process secondary checks (using NER/classifiers) to sanitize payloads before storage. It requires strict rules, but getting verified runtime evidence is far safer and faster than blindly guessing and shipping trial-and-error hotfixes to production. or waiting to be too sure.. a luxury that might not be possible everytime.

> Rollbar etc aggregate errors and captured data to identify patterns before a human (or agent, or tool) ever takes a look at it.

There is merit in that as well, if you are looking at so many logs/traces, you kinda have to do it. We have a different approach, we use hypothesis driven conditional probing instead. probes are dropped dynamically as the understanding of the bug evolves in a session

exmaple:

console.log('hello');

const x = await getThisValueSomehow();

if (condition A) {

console.log('i m in condition A');

// do something;

} else if (condtion B) {

console.log('i m in condition B');

// do something;

}

You can also place a probe before the branch to capture variable state when neither condition evaluates to true. You gather precise data on demand rather than paying to store petabytes of static trace data.

> A single captured instance can also be very misleading as to the true cause.

We collect multiple snapshots per probe run. However, because we capture full variable state at the exact execution line, a single snapshot frequently reveals the root cause for that specific failure path. If that snapshot raises new questions, you/your agent simply drops more probes deeper down the call chain

Thanks! This was very insightful


thanks! the read-only guarantee is structurally enforced by sdk itself

a probe is basically just a definition it contains the file and line number of the code you want to inspect

that is safe by default. there's no custom userland function that you can call

if you want conditional probes, then it get's tricky

here's how it works

NodeJS: v8 natively blocks if the code even tries to produce side effects using `throwOnSideEffect: true`

in python and java: conditions can be set on local variables only without accessors as of now. you can call functions, can only a subset of comparison operators.

so, you can set `total > 50` as a condition but not `order.total > 50` as it could in theory trigger a getter (which ideally should be fine, but devs/agents can make getters with side affects so we wont allow it for now)

We will support these use cases with a custom DSL for agents + AST parsing in the future which will let us safely evaluate these expressions.


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.


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)


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


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.


Take your feedback! What do you think about the problem and how the solution fits to that?


Guidelines | FAQ | Lists | API | Security | DMCA | Apply to YC | Contact

Search: