HackerTrans
TopNewTrendsCommentsPastAskShowJobs

amabito

no profile record

Submissions

Ask HN: How do you prevent retry cascades in LLM systems?

2 points·by amabito·5 miesięcy temu·0 comments

Show HN: Preventing runaway LLM agents (enforcement layer)

github.com
1 points·by amabito·5 miesięcy temu·2 comments

Ask HN: Do LLM agents need a separate safety layer?

2 points·by amabito·5 miesięcy temu·0 comments

comments

amabito
·5 miesięcy temu·discuss
IOPB bit semantics are inverted from what you might expect: 0 means permitted, 1 means denied. So zeroed pcb memory silently grants access to every port in range -- that's why this was consistently reproducible, not flaky. One sizeof() away from correct the whole time.
amabito
·5 miesięcy temu·discuss


  Vulkan's presentation API makes this distinction explicit: VK_PRESENT_MODE_MAILBOX_KHR is the "replace if already queued" mode that actually reduces latency, while VK_PRESENT_MODE_FIFO_KHR is the pipeline-queue variant that adds frames ahead of time. OpenGL never standardized the difference,
  so "triple buffering" meant whatever the driver implemented -- usually vendor-specific extension behavior that varied between hardware. The naming confusion outlived OpenGL's dominance because the concepts got established before any cross-platform API gave them precise semantics.
amabito
·5 miesięcy temu·discuss
The tooling gap exists partly because git's data model has no native concept of "this branch's upstream is another feature branch" — each PR is independent from the forge's perspective, so rebasing one layer in the stack requires manually re-targeting every PR below it. FAANG-internal tools solve this by storing the stack relationship in a metadata layer outside git itself, then regenerating the PR graph after each rebase. Without that layer, the bookkeeping falls on the developer, which is why most teams abandon the workflow after two or three levels deep regardless of how disciplined they are.
amabito
·5 miesięcy temu·discuss
One thing that often gets overlooked in this comparison is how behavior trees degrade under retry or partial failure scenarios.

State machines make failure transitions explicit, but behavior trees can re-enter branches in ways that resemble retry amplification unless guarded carefully.

Curious whether anyone has modeled agent execution control as a state machine specifically to make containment explicit.
amabito
·5 miesięcy temu·discuss
One thing I find fascinating about epoll/kqueue is how much modern async frameworks abstract away the underlying readiness model.

A lot of people talk about “async performance” without realizing the core efficiency gain came from avoiding O(n) scans on idle FDs.

Curious how many higher-level runtimes still leak edge-triggered vs level-triggered semantics in subtle ways.
amabito
·5 miesięcy temu·discuss
Most orchestrators aren’t “bad”.

They just assume LLM calls behave like deterministic RPC.

The real issue is that we’re embedding stochastic, cost-weighted calls inside recursive graphs without structural bounds.

Orchestration isn’t the failure. Lack of containment is.
amabito
·5 miesięcy temu·discuss
That’s actually a pretty disciplined setup.

What you’ve described sounds a lot like layered containment:

Loop budget (hard recursion bound)

Progressive checks (soft convergence control)

Sleep cycles (temporal isolation)

Deep sleep cap (bounded self-modification)

Git rollback (failure domain isolation)

Out of curiosity, have you measured amplification?

For example: total LLM calls per wake cycle, or per deep sleep?

I’m starting to think agent systems need amplification metrics the same way distributed systems track retry amplification.
amabito
·5 miesięcy temu·discuss
This is interesting.

It looks less like a “model failure” and more like a containment failure.

When agents audit themselves, you’re effectively running recursive evaluation without structural bounds.

Did you enforce any step limits, retry budgets, or timeout propagation?

Without those, self-evaluation loops can amplify errors pretty quickly.
amabito
·5 miesięcy temu·discuss
Right — search engines have long had authority scoring, link graphs, freshness signals, etc.

The interesting gap is that retrieval systems used in LLM pipelines often don't inherit those signals in a structured way. They fetch documents, but the model sees text, not provenance metadata or confidence scores.

So even if the ranking system “knows” a source is weak, that signal doesn’t necessarily survive into generation.

Maybe the harder problem isn’t retrieval, but how to propagate source trust signals all the way into the claim itself.
amabito
·5 miesięcy temu·discuss
What’s interesting here is that the model isn’t really “lying” — it’s just amplifying whatever retrieval hands it.

Most RAG pipelines retrieve and concatenate, but they don’t ask “how trustworthy is this source?” or “do multiple independent sources corroborate this claim?”

Without some notion of source reliability or cross-verification, confident synthesis of fiction is almost guaranteed.

Has anyone seen a production system that actually does claim-level verification before generation?
amabito
·5 miesięcy temu·discuss
Approval gates make a lot of sense, especially for high-impact actions. Most agent failures I've seen come from nothing stopping execution at all.

One scenario I'm curious about: how do you think about overnight or weekend runs when no one is around to approve? Human gates work well during business hours, but agents don't necessarily respect that clock.

Do you see Axon evolving toward hybrid controls — human approval for sensitive actions, plus automatic limits for volume or repetition?
amabito
·5 miesięcy temu·discuss
The Markdown-over-database choice makes sense for document-shaped output.

The harder problem seems to be concurrent semantic edits. Git-style merging works for code because conflicts are syntactic. With prose, two agents can produce logically conflicting conclusions without triggering a merge conflict.

How does Sayou reason about semantic divergence when Agent A updates a research note while Agent B is drafting against an older snapshot?
amabito
·5 miesięcy temu·discuss
Nice reference. If agents are essentially “a while loop with an LLM call,” then one missing category might be execution control.

In distributed systems we rarely let loops run unbounded — we add budgets, backoff, circuit breakers, etc. With agents, it’s interesting that most frameworks focus on observability (traces, logs) but not on hard containment of the loop itself.

If you were extending the mapping, would “agent budget limits” fit better as a rate limiter, a circuit breaker, or something closer to a bounded work queue?
amabito
·5 miesięcy temu·discuss
Here’s a raw 75s demo of a runaway loop being halted: https://youtu.be/LaZOGj3EO_0
amabito
·5 miesięcy temu·discuss
Context: This isn’t another observability tool.

It enforces: - hard budget stops - retry containment - circuit breaking

The goal is simple: the $12K weekend never happens.
amabito
·5 miesięcy temu·discuss
[dead]