coordinate-reasoning

coordinate-reasoning is a skill for Claude Code from pjt222/agent-almanac. It costs 90 tokens per session (3,031 once invoked), scanned A, original, MIT.

A guide to keeping information coordinated during complex reasoning and multi-step coding work. It treats notes and context as information that can become stale or lose relevance over time.

In plain words
What is it for?
Use it to track task dependencies, assess information freshness, and organize shared notes during refactoring or other multi-file work.
Why use it?
It helps maintain reliable links between subtasks and carry important decisions forward when a task becomes long or context is compressed.

Skill for Claude Code

Written for Claude Code: allowed-tools in frontmatter. Also seen: mentions CLAUDE.md.

Part of the agent-almanac plugin — 122 skills, 76 agents shipped together

Good fit Use it to track task dependencies, assess information freshness, and organize shared notes during refactoring or other multi-file work.

Compare 6 skills from other repositories ↓
Install with agentmods
npx agentmods add skills/pjt222/agent-almanac/coordinate-reasoning
Install

Getting it into your agent

One page per mod, every tool's command on it. A separate URL per tool would split the same page into five that compete with each other.

Any agent
npx skills add pjt222/agent-almanac --skill coordinate-reasoning
Clone the repo
git clone --depth 1 https://github.com/pjt222/agent-almanac

Made for: Claude Code.

Or install agent-almanac, the plugin that ships this one along with the rest of its 122 skills, 76 agents.

Wrote this? Show the measurements

A badge with what this costs and how it scanned, read live from this page, so it follows the numbers instead of freezing them. Markdown for a README, HTML for a documentation site or a project page.

agentmods badge for coordinate-reasoning

