Failure Modes

Companion doc: Modes of Operation — capability taxonomy this catalog is organized against.

Layers

Failure modes here exist at two layers:

• L1 (Honcho-as-component) — the internals (deriver, dreamer, dialectic, summarizer) produce wrong artifacts given correct input. Observable through Honcho’s own APIs (get_representation, get_peer_card, get_context, peer.chat()). Testable today in tests/unified.
• L2 (Honcho-in-context) — the artifacts may be correct, but the wrapping agent reads, weights, or acts on them wrongly. Observable only at the agent’s output (tool calls, code, response). Requires a coding-agent benchmark module (likely in Excadrill); not testable in tests/unified today.

Many entries express the same underlying bug at both layers — e.g., “old fact wins” can show up as dialectic ranking it first (L1) AND as the agent acting on it even when both facts are surfaced (L2). Those are tagged L1+L2 with both expressions noted. Entries marked just L1 may still cause downstream agent harm, but the bug is fully contained at the substrate — fix L1 and L2 follows.

Severity tags ([H]/[M]/[L]) and layer tags are orthogonal — a high-severity bug can live at either layer.

Trigger-pattern frequency vs. priority observation evidence. Severity tags reflect whether the bug has been observed firing in production, not how common the triggering input pattern is in real-world transcripts. A failure mode can have a very common trigger pattern (negation phrasing, scope cues, task-completion frames) without being [H] if the bug itself hasn’t been observed firing. The next move for a [M] entry with a corpus-common trigger is to author a synthetic reproducer, not auto-promote the tag.

Scope & lifecycle (new category — conclusions lack metadata for these axes)

• scope_overgeneralization [M] — Task-scoped preference gets stored as a peer-global one. (L1+L2: L1 — representation/peer card stores it at the wrong scope; L2 — agent applies the rule outside the originating task context.)
• task_state_no_completion [M] — A specific task gets stored; completion of the task (in any session) doesn’t update the conclusion. (L1+L2: L1 — conclusion never gets demoted/closed; L2 — agent treats the task as ongoing.)
• scope_session_to_global [M] — A statement made in a session-specific context bleeds into the peer’s global representation. (L1+L2: L1 — storage isolation gap between session-scoped and peer-global; L2 — agent in a different session reads the local preference.)
• lifecycle_archived_as_active [M] — Old projects with high-confidence conclusions never get demoted, so the agent describes archived work as current. (L1+L2: L1 — peer card carries old project as current; L2 — agent describes archived work as current even when context suggests otherwise.)
• deletion_friction [H] — Even after the user knows a conclusion is wrong, removing it requires non-obvious tooling or repeated effort. UX-layer failure. (L2: pure UX/wrapper concern; the L1 deletion API exists.)

Negation / defensive memory

• negation_buried_as_preference [M] — “Stop X” / “never X” gets stored as a generic conclusion or pattern_type=preference; gets buried in semantic search alongside ordinary preferences. Genuine Honcho data-model gap (no constraint type). (L1: storage classification problem.)
• negation_silent_when_violated [M] — User now wants to do something they previously said NOT to do. Dialectic doesn’t surface the contradiction unless asked. (L1+L2: L1 — dialectic chat output doesn’t flag the prior “don’t”; L2 — agent proceeds without surfacing the contradiction to the user.)

Time / temporal

