Est.

Fabricated Identifier Failures in Agentic Pipelines

AI agents silently use fabricated identifiers when tool calls succeed despite wrong arguments.

· 8 min read
Cover illustration for “Fabricated Identifier Failures in Agentic Pipelines”
Silent Failure Modes · October 20, 2026 · 8 min read · 1,817 words

Fabricated Identifier Failures in Agentic Pipelines explains why a successful tool call can conceal a wrong action. To detect silent failures in AI agents in production, teams must check tool arguments and results against the agent’s instructions as well as whether a request succeeded. An invented identifier can pass format checks, reach a real tool, and return success while directing the pipeline at the wrong object.

Why fabricated identifier failures are harder to detect than ordinary hallucinations

The trace shows success, but the system has acted on an invented input. The tool’s HTTP 200 response is the failure’s alibi because it records successful execution without establishing that the argument was valid. Ordinary hallucinations produce wrong text, whereas fabricated identifiers can produce wrong actions. That distinction creates a structural mismatch between what the pipeline reports and what actually happened.

Consider an agent that guesses a database uses user_id when the schema requires customer_uuid. In this failure pattern, the lookup returns zero rows, and the agent reports “no data found”. The response makes a bad argument look like evidence about the data. As a result, the user can blame the data while the engineer investigates retrieval, leaving the invented field name outside the investigation.

Output filters and hallucination judges aimed at user-facing text do not establish whether a tool argument refers to the intended object. A structurally valid argument can cross that boundary without producing an error for those checks to catch. Detecting it requires access to the action and its context. This is the silent misbehavior that agent observability platforms, including Lemma, address by auditing traces against the agent’s instructions.

How next-token prediction makes identifiers probabilistically plausible to the model

Next-token prediction favors a plausible continuation. Identifiers are at particular risk because DOIs and UUIDs have strict patterns that a model can copy without knowing whether a given value exists. A well-formed identifier can therefore be probable as text while being entirely fabricated as a reference. Post-training alignment, including RLHF and constitutional AI, makes generation more helpful but does not make token prediction check whether something exists. Better model behavior can reduce errors, but it cannot serve as proof that an identifier is real or appropriate for the task. The pipeline must therefore check the identifier outside the model’s judgment of what looks plausible.

The taxonomy of fabricated identifier subtypes and what each one defeats

Ansari’s 2026 taxonomy, developed through manual coding of fabricated citations in NeurIPS 2025 papers, distinguishes five categories. Total fabrication produces an identifier that never existed, so an existence check can reject what format validation accepts. Partial attribute corruption blends real and fabricated elements, including corrupted titles, volumes, years, or page numbers. Because some elements remain genuine, a shallow resolver may return enough evidence to make the reference appear legitimate.

Identifier hijacking is harder to catch because it reuses a real DOI or arXiv ID for an unrelated paper. The link resolves, but its destination does not support the claim attached to it. Placeholder hallucination instead supplies a syntactically acceptable dummy value, such as “Firstname Lastname and Others”, which a human can recognize but a format validator may accept. Semantic hallucination supplies a professionally plausible title that fits the research domain but corresponds to no real work. These distinctions separate the question of whether a reference looks right from whether it exists and means what the surrounding text says it means.

The same distinctions apply to UUIDs, API parameters, and order IDs in agentic pipelines. A fabricated customer_uuid is total fabrication, while a real user ID applied to the wrong account is identifier hijacking. A real order ID with a corrupted field is a case of partial attribute corruption. An existence check addresses the first case but cannot establish account correctness in the second or field consistency in the third. Schema validation, existence checks, argument-level policy, and semantic verification therefore answer different questions.

How a single fabricated identifier propagates through downstream pipeline steps

Agentic pipelines pass one step’s output into the next, where later steps may treat it as verified input. Tool calls, database writes, and API transactions can then proceed on the same false premise. Each accepting step increases the chance that the final result will be wrong and adds another place where the error has taken effect.

A longitudinal production study of a personal-assistant agent runtime documented 22 incidents with full root-cause postmortems. One incident involving a fabricated analysis illustrates the trust-transfer mechanism. A Unicode surrogate caused a JSON serialization error, and a logging function printed diagnostics to stdout. Command substitution saved that error text as a cache payload, so the reduce-step LLM then saw error-code vocabulary throughout its context. It composed a confident analysis of a fabricated “Hugging Face platform crisis” because successive stages had accepted the preceding stage’s output as usable material.

Gabriel Anhaia’s production trace shows a related amplification through repeated retries. A database lookup returned a truncated JSON blob because of an undocumented 4KB gateway cap, and the model correctly recognized that the response was broken. It nevertheless retried repeatedly, increasing latency and cost while the interpretation of the defective payload continued through the workflow. A 2026 study isolates another route, namely fabrication after a tool returns nothing usable, when the model asserts an answer the payload cannot support.

Why schema disclosure determines whether a fabricated identifier can even be caught at the boundary

