foundations-grounding-communication

name	foundations-grounding-communication
description	Grounding-theory primitives for human-AI and agent handoffs, common ground, acceptance evidence, repair, and ambiguity. Use when coordinating meaning.
compatibility	Portable core only.
version	1.2
last_validated	2026-08-14T00:00:00.000Z

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

#	Primitive	When to Reach For It
1	Common Ground	Audit what each party already shares before drafting any handoff
2	Grounding Criterion	"Grounded enough for what?" — set the bar before designing the protocol
3	Contributions: Presentation + Acceptance	Decompose a message into the two-step joint act it actually is
4	Evidence of Understanding	Design the explicit/implicit signals that close the loop
5	Repair	Plan how misunderstandings get caught and fixed
6	Presupposition	Audit what the message assumes its audience already knows
7	Audience Design	Match the brief to who will read it (not who wrote it)
8	Joint Commitment	Treat communication as joint action, not unilateral signal
9	Least Collaborative Effort	Optimize total effort across both parties, not just speaker effort
10	Grounding Cost / Tracks	Price the meta-channel — confirmations and repairs cost too

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

---

Primitive Index

#	Primitive	Failure Mode It Addresses
1	Common Ground	Treating "in the system prompt" as "shared with the agent" — common ground is what's believed mutual, not just present
2	Grounding Criterion	Over-grounding (excess confirmation overhead) or under-grounding (acting on uncertain interpretation)
3	Contributions: Presentation + Acceptance	"I sent the message, so we're done" — communication isn't complete until acceptance is signaled
4	Evidence of Understanding	Acknowledgment vs. understanding conflated; "ack" doesn't mean "got it". LLMs emit 3× fewer clarification initiations and 16× fewer follow-ups than humans (Rifts, ACL 2025); benchmark: aclanthology.org/2025.acl-long.1016/
5	Repair	Errors compound silently because no repair protocol exists; agent acts on misinterpretation. LLMs fail to initiate repair-seeking acts at comparable human rates; early repair failures predict compounding breakdown (Rifts, ACL 2025). Repair is the weakest measured conversational competence: 5–75% accuracy on repeat requests vs 95–100% on plain answering (NC-Bench, 2026). Models also fail to update assumptions after a repair completes (Poelitz et al. 2026) — the repair lands but common ground doesn't move
6	Presupposition	Brief assumes context the recipient doesn't have; MAST-style specification failures live here
7	Audience Design	Brief written for the writer, not the reader; tokens spent on wrong abstractions. LLMs fail to pivot to audience-state-informed questions, instead repeating similar follow-ups (NewsInterview, ACL 2025)
8	Joint Commitment	Handoff treated as transmission rather than joint coordination. CRSA (EMNLP 2025) formalizes this: joint task distribution P(m_A,m_B,y) captures what both agents know about outcomes — a formal model of the mutual-obligation structure joint commitment requires
9	Least Collaborative Effort	One-sided optimization — fewer tokens for the speaker, more confusion for the listener. CRSA's gain function minimizes total communication effort across both agents over the full dialogue history — the formal analogue of least collaborative effort for multi-turn settings
10	Grounding Cost / Tracks	Confirmation/repair overhead ignored when budgeting communication

---

Formal Supporting Theory

Theory Area	Use When	Applied Primitives It Grounds
Clark & Brennan grounding theory	Design handoff/confirmation protocols	#1, #2, #3, #4, #10
Gricean implicature / pragmatics	Account for what is meant beyond what is said	#6, #7
Conversation analysis (Sacks, Schegloff)	Repair sequences, turn-taking, adjacency pairs; Ubuntu-CG (Sarkar et al., ACL 2025) provides first real-world empirical validation: friction (failed repair initiation) predicts task failure; current LLMs detect implicit friction poorly (64.81% F1)	#5
Joint action theory	Frame communication as coordinated activity, not message-passing	#8, #9
Collaborative RSA (CRSA)	Multi-turn dialogue where agents hold private information and must converge on shared outcomes	#8, #9
Dynamic grounding (Yao et al. 2026)	Coordination spans many turns and joint plans must be formed, committed to, and executed — not just interpreted once	#1, #3, #6, #8
Protocol semantic layer (Yuan et al. 2026)	Deciding what the transport protocol gives you vs. what you must build; 18-protocol survey against communication/syntactic/semantic layers	#3, #5, #6
Common-knowledge logic (Aumann, Lewis)	Need formal model of what is mutual belief	#1
Audience design (Bell, Clark & Murphy)	Tailor message to recipient	#7

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

