Agent Know-How

In an InfoQ talk on LLM-powered selection systems, Jendrik Jördening restricts model output to a constrained schema, separates semantic extraction (where the model is needed) from the deterministic code that acts on it, and validates the model's choices with a discriminator model before they reach the database.

He structures the pipeline as an MVC-style split so non-determinism stays in one layer instead of leaking into storage and downstream logic.

Quickchat's write-up on reliable agent actions describes two mechanisms. A server-side gate evaluates conditions after the model decides to call a tool but before the request goes out, so a prompt-injected model cannot talk its way past the check. A JSONPath extraction step stores values from earlier API responses so later steps reference a saved field instead of the model re-typing, and possibly hallucinating, an ID.

Enforcement lives outside the model's decision, not inside a longer, more careful prompt.

In an InfoQ talk, NVIDIA's Aaron Erickson describes purpose-built agent hierarchies that separate tools for certainty (deterministic code you can trust) from space for the model's own discovery. He pairs the split with LLM-as-judge test pyramids and warns against the paradox of choice: giving an agent too many options lowers reliability.

Deciding which parts of a task get deterministic treatment becomes an explicit architecture decision, made at design time, rather than something left to the model at run time.

An essay splits agent reliability into three legs:

• Identity has no purpose-built primitive. Platforms retrofit workload identity: SPIFFE-based identities (Gemini Enterprise), service principals plus token brokers (Microsoft Entra). The fit is poor because two runs of the same agent can behave differently.
• Execution borrows the distributed-systems playbook: checkpoint recovery, exactly-once guarantees, cgroup quotas, per-session microVM or gVisor isolation.
• Intent is least solved. Models drift from the task or report false completion. Fixes split between LLM-graded trajectory checks and cheaper encoder classifiers that score task completion, an auditability and cost trade-off.

The identity leg overlaps with sandboxing and scoped credentials.

ReWEIGH calibrates token-level ordinal visual evidence during decoding in vision-language models. It projects visual-token states through the output head to measure how strongly the image supports each candidate token, instead of only judging the finished output.

It is the "contain it during generation, not just catch it after" approach, applied inside the decoding step.

AutoResearch is a two-stage system that links idea generation to idea execution so autonomous research workflows stay scientifically grounded. Its premise, "insight in, hallucination out", is that automation alone does not keep a long research run rigorous.

For long-running agents, grounding has to be a design target of the workflow, checked through experiments, rather than assumed from automation.

Simon Willison describes Doug Turnbull's trick for tagging against a vocabulary too large for one prompt (his blog has 1,856 tags). Ask the model to output tags with no knowledge of the existing vocabulary, then use vector-embedding similarity to map each guess to the nearest real tag.

It swaps a task the model is bad at (choosing from thousands of options) for one it does well (free generation plus retrieval). It only works because the embedding step grounds the hallucination instead of returning it as-is.

HALO (Hallucination-Aware Layered Oversight) argues "zero hallucination" is a property a system enforces, not one a model has. It stacks six layers:

• grounded generation over approved content
• constrained, deterministic execution that bounds where the model can err
• multi-signal verification: an LLM judge plus evidence checks against source text
• calibrated abstention when grounding is thin
• traceability of every retrieval, tool call, and generation
• continuous oversight that detects drift and regenerates on threshold breaches

It puts the identity/execution/intent controls into one composable architecture instead of waiting for a model that does not hallucinate.

Tech Times coverage puts Grok 4.5's coding-agent cost roughly 80% below a comparable frontier setup, at near-frontier speed and accuracy, but with the hallucination rate roughly doubling as accuracy rose. The figures are from press coverage, not an independent benchmark.

A cheaper, faster model is not a free swap. The saving only holds if the harness adds verification to catch the extra hallucinations; see agent cost for the cost side.

HIVE is an evaluation harness for post-hallucination reasoning: what happens after hallucinated content enters a vision-language model's context. Across nine tasks and nine models, hallucinated captions often improved accuracy on vision-language tasks by broadening semantic coverage, while text-only tasks showed limited or unstable effects.

"Does the agent hallucinate" is the wrong single-axis question. What matters is whether a given hallucination widens useful context or misleads the next reasoning step.

Phil Schmid notes that agents can already edit their own tools, skills, and harness. Recursive self-improvement still needs a system that can raise the verifier without the agent capturing it.

A self-modifying agent can also modify its own check. Any self-improvement loop needs a verifier the agent cannot rewrite.

LangSmith Tuned Evaluators attach quality feedback to production traces, starting with a Perceived Error signal that surfaces agent mistakes from user reactions in production.

It adds a user-facing check alongside independent judges and trace mining: the agent's "done" is tested against whether the user thought it was right. The eval-tooling side of the release is on agent evaluation.

Sonn is a persistent reasoning layer that watches a coding agent's session live and injects a nudge the moment a past decision becomes relevant again, such as a previously rejected approach or a settled architecture choice.

It moves reliability work upstream: from checking the output after the fact to steering the decision before the agent makes it. The claim comes from a Show HN launch, with no published accuracy numbers.

Make No Mistakes, a Show HN project, is built around one rule: an AI coding agent must prove its work with verifiable evidence of completion instead of the harness trusting the agent's own "done" signal.

It is a practitioner-side instance of the same idea the research work on this page converges on. False completion is a known failure mode, so the completion claim itself has to be checked.

Anthropic found that infrastructure configuration, container CPU/RAM allocation and how strictly it is enforced, can move agentic coding scores by up to 6 percentage points on Terminal-Bench 2.0.

That is enough noise to erase an apparent reliability gain. Pin and report the eval infrastructure alongside the model; methodology is on agent evaluation.

Anthropic's analysis of roughly 400,000 Claude Code sessions splits responsibility along the plan/execute line: people make about 70% of planning decisions but only 20% of execution decisions. Expert users trigger about twice the actions per prompt that novices do (12 vs. 5) and five times the output (3,200 vs. 600 words).

Reliability today leans on where humans still hold the pen, which is planning rather than unattended execution. Removing that human checkpoint removes part of the reliability you are currently getting for free.

Anthropic reliability engineer Alex Palcuie reports on using Claude for incident response:

• Observe works. It flagged 4,000 accounts created at once with identical traits as coordinated fraud, and root-caused a Rust panic in checkpoint.rs before engineers finished reading the logs.
• Orient breaks. Seeing requests and errors double together, it repeatedly called a capacity problem when a failed KV cache was the cause; the engineer corrected it "six, seven times" before adding the distinction to the system prompt.
• Postmortems come out "80% readable" but miss contributing factors.

The open risk: if AI runs mitigation, humans lose the feedback loop that builds senior-responder judgment.