• time_drift_storage_no_supersession [M] — Preference changes from X to Y; both conclusions persist in storage with no supersession link. The dreamer/deriver should mark Y as superseding X (both retrievable, but the relationship recorded), but doesn’t. (Storage-layer half of the former time_drift_no_marker.) (L1: storage layer.) (Corpus note: dominant real-world trigger is implicit revision via correction, not explicit “I changed my mind” — 19 strict hits / 0 literal-phrase hits in 35,445-row coding corpus, but Mind Changer persona corrects in 35.4% of turns. Repro shape should cover both explicit announcement and implicit override-via-correction. Observed in SWE-chat 2026-04-30, DEV-1709.)
• time_drift_dialectic_no_currency_marker [M] — Even when both X and Y are stored, dialectic’s retrieval output doesn’t annotate which is current, so the wrapping agent can’t tell. (Retrieval-layer half of the former time_drift_no_marker — independent of whether storage supersession exists.) (L1: dialectic output layer.) (Corpus note: same dominant trigger as time_drift_storage_no_supersession — implicit override via correction is the common form. Observed in SWE-chat 2026-04-30, DEV-1709.)
• time_old_fact_wins_via_relevance [M] — Dialectic returns the older fact because semantic-search relevance favors the more-discussed one over the more-recent one. (L1+L2: L1 — dialectic ranks the older fact first; L2 — agent uses the older fact in its output even when both are returned.)
• time_stale_demographic [M] — Stale facts (employer, location, project status) don’t decay even after months of contradicting context. (L1+L2: L1 — representation doesn’t decay; L2 — agent acts on stale fact.) (Corpus note: deployment-surface-dependent — coding-agent transcripts surface near-zero biographical content, so this entry is under-tested for coding deployments. Retain priority for chat / personal-assistant surfaces where biographical context dominates. Observed in SWE-chat 2026-04-30, DEV-1709.)
• time_dreamer_loses_ordering [M] — Dreamer consolidates two contradictory facts into a synthesis that loses which was latest. (L1: internal consolidation.)
• misinterpretation_correction_creates_orphan_fact [M] — User explicitly tells the agent it misunderstood (“no I meant X, not Y”). If the deriver writes facts only from user turns, the original misinterpretation is invisible to it; if it writes facts from any turn (or via the source-attribution failure in agent_synthesized_text_as_user_input), both wrong and corrected versions persist without lifecycle metadata to mark which is current — same end-state shape as time_drift_storage_no_supersession, but the trigger is agent misinterpretation rather than user mind-change, and it can fire on facts the user never explicitly stated themselves. Compounds with agent_synthesized_text_as_user_input: if agent claims slip into the representation, user corrections of those claims can’t fully retract them. (L1: storage layer; cross-references the transcript-ingestion section above.) (Corpus evidence: 63 explicit-misinterpretation hits in SWE-chat 2026-04-30, DEV-1709.)

Concept models / entities

• entity_name_variant_split [feature gap] — Same person referenced by name variants (full vs. nickname) gets modeled as separate peers. Note: Honcho’s peer IDs are application-supplied; there is no entity-resolution layer to fail. This is a feature gap (Honcho doesn’t do entity resolution), not a behavioral failure of an existing component. Either reclassify or move to a separate “feature gaps” list.
• entity_project_collision [M] — Two projects with similar names get conflated. (L1: internal entity confusion; downstream agent inherits the conflation.)
• entity_relationship_unstructured [L] — Relationships (“X reports to Y”, “repo A depends on B”) captured as prose inside conclusions, can’t be queried as structured edges. (L1: data model gap.)

Cross-context

• cross_session_inconsistent_repr [M] — Same peer queried from two sessions returns inconsistent representations because session-level context isn’t fully reconciled. (L1.)
• cross_tool_state_drift [M] — Same peer accessed from Claude Code vs. Hermes shows different memory state due to sync lag or partition. (L1: sync/partition.)

Pipeline health (deriver, dreamer, summarizer)

• pipeline_queue_lag [M] — Deriver queue backs up under bursty input; observations lag minutes behind messages and dialectic answers from stale state. (L1.)
• deriver_non_idempotent [M] — Re-running deriver on the same message produces different observations (at temp > 0). (L1.)
• confidence_inflation_via_repetition [M] — When the same constraint is restated many times across one session (because the agent keeps mishandling it and the user keeps re-explaining), the deriver records N near-duplicate atomic facts. If retrieval/synthesis interprets repetition as user emphasis, the constraint becomes overweighted in the representation — even though the repetition is a signal of agent failure to internalize, not user conviction. (L1; distinct from deriver_non_idempotent — that entry is unstable re-derivation; this is stable re-derivation that adds up to over-emphasis.) (Corpus note: extreme tail in SWE-chat — one session has 400 corrections in 526 turns; 119/108/78 corrections in nearby sessions. Trigger pattern is corpus-common in long agentic-coding sessions. Observed in SWE-chat 2026-04-30, DEV-1709; reproducer not yet authored.)
• dreamer_over_consolidation [M] — Dreamer deletes specific named facts in favor of generic patterns, losing detail that mattered. (L1; downstream agent inherits the loss of detail.)
• summarizer_loses_critical_detail [M] — Short summary loses critical detail at token limit; long summary doesn’t compensate, context degrades over long sessions. (L1; downstream agent inherits degraded context.)

Dialectic reasoning quality

• dialectic_hallucinated_fact [M] — Dialectic claims a fact that no retrieved conclusion supports. (L1: observable in chat output.)
• dialectic_early_termination [M] — Tool loop terminates early under cost/iteration pressure; answer cites insufficient context. (L1.)
• dialectic_card_only_when_conclusions_better [L] — Dialectic answers from peer card alone when conclusions would have given a more specific answer. (L1.)