A tool can reject only the violations its boundary is equipped to recognize. If an identifier constraint is absent from the schema and unavailable to a downstream validator, the model’s plausibility judgment becomes the only guard. Explicit prose can guide the model better than an example alone, but it does not give an external validator a rule it can enforce. Machine-readable constraints let a validator enforce the rules without relying on the model.

Even when a format rule can be enforced, it leaves open whether a given caller is allowed to use a given value. Kodathala’s 2026 aiAuthZ architecture illustrates why that decision belongs outside the agent’s trust domain. It moves authorization off the agent’s host to a layer that verifies caller identity and evaluates role-based and argument-level policy. The agent cannot read or modify that policy, so the component proposing the action does not also control the rule that permits it. This is an architectural illustration of separation, not a reason to treat authorization as a complete detector of fabricated identifiers.

The boundary must distinguish a permitted tool from a permitted use of that tool. Allowing a lookup does not establish that the supplied identifier belongs to the account involved in the task. Argument-level enforcement can address that distinction when the necessary constraints are available. If those constraints remain unstated, however, the validator has no independent basis for rejecting a plausible value. Model quality cannot supply a missing enforcement rule, and a successful call cannot retroactively prove that the rule was satisfied.

How to know when an AI agent is wrong instead of crashing through semantic verification

The detection question must change from whether the call succeeded to whether its argument was valid for the context and caller. An HTTP 200 response with an empty, null, or malformed payload does not answer that question. Nor does a fluent final response establish that the tool supplied evidence for it. Traditional application performance monitoring can report that a run went well while missing this mismatch, especially when the same input leads to different sequences of tools across runs. Step-level tracing is therefore the minimum signal for distinguishing operational success from task correctness.

A useful trace exposes the relation between the requested task, the supplied argument, and the returned payload. Wrong arguments, missing fields, and fabricated tool names have different signatures from a legitimate lookup that finds no results. Comparing the argument with the schema reveals a constraint mismatch, while comparing the final claim with the returned payload reveals unsupported assertions. Neither comparison alone catches a real identifier attached to the wrong object, which also requires semantic verification.

The Microsoft AI Red Team’s v2.0 taxonomy, dated April 2026, adds Session Context Contamination and MCP/Plugin Abuse after a year of red-teaming agentic systems. A 2026 study of production agent frameworks makes the payload comparison concrete. It found that one shipped prompt reached a 24.67% fabrication rate after tool failure. In that pattern, the decisive evidence is that the answer references information the tool did not return, even though the interaction produced a response.

Online evaluations on live traffic must compare behavior with the agent’s own instructions, including what it was supposed to do with the identifier and how it was supposed to handle an unusable result. Lemma audits every trace against those instructions and groups recurring deviations into actionable issues. That approach can surface recurring identifier-fabrication patterns without requiring engineers to manually decode every successful-looking call or predefine every variant. It works alongside schema checks, resolvers, and authorization to check whether the actions completed the task as well as whether each component accepted its input.

What the failure mode looks like in production and what teams discover too late

Ansari’s 2026 account of the NeurIPS 2025 and ICLR 2026 cases shows why dedicated detection matters even when fabricated references look conventional. ICLR 2026 program chairs desk-rejected 647 submissions that cited fabricated references. An automated reference checker compared citations against bibliographic databases, and subsequent human review rounds filtered false positives. The important distinction is between screening that accepts a plausible reference and instrumentation that tests its referent.

The fabricated “Hugging Face platform crisis” analysis reached the user as a routine digest. A reader recognized that the content was wrong before any monitoring layer flagged it. The postmortem then had to follow the chain back through the reduce step, cache payload, logging output, and serialization failure. This incident demonstrates the same late-discovery problem that identifier propagation creates.

The 2026 fabrication-after-tool-failure study found that none of the nine production agent frameworks audited specified what the model should do when a tool failed. That omission also weakens detection because there is no stated expected behavior against which to evaluate the trace. Kodathala’s 2026 discussion of MCP supply-chain cases exposes a different trust gap through the postmark-mcp package, which shipped clean releases before adding email exfiltration code. In that case, the question extends beyond whether an argument names the right object to whether the invoked tool is the tool the agent believes it to be. A familiar tool identity is not sufficient evidence of trustworthy behavior.

A wrong digest, an unsupported answer, or a security incident gives the warning that routine success monitoring failed to give. Production monitoring must therefore evaluate the meaning of actions while their traces are available, before the user disputes the result. For fabricated identifiers, each downstream step can make the system do more work based on the same false premise. The later detection occurs, the farther the investigation must reach and the greater the remediation cost becomes.

Sources

  1. aiAuthZ: Off-Host, Identity-Bound Authorization for AI Agents
  2. Compound Deception in Elite Peer Review: A Failure Mode Taxonomy of 100 Fabricated Citations at NeurIPS 2025
  3. Real-Time Detection and Repair of LLM Agent Failures
  4. Updating the taxonomy of failure modes in agentic AI systems: What a year of red teaming taught us

More in Silent Failure Modes