---

Anti-Patterns

Anti-Pattern	Grounding Theory Diagnosis	Fix
"I put it in the system prompt, so the agent knows"	Common ground (#1) confused with content delivery; presence ≠ mutual belief	Verify common ground via grounded probe (ask the agent to summarize before acting). Detect friction as operational signal of CG misalignment — 61% of real conversations contain friction; successful conversations show significantly lower rates (Ubuntu-CG, ACL 2025)
Subagent acts immediately on first reading of the brief	Grounding criterion (#2) set to zero; no acceptance phase	Build acceptance into the protocol — agent restates intent before executing
User says "ok" / agent emits "ack" — taken as confirmation of understanding	Evidence of understanding (#4) confuses acknowledgment with comprehension	Require active evidence: paraphrase, plan, or worked example, not just acknowledgment. (Empirical: LLMs produce near-zero acknowledgement statements (~0%) vs ~9% in human dialogue — NewsInterview, ACL 2025)
No mechanism for "wait, I don't understand" once a task starts	Repair (#5) channel missing; errors compound	Provide explicit "ask for clarification" tool; reward its use when uncertainty is high. For irreversible actions, preemptive verification (infer task from action sequence, check against user intent) outperforms reactive repair (InferAct, EMNLP 2025)
Repair happens, but the agent proceeds on its pre-repair assumptions	Repair (#5) treated as an utterance rather than a common-ground update; the correction is acknowledged and then not propagated	After a correction, require restatement of the revised shared state, not of the correction. Empirically LLM collaborators fail to update assumptions post-repair, and their joint vocabulary with a partner shrinks rather than grows over trials (Poelitz et al. 2026)
Brief mentions "the dashboard" without antecedent	Presupposition (#6) failed; agent fills in wrong referent	Audit briefs for definite references; resolve antecedents before handoff
Brief written in domain shorthand the recipient doesn't share; LLMs repeat similar follow-ups rather than pivoting to audience-state-informed questions	Audience design (#7) failed; speaker-centric, listener state untracked	Rewrite for the recipient's vocabulary; check by having a peer (or different agent) read it cold
Handoff treated as fire-and-forget	Joint commitment (#8) violated; communication framed as transmission	Wait for acceptance signal before considering the handoff complete

---

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.

Signature	What it looks like	Distinguishing test	Fix
Silent misalignment	Two parties (human-human, human-agent, agent-agent) proceed for many turns or steps before anyone notices they meant different things — no error is ever raised, only a late, expensive divergence	Ask each party independently to state the current shared goal in one sentence. If they diverge and neither noticed, this is it	Scheduled, low-cost restatement checkpoints — don't wait for a symptom; under this failure mode there won't be one until the cost is sunk (#1, #2)
Acknowledgment-without-understanding	"LGTM," "sounds good," "ack," a rubber-stamp code review, a nodding stakeholder — social or procedural closure is mistaken for grounding	Ask the acknowledger to act on or restate the specific content, not just approve it. If they can't, the "ack" was backchannel, not evidence (#3, #4)	Replace approval gates with restatement or demonstration gates on anything irreversible; "approved" and "understood" are different claims — don't conflate them
Costly-repair spiral	A misunderstanding surfaces, gets "fixed," but the fix itself wasn't grounded either — repair attempts compound rather than converge, each round costing more than the last	Track repair-round cost (tokens, time, trust) over the incident. If it's rising rather than falling, the repair channel itself lacks an acceptance phase	Ground the repair the same way you'd ground the original contribution — restate the correction, get explicit acceptance, before the next attempt (#3, #5, #9)

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.

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.