Agent skill

State Management

by Owl-Listener in Owl-Listener/ai-design-skills

Managing shared context, memory, and state across multiple agents.

MITAuto-check passedFrontend & Design

Install State Management

skills CLI
$ npx skills add Owl-Listener/ai-design-skills --skill state-management -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install Owl-Listener/ai-design-skills state-management --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/Owl-Listener/ai-design-skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/design-agent-orchestration/state-management .claude/skills/state-management && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
state-management
GitHub stars
185
Token cost
~1.5k tokens
SKILL.md length
717 words
Files
1
Skills in repo
11
Repo updated
First seen
Licence
MIT

At a glance

Managing shared context, memory, and state across multiple agents.

  • Tasks that involve State management
  • SKILL.md covers Types of state, State architecture patterns, Designing state for users and Decision rules, plus 4 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md
  • Tasks that involve Multi-agent orchestration

What it does

State Management is an agent skill from Owl-Listener/ai-design-skills. Managing shared context, memory, and state across multiple agents.

Its SKILL.md is about 1.5k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in Frontend & Design, covering State management and Multi-agent orchestration. The repository describes itself as: AI Design Skills Collection: agentic skills, commands, and plugins for designing AI products — from interaction patterns to alignment, evaluation, agent orchestration, and prompt… The licence is MIT.

When your agent uses it

  • Tasks that involve State management
  • Tasks that involve Multi-agent orchestration

Example prompts

  • “/state-management”

What it can do on your machine

Read from SKILL.md and the folder at commit f41b650. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md.

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

State Management loads about 1.5k tokens when it runs. Until then it costs about 21 tokens; SKILL.md has 717 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~21
When it runs · the whole SKILL.md, loaded when a task matches
~1.5k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from Owl-Listener/ai-design-skills at commit f41b650, republished under its MIT licence (© Owl-Listener). 717 words, ~1,537 tokens.