Transcript ingestion source attribution (integration-conditional)

Failure modes in this section apply only to integrations that ingest agent-side conversation transcripts directly (e.g., Hermes, SillyTavern, custom apps reading API transcripts). They are not applicable to the first-party Claude Code plugin, which filters by Claude Code hook surface — UserPromptSubmit only fires on human-typed text; tool results, slash-command payloads, and continuation summaries don’t reach Honcho through that hook. Verified against ~/.claude/plugins/cache/honcho/honcho/0.2.4/src/hooks/ 2026-04-30 (DEV-1709). The structural protection is Claude-Code-specific and depends on Claude Code’s hook semantics remaining stable.

• continuation_summary_as_fresh_input [M] — When a session continues across context resets, the resumed session’s first user message embeds the prior session’s full third-person summary (“This session is being continued from a previous conversation… The user reported a bug where…”). The deriver treats the agent’s own synthesis of the prior session as fresh first-person user content, duplicating any extraction errors from the original session and amplifying low-confidence claims into high-confidence ones. (L1: source-attribution failure at the ingestion boundary.) (Corpus evidence: 926 user_prompt rows / 483 sessions = ~8.3% of the SWE-chat English corpus. SWE-chat 2026-04-30, DEV-1709.)
• agent_synthesized_text_as_user_input [M] — Tool-result and slash-command payloads (<task-notification>, <command-name>, subagent completion reports) arrive in the API transcript as role=user rows but are agent-generated, not user voice. The deriver extracts subagent claims as user-stated facts (“the user said the security audit found 13 critical issues” — a subagent said it). Source attribution lost. (L1: source-attribution failure at the ingestion boundary; distinct from peer_third_party_attribute_confusion which is about user-mentioned third parties, and from peer_observe_others_misattribution which is about cross-peer observation policies.) (Corpus evidence: 1,227 <task-notification> rows + 1,160 <command-name> rows in SWE-chat 2026-04-30, DEV-1709.)

Deriver faithfulness

• deriver_interpret_not_extract [M] — Deriver records an interpretation rather than what was literally said. Single instance becomes stable preference. (L1.)
• deriver_no_memory_signal [M] — Deriver writes observations that don’t add signal a future agent could use about the user or their work. Memory should capture the user-and-their-work — (a) the user (identity, traits, preferences, work patterns) OR (b) the work (codebase, system architecture, stack/tools, problem domain, projects, current focus with specificity). A failed observation adds neither: speech-act paraphrase (“X confirmed with yes”), task-instructions-as-attributes (“X wants to delete Y”), momentary-state-as-preference with no specificity (“X wants a setting flipped”), conversation events (“X talked to Y” — Yuya’s narrow META_CONVERSATIONAL in excadrill/evals/auxiliary/deriver/__main__.py:163). Discriminator: would a future agent be better off with this observation in their context than without it? Pure durability would over-block legitimate transient-but-meaningful state (“user is currently debugging the payment migration”); the dual user-or-work-signal criterion handles both. Verified firing in production (5 conclusions in claude_code workspace, 2026-05-05); see honcho/tests/unified/test_cases/deriver_no_memory_signal.json. Renamed from deriver_meta_conversation_as_fact 2026-05-06. (L1.)
• deriver_sarcasm_literal [M] — Sarcasm or irony interpreted literally. (L1.)

Peer modeling / observation policies

• peer_third_party_attribute_confusion [M] — Third-party peer mentioned by user has attributes confused with user’s own. Repro: user describes Vineeth’s preferences in a multi-peer session; query user’s own preferences and assert Vineeth’s don’t bleed in. (L1.)
• peer_observe_others_misattribution [L] — observe_others=true causes a peer to incorporate agent statements as if they were the agent’s user-facing claims. Repro: multi-peer session with mixed policies; assert observation source attribution is correct. (L1.)

Cold start / long-tail

• long_history_card_bloat [L] — Very long histories cause peer card to bloat and dilute the most-recent / most-important facts. (L1; downstream agent sees the diluted card.)

Layer tally

• L1-only: 25
• L1+L2 (dual expression): 7
• L2-only: 1 (deletion_friction)
• Feature gap (not a behavioral failure of existing components): 1 (entity_name_variant_split)

Most of the catalog is testable in tests/unified at L1, even when the L2 expression is what hurts in production. Building the L2 test infrastructure (likely an Excadrill coding-agent module) is downstream work.