README.md
[![agentmods](https://agentmods.dev/badge/skills/pjt222/agent-almanac/coordinate-reasoning/github.svg)](https://agentmods.dev/skills/pjt222/agent-almanac/coordinate-reasoning)
Your own site
<a href="https://agentmods.dev/skills/pjt222/agent-almanac/coordinate-reasoning"><img src="https://agentmods.dev/badge/skills/pjt222/agent-almanac/coordinate-reasoning/github.svg" alt="Measured on agentmods" height="20"></a>

Or the 80×15 button, for a site that already has a row of RSS and ATOM ones. Only the verdict fits; the numbers stay here.

agentmods 80×15 button for coordinate-reasoning

Your own site · 80×15
<a href="https://agentmods.dev/skills/pjt222/agent-almanac/coordinate-reasoning"><img src="https://agentmods.dev/badge/skills/pjt222/agent-almanac/coordinate-reasoning.svg" alt="Reviewed on agentmods" width="80" height="20"></a>
Per session 90 Skills are progressive disclosure: only the name and description are preloaded; the body loads when the skill is used.
When invoked 3,031 The whole file, excluding the scripts and references it only reads on demand.
Security scan A 0 findings. A grade says what 26 rules found in the file — not that it is safe. Third-party audits
  • NVIDIA SkillSpector pass 7 Sept 2026
How audits are shown
Origin original No closer match found in the catalogue.
Token cost

What it costs to keep this loaded

Counted locally with the o200k_base tokenizer, which is exact for GPT models; Claude uses its own tokenizer and its counts differ. Treat this as one consistent yardstick across the catalogue rather than a bill. Prices are per million input tokens.

ModelPer sessionOnce invoked
Fable 5.1 $0.00090 $0.03031
Opus 5 $0.00045 $0.01515
Sonnet 5 $0.00018 $0.00606
Haiku 4.5 $0.00009 $0.00303

Measured 6d ago against content hash 4f2bb6e25088, method: parsed. Prices are Anthropic first-party input rates as of 2026-09-09, from the pricing page.

Security

Grade A, and why

coordinate-reasoning scanned grade A with 0 findings against 26 rules in 11 categories — prompt injection, anti-refusal, data exfiltration, privilege escalation, supply chain, agent snooping, system-prompt leakage, SSRF and excessive agency — measured 6d ago.

A static scan of the body, not an audit. Every finding is printed with the line that produced it so you can judge whether it matters here. A mod is markdown that instructs an agent; that is exactly why what it instructs is worth reading.

Nothing flagged

None of the 26 patterns this scan looks for appear in this file: no shell pipes, no recursive deletes, no credential paths, no hidden text, no instruction-override or anti-refusal phrasing, no agent-config snooping. That is not a guarantee, it is the absence of the things that are checkable.

i18n/caveman-lite/skills/coordinate-reasoning/SKILL.md · 245 lines

How it starts

The opening of the file, as written. The whole thing — 245 lines — stays where its author put it; the contents beside it link to each section on GitHub.

Coordinate Reasoning

Manage the internal coordination of reasoning processes using stigmergic principles — treating context as an environment where information signals have freshness, decay rates, and interaction rules that produce coherent behavior from simple local protocols.

When to Use

  • During complex tasks where multiple sub-tasks must coordinate (multi-file edits, multi-step refactoring)
  • When context has grown long and information freshness is uncertain
  • After context compression when some information may have been lost
  • When sub-task outputs need to feed into each other cleanly
  • When earlier reasoning results need to be carried forward without degradation
  • Complementing forage-solutions (exploration) and build-coherence (decision) with execution coordination

Inputs

  • Required: Current task decomposition (what sub-tasks exist and how do they relate?)
  • Optional: Known information freshness concerns (e.g., "I read that file 20 messages ago")
  • Optional: Sub-task dependency map (which sub-tasks feed into which?)
  • Optional: Available coordination tools (MEMORY.md, task list, inline notes)

Procedure

Step 1: Classify the Coordination Problem

Different coordination challenges require different signal designs.

AI Coordination Problem Types:
┌─────────────────────┬──────────────────────────────────────────────────┐
│ Type                │ Characteristics                                  │
├─────────────────────┼──────────────────────────────────────────────────┤
│ Foraging            │ Multiple independent searches running in         │
│ (scattered search)  │ parallel or sequence. Coordination need: share   │
│                     │ findings, avoid duplicate work, converge on      │
│                     │ best trail                                       │
├─────────────────────┼──────────────────────────────────────────────────┤
│ Consensus           │ Multiple approaches evaluated, one must be       │
│ (competing paths)   │ selected. Coordination need: independent         │
│                     │ evaluation, unbiased comparison, commitment      │
├─────────────────────┼──────────────────────────────────────────────────┤
│ Construction        │ Building a complex output incrementally (multi-  │
│ (incremental build) │ file edit, long document). Coordination need:    │
│                     │ consistency across parts, progress tracking,     │
│                     │ dependency ordering                              │
├─────────────────────┼──────────────────────────────────────────────────┤
│ Defense             │ Maintaining quality under pressure (tight time,  │
│ (quality under      │ complex requirements). Coordination need:        │
│ pressure)           │ monitoring for errors, rapid correction,         │
│                     │ awareness of degradation                         │
├─────────────────────┼──────────────────────────────────────────────────┤
│ Division of labor   │ Task decomposed into sub-tasks with              │
│ (sub-task mgmt)     │ dependencies. Coordination need: ordering,       │
│                     │ handoff, result integration                      │
└─────────────────────┴──────────────────────────────────────────────────┘

Read the full file on GitHub · 245 lines

Changes

What this file has done since we first saw it

Hashed on every crawl. A supply-chain change to an agent config is a question of when, not whether, so the history is kept rather than the latest state alone.

  1. 6d ago First seen · 245 lines · 90 tokens per session scan A 4f2bb6e25088

Subscribe to this mod's changes

coordinate-reasoning is a skill published in the GitHub repository pjt222/agent-almanac (32 stars, last pushed yesterday), licensed MIT. It adds 90 tokens to every session and 3,031 once invoked, about $0.0005 per session on Opus 5. A static security scan graded it A with 0 findings. No closer match exists in the catalogue, so it is treated as the original; first seen 2026-09-03.

Related

Other skills, from other repositories

log-session

Append a structured entry to the project's session log (docs/LOGS.md): what was done this session, files touched, decisions taken, and the next step — so the next session (or another person) can pick up the thread without re-reading git history. Run it before /clear, before closing Claude Code, or at any natural…

gtrabanco/agentic-workflow · 183 tokens

cocoscout

Relevance-ranked context loading — Tier 2 async subagent (Haiku, <5s) that fires after Tier 1 deterministic checks in UserPromptSubmit. Injects ranked context from CocoGrove, CocoContext, Environment Inspector, Prompt Studio, and CocoDream.

Snowflake-Labs/cocoplus · 59 tokens

cocohealth

Context utilization monitor — background monitor that samples context window utilization via PostToolUse hook, surfaces advisory at 60% and critical warning with recovery decision matrix at 70%.

Snowflake-Labs/cocoplus · 38 tokens

pull-search

CocoPull session archive search — full-text search across past sessions. Handles $pull search " " with --since and --feature filters, and $pull index rebuild.

Snowflake-Labs/cocoplus · 38 tokens

pod-kb

Display the project knowledge base (lifecycle/kb.md) — project-specific patterns, decisions, and gotchas accumulated by CocoCupper across sessions.

Snowflake-Labs/cocoplus · 33 tokens

pod-resume

Reconstruct context for a returning developer. Reads .cocoplus/ state and generates a narrative summary of project status, last achievements, pending tasks, recent decisions, available patterns, CocoCupper insights, and recommended next action.

Snowflake-Labs/cocoplus · 50 tokens