Download SKILL.mdSave it as .claude/skills/state-management/SKILL.md (or your agent's skills folder).
name
state-management
description
Managing shared context, memory, and state across multiple agents.

State Management

In a multi-agent system, state is the shared truth about what's happened, what's in progress, and what's been decided. Without state management, agents work with stale or conflicting information — and the user pays the cost in repeated questions, contradictory answers, and lost progress.

State management is the plumbing skill of multi-agent design. Get it wrong and every other skill in this plugin gets harder.

Types of state

  • Task state: where the overall task is in its lifecycle. Which subtasks are complete, in progress, or pending.
  • Context state: what each agent knows. What has been shared, summarised, or dropped.
  • User state: preferences, history, and current emotional state.
  • Decision state: decisions made, options considered, options rejected (and why).
  • Error state: what has failed, been retried, been escalated.

State architecture patterns

  • Centralised state: one shared store all agents read from and write to. Simple, debuggable. Bottleneck risk at scale.
  • Distributed state: each agent maintains its own state and syncs with others. Flexible. Consistency risk.
  • Event-sourced state: state is built from a log of events. Every change is recorded. Auditable. Complex.
  • Blackboard pattern: shared workspace where agents post results and read others' contributions. Good for collaborative problem-solving.

Designing state for users

Users have expectations about what the system remembers:

  • Within-session state: everything said in this conversation should persist consistently
  • Cross-session state: preferences, decisions, and context from past sessions should carry forward
  • Cross-agent state: if one agent learned something, other agents should know
  • User-controlled state: users should be able to see, edit, and clear what the system remembers

Decision rules

  • Default to centralised state. Reach for distributed only when measured cross-agent latency is genuinely the bottleneck. Most teams choose distributed prematurely and pay in consistency bugs forever.
  • If a piece of state lives in a single agent's working memory, treat it as lost. Memory across model invocations is unreliable; promote anything that needs to persist to the shared store.
  • Cross-session state requires explicit consent per category. "Remember preferences" ≠ "remember what we discussed". Granularity is the design constraint, not a nice-to-have.
  • For state conflicts, prefer detection over silent merging. A surfaced conflict the user resolves is recoverable; a silently merged inconsistency is invisible damage.
  • State a user can't see, they can't trust. Any state used to personalise behaviour must be visible somewhere the user can find within ~30 s of UI navigation.
Show full SKILL.md (329 more words)Show less

Anti-patterns

  • The stale-context bug: an agent acts on state that's been superseded by another agent. Hard to detect because the agent looks correct in isolation. Mitigated by versioning every read.
  • The one-source-of-truth fight: two agents both claim authority over the same state slice. Resolution rules are vague. Last write wins, intermittently.
  • Implicit state: state lives in an agent's prompt context rather than the shared store. Lost on restart, untransferable, undebuggable.
  • State sprawl: schema grows unbounded as features accrete. After six months nobody knows what's used, what's dead, or what's load-bearing.
  • Sync deferral: writes are batched for efficiency, then dropped on failure. The user sees "saved" but the state never made it.
  • Invisible personalisation: state shapes behaviour the user can't see or override — drift toward manipulation.

When not to use this

  • Single-agent products — the model's context window is the state. Reach for context-window-design instead.
  • Stateless transactional features (one-shot completions, image generation calls) — explicit state architecture adds overhead without benefit.
  • Prototype phase — premature state architecture freezes choices that should still be loose. Use the simplest possible store, document decisions in decision-state only.

See also

  • handoff-protocols — context transfer between agents uses the state architecture; design them together.
  • observability-design — state mutations are the most useful traces. Design what's logged at the same time as what's stored.
  • consent-and-agency — cross-session and cross-agent state is consent-laden by default.
  • task-decomposition — task-state schema is determined by the decomposition shape; co-design.

Design Artefacts

  • State architecture diagrams (centralised / distributed / event-sourced / blackboard)
  • State schema definitions (what's stored, where, by whom, with what TTL)
  • State lifecycle specifications (creation, update, archival, deletion)
  • Conflict resolution rules per state slice
  • User-facing state visibility and control designs

Worked example — task state for a multi-agent customer support flow:

{
  "task_id": "tk_8b2",
  "owner_agent": "router",                  // who currently holds the task
  "status": "in_progress | escalated | done",
  "subtasks": [
    {"id": "verify_account", "status": "done", "result_ref": "ctx_a91"},
    {"id": "check_refund_eligibility", "status": "in_progress", "owner": "billing_agent"}
  ],
  "user_state_ref": "us_482",               // pointer, not embedded copy
  "decisions": [
    {"at": "...", "by": "router", "choice": "billing_agent", "rejected": ["faq_agent"], "why": "intent: refund"}
  ],
  "errors": [],
  "version": 7                              // increments on every write; readers check before acting
}

The version field is the simplest defence against the stale-context bug. The decisions log with rejected makes the routing legible to humans during incident review.

Adapted from work on shared mental models in multi-agent systems and distributed-systems consistency literature (Lamport on logical clocks; the actor model on isolated state).

© Owl-Listener, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in skills/design-agent-orchestration/state-management of Owl-Listener/ai-design-skills.

Open the folder on GitHubat commit f41b650

Compare with similar skills

State Management next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

State Management compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
State Management this skillOwl-Listener/ai-design-skills185—~1.5kAutomated safety check: PassMIT
Agent Workflow Designerborghei/Claude-Skills891—~2.3kAutomated safety check: PassMIT
Onboardingagentuse/agentuse205—~928Automated safety check: PassCustom licence
Agentic Osaffaan-m/ECC276k1 repos~3.1kAutomated safety check: NotesMIT
React Generate Skilljiushiwon/wg-skills114—~2.8kAutomated safety check: PassApache-2.0
Agent Collaboration ProtocolLeoYeAI/openclaw-master-skills2.2k—~1.1kAutomated safety check: PassMIT

Similar skills

  • Agent Workflow Designer

    borghei/Claude-Skills

    Design multi-agent orchestration with workflow DAGs, routing, handoff protocols, and state management.

    891 GitHub stars~2.3k tokensUpdated 2 days ago
    Agent WorkflowsAuto-check passed
  • Onboarding

    agentuse/agentuse

    Guide a new AgentUse user from a confirmed project to one validated first agent and its first CLI or Web UI run.

    205 GitHub stars~928 tokensUpdated 3 days ago
    Frontend & DesignAuto-check passed
  • Agentic Os

    affaan-m/ECC

    Build persistent multi-agent operating systems on Claude Code.

    276k GitHub starsUsed in 1 repo~3.1k tokens
    Agent WorkflowsAuto-check: notes
  • React Generate Skill

    jiushiwon/wg-skills

    This skill should be used when the user wants to create a standardized React 18 + TypeScript + Vite + Zustand project from scratch.

    114 GitHub stars~2.8k tokensUpdated 3 days ago
    Frontend & DesignAuto-check passed
  • Agent Collaboration Protocol

    LeoYeAI/openclaw-master-skills

    Structured multi-agent collaboration for backend + frontend builds.

    2.2k GitHub stars~1.1k tokensUpdated 2 mo ago
    Frontend & DesignAuto-check passed
  • UI Agent Patterns

    HermeticOrmus/LibreUIUX-Claude-Code

    Patterns for delegating UI work to agents: one synthesis agent versus specialized agents, multi-agent pipelines for research, design, implementation, and review, and clean handoffs between them.

    112 GitHub stars~4.6k tokensUpdated 5 days ago
    Frontend & DesignAuto-check passed

More from Owl-Listener/ai-design-skills

All 11 skills in this repo
  • Few Shot Patterns

    Owl-Listener/ai-design-skills

    Crafting examples that steer AI behavior effectively. An agent skill from Owl-Listener/ai-design-skills.

    185 GitHub stars~723 tokensUpdated 4 mo ago
    Auto-check passed
  • Agent Role Design

    Owl-Listener/ai-design-skills

    Defining what each agent does, knows, and owns in a multi-agent system.

    185 GitHub stars~658 tokensUpdated 4 mo ago
    Auto-check passed
  • Behavioral Consistency

    Owl-Listener/ai-design-skills

    Ensuring the AI behaves predictably across sessions, edge cases, and modalities.

    185 GitHub stars~568 tokensUpdated 4 mo ago
    Auto-check passed
  • Bias Detection Design

    Owl-Listener/ai-design-skills

    Designing review workflows to surface and mitigate bias in AI outputs.

    185 GitHub stars~650 tokensUpdated 4 mo ago
    Auto-check passed
  • Chain Of Thought Design

    Owl-Listener/ai-design-skills

    Designing reasoning chains that produce better outputs. An agent skill from Owl-Listener/ai-design-skills.

    185 GitHub stars~687 tokensUpdated 4 mo ago
    Auto-check passed
  • Comparative Evaluation

    Owl-Listener/ai-design-skills

    A/B testing, side-by-side comparison, and preference ranking for AI outputs.

    185 GitHub stars~614 tokensUpdated 4 mo ago
    Auto-check passed

Questions about State Management

What does State Management do?

Managing shared context, memory, and state across multiple agents. State Management is an agent skill from Owl-Listener/ai-design-skills. Managing shared context, memory, and state across multiple agents.

When should I use State Management?

State Management fits situations like: tasks that involve State management; tasks that involve Multi-agent orchestration.

How do I install State Management in Claude Code?

Run `npx skills add Owl-Listener/ai-design-skills --skill state-management -a claude-code`. Or copy the skill folder (skills/design-agent-orchestration/state-management in Owl-Listener/ai-design-skills) into .claude/skills/state-management in your project. Claude Code loads it when a task matches its description.

How do I install State Management in Codex?

Run `npx skills add Owl-Listener/ai-design-skills --skill state-management -a codex`. Or copy the skill folder (skills/design-agent-orchestration/state-management in Owl-Listener/ai-design-skills) into .agents/skills/state-management in your project. Codex loads it when a task matches its description.

Can I use State Management in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add Owl-Listener/ai-design-skills --skill state-management -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/state-management, .gemini/skills/state-management, .github/skills/state-management and .opencode/skills/state-management in your project.

What does State Management need to run?

SKILL.md names no scripts, command-line tools or credentials: State Management is instructions for the agent only.

Does State Management access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is State Management safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does State Management use?

State Management is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does State Management use?

About 1.5k tokens (SKILL.md is roughly 6.1k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to State Management?

Skills that share tags, products or a category with State Management: Agent Workflow Designer (borghei/Claude-Skills, 891 stars), Onboarding (agentuse/agentuse, 205 stars), Agentic Os (affaan-m/ECC, 276k stars) and React Generate Skill (jiushiwon/wg-skills, 114 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains State Management?

Owl-Listener (a GitHub user) maintains it in Owl-Listener/ai-design-skills, which has 185 GitHub stars. The repository holds 11 skills in this directory. The repository was last updated on June 9, 2026.

Source: Owl-Listener/ai-design-skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.