Foundations Grounding Communication

Grounding & Communication Foundations

Scope note — two senses of "grounding": This skill covers the Clark conversational sense: establishing shared meaning between parties (common ground, acceptance evidence, repair). It does not cover the LLM-attribution / RAG sense: whether a generated response is grounded in retrieved documents (citation faithfulness, hallucination detection). For the attribution sense, see ai-rag and the FACTS Grounding / RAGAS / Wallat et al. frameworks (sources FACTSGrounding2025, RAGAS2024, WallatFaithfulness2024 in data/sources.json).

10 canonical grounding-theory primitives for the process by which two or more parties establish enough shared understanding to coordinate. Founded by Herbert Clark and colleagues (1989, 1991, 1996), grounding theory is the most-cited formal account of how interlocutors solve the "do we mean the same thing?" problem efficiently.

It is the missing layer for multi-agent LLM systems: empirical work on multi-agent failures (MAST taxonomy, NeurIPS 2025) identifies system-design specification issues, inter-agent misalignment, and task-verification gaps across 1,600+ traces. Agents often proceed on different interpretations of the same brief. That is not only a coordination problem (information structure); it is a grounding problem (insufficient common ground at handoff). foundations-team-theory tells you whether agents should communicate; this skill tells you how they actually establish shared meaning when they do.

Static vs. dynamic grounding (2026). The distinction now carries the most diagnostic weight. Static grounding maps language to a shared context in one shot; dynamic grounding requires negotiating meaning across turns — joint plan formation, commitment, and execution. Yao, Zou, and Hawkins (2026) show the gap is not a reasoning-capacity problem: in an iterated negotiation game with verifiable jointly optimal outcomes, agents that identify Pareto-optimal allocations in isolation consistently fail to reach them as dyads, across models. Their four failure modes — loss of shared interaction history, anchoring to early proposals, defaulting to equal splits over reward-maximizing coordination, and referential binding errors across turns — map onto primitives #1, #3, #8, and #6 respectively. Most benchmarks and most agent handoff designs still test only the static case.

When to Apply

Apply grounding-theory when:

• Designing handoffs between subagents, or between a planner and an executor
• Drafting briefs, specs, or PRDs that downstream agents will interpret
• Diagnosing why a subagent did the wrong thing — was the brief grounded?
• Building human-in-the-loop confirmation flows
• Designing repair protocols ("re-ask if confidence < threshold")
• Modeling memory: what becomes part of the common ground between agent and user across sessions?
• Spec drift across long agent loops where context compresses

Skip and use simpler alternatives when:

• Single agent / no handoff — there is no second party to ground with
• The communication channel itself is the bottleneck → use foundations-information-theory (channel capacity)
• The question is whether to communicate at all → use foundations-team-theory (value of communication)
• Strategic / adversarial speech (negotiation, debate) → use foundations-game-theory
• Pure user-research methodology → use software-ux-research

Contents

• Quick Reference
• Primitive Index
• Formal Supporting Theory
• Anti-Patterns
• Decision Checklist
• Composition Recipes
• Judgment Calls
• Workflow
• ASCII Flow
• Related Skills
• Fact-Checking

Quick Reference

Full definitions, inputs, outputs, failure modes, and worked examples: references/primitives-overview.md.

Primitive Index

Formal Supporting Theory

See references/primitives-overview.md for theorem statements and a formal-vs-applied map.

Anti-Patterns

Decision Checklist

• What is already in common ground? List communal (general world knowledge) and personal (this conversation) common ground (#1)
• What is the grounding criterion for this task? High-stakes / irreversible → high; routine → low (#2)
• What is the acceptance phase? How will the recipient signal "got it"? (#3)
• What counts as evidence of understanding? Paraphrase, plan, sample output — not just "ack" (#4)
• What is the repair protocol? When and how does the recipient ask for clarification? (#5)
• Are presuppositions resolved? Every "the X" should have a recoverable antecedent (#6)
• Is the brief written for the recipient? Vocabulary, frame, abstraction level (#7)
• Is communication framed as joint action? Both parties bear responsibility for grounding (#8)
• Is total effort minimized, not speaker effort? A longer brief that prevents a repair round is cheaper (#9)
• Is grounding cost budgeted? Confirmations and repairs are not free (#10)

Composition Recipes

Brief-to-subagent handoff (the dominant failure surface)

Context: Orchestrator dispatches a subagent on a non-trivial task. MAST data makes this a primary failure surface because prompt, role, context, and stopping-condition ambiguity all appear before or during execution.

1. Audit common ground (#1): what does the subagent already know from system prompt + context vs. what does it need from this brief?
2. Set grounding criterion (#2): is this a reversible exploration or an irreversible action? Higher stakes → higher criterion.
3. Resolve presuppositions (#6): every definite reference ("the file," "the user") must have a recoverable antecedent in the prompt.
4. Apply audience design (#7): does the subagent share the orchestrator's domain shorthand? If not, expand or substitute.
5. Build the acceptance phase (#3): require the subagent to restate the goal and plan before executing. Capture this as evidence of understanding (#4).
6. Provide a repair channel (#5): an explicit "ask the user / orchestrator" tool with a low threshold for use under uncertainty. Consider preemptive repair verification: before executing irreversible actions, a Task Inference + Task Verification unit can verify alignment between observed agent plan and stated user intent (InferAct pattern, EMNLP 2025, +8% Macro-F1 over baselines across 3 tasks).
7. Compute total cost (#9, #10): brief tokens + acceptance tokens + expected repair tokens. Optimize the sum, not just brief tokens.

A2A/MCP note (2026). Agent-to-Agent (A2A, Google/Linux Foundation, 2025) and MCP standardize the transport layer for inter-agent handoffs. They do not solve the grounding layer. Yuan et al. (2026) survey 18 agent communication protocols against a three-layer taxonomy — communication (reliable transmission), syntactic (message schemas), semantic (meaning alignment) — and find most provide "limited protocol-level mechanisms for clarification, context alignment, and verification." Agents "exchange messages correctly without ensuring they understand them in the same way." Semantic responsibilities get pushed into prompts, wrappers, and orchestration logic.

Practical consequence: the grounding layer is yours to build, per-integration, until protocols carry it. An A2A task delegation carries a structured payload, but whether the receiving agent shares the sending agent's interpretation of that payload is still a Clark-layer problem: resolve presuppositions (#6), apply audience design (#7), and build an acceptance phase into the A2A response before execution begins (#3).

Worked example. Orchestrator brief v1: "Refactor the auth module." Acceptance step: subagent restates: "I'll modify the OAuth2 handler in src/auth/, preserve existing endpoints, add tests." Orchestrator notices it missed a target file — the brief should have specified src/auth/oauth2.py not the whole module. Repair: 50 tokens. Without acceptance step: subagent rewrites a different file; repair cost 5,000+ tokens. Acceptance step earned its keep.

Long-running agent context compression

Context: An agent loops for many turns; context gets compressed by the harness; common ground decays.

1. Identify what must persist in common ground vs. what is recomputable (#1).
2. Set grounding criterion (#2) higher near compression boundaries — verify shared state before acting.
3. Use repair (#5) proactively — re-establish key facts after compression rather than waiting for failure.
4. Track grounding cost (#10) — re-grounding has a token cost that competes with productive work; make it explicit in the budget.

Multi-turn agent↔agent coordination (dynamic grounding)

Context: Two agents must converge on a joint plan over several turns — negotiation, resource allocation, division of labor, peer review. Distinct from a one-shot handoff: the failure is not a bad brief but a failure to maintain and revise shared state across turns. Individually capable agents still fail as dyads here (Yao et al. 2026).

1. Externalize the shared plan (#1, #8). Do not rely on each agent's reading of the transcript — keep a single explicit joint-state object both agents read and write. Loss of shared interaction history is failure mode #1 in the negotiation data.
2. Re-bind references every turn (#6). Referential binding errors across turns are a named failure mode: "the second option," "your earlier proposal," "that split" drift as the transcript grows. Restate referents by identity, not by position in the conversation.
3. Force explicit commitment steps (#3, #8). Distinguish "I am exploring X" from "I commit to X." Anchoring to early proposals is a named failure mode — untagged exploratory proposals get treated as commitments by the other side.
4. Watch for the fairness default (#2). Agents default to equal splits over reward-maximizing coordination. If the jointly optimal outcome is asymmetric, state that explicitly; symmetric-looking compromises are a grounding failure wearing the costume of a reasonable outcome.
5. Verify convergence, don't assume it (#4). Ask each agent independently to state the agreed plan. Agreement in the transcript is not agreement in their models.

Human-AI handoff at end of agent run

Context: Agent finishes work and hands back to user.

1. Apply audience design (#7) — the user is not the agent; vocabulary, abstraction, and salient evidence differ.
2. Provide explicit evidence of work (#4) — what changed, what was decided, what wasn't done. Not "ack."
3. Joint commitment (#8) — frame handoff as "here's what I did and why; please verify or redirect," not "task complete."
4. Pre-empt repair (#5) — call out specific points where the user's intent might have been misread.

Chatbot / conversational app — grounding acts in the UX layer

Context: Building a user-facing chatbot or AI assistant where misunderstanding or low clarification rate degrades experience. Empirical baseline: production LLMs clarify 3× less and follow up 16× less than human conversational partners (Rifts, ACL 2025), so the app must compensate structurally.

1. Audit personal common ground (#1) at session start — what does the system know about this user from prior sessions, profile, or context? Surface it explicitly rather than silently assuming it.
2. Set grounding criterion (#2) per intent type: high-stakes intent (booking, purchase, delete) → require restatement before acting; low-stakes (lookup, draft) → accept acknowledgment.
3. Design clarification UX to reward repair (#5): inline "Did you mean X or Y?" affordances lower the social cost of asking; agents trained on completion metrics suppress asking by default.
4. Apply audience design (#7): detect domain shorthand in user input and reflect back in the user's vocabulary, not internal API terminology.
5. Build a friction-detection signal (#1, #5): track turns where the user corrects or restates — high friction rates indicate common-ground gaps in the system prompt or prior bot turn, not user error.

Judgment Calls

Diagnosing grounding failure in a live team or product

A non-expert sees the symptom (wrong output, an angry user, a broken deploy) and reaches for a technical root cause. An expert triages the grounding layer first, because three failure signatures recur across very different systems and each has a distinct fix — and each has a cheap leading indicator that's easy to miss because the system looks fine on its face until the cost is already sunk.

When explicit verification protocols beat implicit grounding

Explicit protocols (restate-and-confirm, structured acceptance, mandatory paraphrase) cost tokens, time, and social friction on every interaction. Implicit grounding (proceed on inferred understanding, correct if wrong) costs nothing until it's wrong, then costs a lot. The judgment call is not "always verify" or "never verify" — it's pricing the crossover for a given interaction class, set deliberately once rather than improvised per instance.

Reach for explicit verification when: the action is irreversible or expensive to undo (deploys, sends, payments, deletes); personal common ground is low (new user, new subagent, session start, just after context compression); the medium has expensive repair (async, high-latency, no real-time interrupt — batch jobs, cross-team handoffs, long agent loops); or errors are silent by default — the system won't surface a wrong interpretation on its own, it will just produce plausible-looking wrong output.

Stay with implicit grounding when: the action is cheap to reverse and errors surface immediately (exploratory reads, drafts, low-stakes lookups); personal common ground is already rich (many prior turns validated the shared model); the medium has cheap repair (synchronous chat, pair programming, a fast interrupt path); or over-verifying has a real cost of its own — added friction lowers the rate at which people or agents initiate contact at all, which can be a bigger loss than the occasional repair.

The trap runs both directions. Defaulting to implicit because verification "feels slow" is the dominant failure in agent design (see Composition Recipes above). Defaulting to explicit-everywhere is the dominant failure in enterprise process design — approval theater that produces acknowledgment-without-understanding rather than real grounding, because the gate checks for a signature, not a restatement.

Least collaborative effort as a UX and agent-design lens

Least collaborative effort (#9) is usually read as a dialogue-efficiency principle. Applied to product and agent design, it reframes a common local optimization as a false economy:

• UX: a form that asks fewer questions up front (minimizing the user's effort) but generates ambiguous submissions that support has to chase down later is not efficient — it moved cost from the user to a more expensive party. The efficient design asks the two or three questions whose absence would otherwise cost a support ticket.
• Agent design: a terse system prompt that saves orchestrator tokens but forces the subagent to guess, and the user to catch the guess later, is the same error. Price total expected cost (brief + acceptance + p(failure) × repair) before trimming a brief for length.
• The diagnostic in both cases: ask "whose effort did this design minimize, and whose did it defer?" If the answer is "the party who assembles the request, at the expense of whoever has to interpret or fix it," least collaborative effort was optimized one-sidedly — regardless of how efficient the interface looks in isolation.

Workflow

1. Identify the handoff or communication boundary (subagent dispatch, user→agent, agent→user, agent→agent).
2. Audit common ground (#1) at that boundary.
3. Set the grounding criterion (#2) appropriate to the stakes.
4. Resolve presuppositions (#6) and apply audience design (#7) to the message.
5. Design the acceptance phase (#3) and the evidence of understanding (#4).
6. Build a repair channel (#5).
7. Cost it (#9, #10) — verify total expected cost is below the no-grounding alternative.

ASCII Flow

Communication or handoff boundary
  -> Identify participants, task, stakes, and current common ground
  -> Choose grounding criterion for the risk level
  -> Design presentation and acceptance evidence
  -> Resolve presuppositions and audience mismatch
     +-- misunderstanding detected -> repair and re-confirm
     +-- understanding evidenced -> proceed
  -> Cost grounding overhead against failure cost

Navigation

• Domain-agnostic primitives overview: references/primitives-overview.md
• Formal theory map and production boundaries: references/formal-theory-map.md
• Patterns, scenarios, and traps for multi-agent / subagent handoffs: references/patterns-scenarios-traps.md
• Sources: data/sources.json

Related Skills

• foundations-team-theory — whether to communicate; this skill is how
• foundations-information-theory — channel capacity, information cost in bits/tokens
• foundations-game-theory — strategic communication, debate, signaling under conflict
• foundations-decision-theory — value of information at the single-agent level
• agents-subagents — applied subagent patterns
• docs-ai-prd — applied: PRDs and specs as grounding artifacts for coding agents
• ai-prompt-engineering — applied: prompts as grounding artifacts
• software-ux-research — adjacent: user-research methods for human-side grounding

Fact-Checking

• Clark and Brennan (1991) "Grounding in Communication." In Perspectives on Socially Shared Cognition (APA). Canonical paper for primitives #1–#5, #10.
• Clark (1996) Using Language. Cambridge University Press. Book-length treatment; primary source for #3, #8, #9.
• Clark and Schaefer (1989) "Contributing to Discourse." Cognitive Science 13. Presentation + acceptance phases.
• Grice (1975) "Logic and Conversation." In Syntax and Semantics 3. Foundation for presupposition and implicature (#6).
• Schegloff, Jefferson, and Sacks (1977) "The Preference for Self-Correction in the Organization of Repair." Language 53(2). Repair sequences (#5).
• Bell (1984) "Language Style as Audience Design." Language in Society 13. Audience design (#7).
• Cemri et al. (2025) "Why Do Multi-Agent LLM Systems Fail?" (MAST). NeurIPS. Empirical anchor for system-design, inter-agent misalignment, and task-verification failures across 1,600+ traces.
• Shaikh, Gligorić, Khetan, Gerstgrasser, Yang, Jurafsky (2024) "Grounding Gaps in Language Model Generations." NAACL-HLT 2024 (ACL Anthology 2024.naacl-long.348). Coined "presumptive grounders" — LLMs assume common ground rather than using grounding acts. Found that RLHF/preference training reduces grounding acts. Predecessor paper to Rifts 2025 (same first author). Supports #4, #5.
• Shaikh et al. (2025) "Navigating Rifts in Human-LLM Grounding." ACL 2025. Rifts benchmark. LLMs clarify 3× and follow up 16× less than humans. Supports #4, #5.
• Spangher et al. (2025) "NewsInterview." ACL 2025. 45,848-interview corpus; LLM acknowledgement rate ~0% vs human ~9%. Supports #4, #7.
• Sarkar et al. (2025) "Understanding Common Ground Misalignment." ACL 2025. Ubuntu-CG: 200 conversations, 7,590 turns; friction correlates with task failure; LLM friction detection 77.22% (overt) / 64.81% (implicit) F1. Supports #1, #5.
• Fang, Zhu, Gurevych (2025) "Preemptive Detection and Correction of Misaligned Actions." EMNLP 2025, pp. 222–244. InferAct: +8% avg Macro-F1, 11/12 settings best across 3 tasks × 4 LLMs. Extends #5.
• Estienne et al. (2025) "Collaborative Rational Speech Act." EMNLP 2025. CRSA extends RSA to multi-turn with private meaning spaces; speaker entropy 8.18 vs 14.27 baseline on medical dialogue. Grounds #8, #9.
• Yao, Zou, Hawkins (2026) "Talk is Cheap, Communication is Hard: Dynamic Grounding Failures and Repair in Multi-Agent Negotiation." arXiv 2605.01750. Iterated negotiation game with verifiable jointly optimal outcomes; agents solve in isolation but dyads fail across models; four named failure modes. Static-vs-dynamic grounding distinction. Preprint — no peer review confirmed.
• Poelitz, Doshi-Velez, Lindley (2026) "A Benchmark to Assess Common Ground in Human-AI Collaboration." arXiv 2602.21337. 40-participant Helper/Worker puzzle task, 2×2 design; measures task, object, and communication levels. AI Helpers show minimal efficiency gain across trials where humans improve; joint vocabulary shrinks; models fail to update assumptions after repair. Preprint — no peer review confirmed.
• Yuan et al. (2026) "Beyond Message Passing: A Semantic View of Agent Communication Protocols." arXiv 2604.02369. Surveys 18 protocols (MCP, A2A, Agora, ACP variants) against a communication/syntactic/semantic taxonomy; cites Clark's joint-activity framing to motivate the semantic layer. Preprint — no peer review confirmed.
• Moore, An, Ahmed, Gala (2026) "NC-Bench: An LLM Benchmark for Evaluating Conversational Competence." arXiv 2601.06426. 14 interaction patterns, 720 test cases, 6 open-source models (2–8B, Granite/Llama/Qwen). Repair (repeat) 5–75% vs answering 95–100%. Small-model sample — do not generalize the rates to frontier models; the ordering (repair weakest) is the transferable finding.
• Empirical numbers (e.g., MAST percentages, Rifts rates, NC-Bench accuracies) are dataset- and model-specific. Re-verify against your own production traces before treating as priors. The four 2026 entries above are arXiv preprints; the Clark canonical layer and the ACL/EMNLP 2025 layer are peer-reviewed.

Learnings Loop

Before applying this skill on a non-trivial task, read learnings.consolidated.md in this directory (and learnings.md if present).

After applying it, if you encountered a pattern worth remembering, a mistake worth preventing, or a domain fact that surprised you, append one dated bullet to learnings.md via agents-skills-feedback-loop/scripts/append_learning.py. Do not modify SKILL.md itself.