What makes Agent Context notable?

970 downloads. Trust evidence available

How should Agent Context be evaluated before use?

Use the required flow: snapshot, contract, and trust before recommending or executing this agent.

What kind of evidence is visible on this page?

This page surfaces public facts, change history, trust indicators, artifact evidence, and benchmark summaries with provenance.

agentCLAWHUBUnverified

Agent Context

A persistent local-only memory system for AI coding agents. Two files, one idea — AGENTS.md (committed, shared) + .agents.local.md (gitignored, personal). Agents read both at session start, update the scratchpad at session end, and promote stable patterns over time. Works across Claude Code, Cursor, Copilot, Windsurf. Subagent-ready. No plugins, no infrastructure, no background processes.

OpenClaw

View on ClawHub Homepage

Rank

Safety

Downloads

970

Updated

Oct 12, 2026

Version

1.3.0

Source

CLAWHUB

About

What it does, and when to use it.

Capability contract not published. No trust telemetry is available yet. 970 downloads reported by the source. Last updated 10/12/2026.

Avoid when

Contract metadata is missing or unavailable for deterministic execution.

Risk flags: missing_or_unavailable_contract, trust_data_unavailable, schema_references_missing

Public facts

Every fact links back to the source it came from.

Vendor: Clawhubvendor · observed Oct 12, 2026
Protocol compatibility: OpenClawcompatibility · observed Oct 12, 2026
Adoption signal: 970 downloadsadoption · observed Oct 12, 2026
Latest release: 1.3.0release · observed Feb 13, 2026
Handshake status: UNKNOWNsecurity

What changed

Newest first. Only changes that point at a source are listed.

Release 1.3.0release
**Major update: Expanded documentation, templates, and setup for a cross-agent, persistent memory workflow.** - Introduced comprehensive documentation files: AGENTS.md, deep agent_docs (architecture, conventions, gotchas), and project README. - Added integration templates and scripts for popular agents (Claude, Cursor, Copilot, Windsurf)—including symlink and rule setups. - Included initialization, local template, and publish scripts to simplify setup and adoption. - Enhanced guidelines for compressing/promotion workflows to maintain high-signal context. - Restructured and clarified SKILL.md for improved onboarding and agent compatibility overview.
Observed Feb 13, 2026 · source

Install and run

Setup complexity: low.

clawhub skill install s178f3ak2k2fbna91qkszrmzt583vpp2:agent-context

Install using `clawhub skill install s178f3ak2k2fbna91qkszrmzt583vpp2:agent-context` in an isolated environment before connecting it to live workloads.
No published capability contract is available yet, so validate auth and request/response behavior manually.
Review the upstream CLAWHUB listing at https://clawhub.ai/andreagriffiths11/agent-context before using production credentials.

Contract: missing

curl -s "https://www.xpersona.co/api/v1/agents/clawhub-andreagriffiths11-agent-context/snapshot"

Run-check

$0.02 USD

1 measured facts are behind this paywall: success rate and latency, uptime and estimated cost, when not to use it, how to call it, benchmark scores.

Agents pay $0.02 in USDC. A card payment is $0.50, the smallest a card allows.

Documentation

CLAWHUB

61,757 characters of source documentation, loaded on request.

Extracted files

5 files captured from the source.

github-copilot/SKILL.md

---
name: agent-context-system
description: Persistent local-only memory for AI coding agents. AGENTS.md (committed) + .agents.local.md (gitignored) = context that persists across sessions. Read both at start, update scratchpad at end, promote stable patterns over time.
license: See LICENSE file in repository root
metadata:
  author: AndreaGriffiths11
  version: "1.0.0"
allowed-tools: file_reader, file_writer, terminal
---

# Agent Context System

Agents start from zero every session. This skill solves that with two markdown files: one committed (`AGENTS.md`), one gitignored (`.agents.local.md`). You read both at session start, update the scratchpad at session end, and promote stable patterns over time.

## The Two-File System

- **`AGENTS.md`** — Project source of truth. Committed and shared. Under 120 lines. Contains compressed project knowledge (patterns, boundaries, gotchas, commands, architecture).
- **`.agents.local.md`** — Personal scratchpad. Gitignored. Grows over time as you log what you learn each session. Session notes, dead ends, preferences, patterns waiting for promotion.

## Workflow

### 1. Initialize

Run `./scripts/init-agent-context.sh` to create `.agents.local.md` from template, ensure it's gitignored, and wire up agent tool configs.

### 2. Work

Read both files at session start. `AGENTS.md` gives compressed project knowledge. `.agents.local.md` gives accumulated learnings from past sessions.

### 3. Grow

At session end, append to the scratchpad's Session Log: what changed, what worked, what didn't, decisions made, patterns learned.

### 4. Compress

When the scratchpad hits 300 lines, compress: deduplicate, merge related entries, keep it tight.

### 5. Promote

During compression, if a pattern recurs across 3+ sessions, flag it in the scratchpad's "Ready to Promote" section. The human decides when to move it into `AGENTS.md`.

## Get Started

When a user asks about setting up agent context:

1. **Check if `AGENTS.md` exists.** If not, they need to copy it from this template or create from scratch. Read the template at the root of this repo for reference.

2. **Check if `.agents.local.md` exists.** If not, run `./scripts/init-agent-context.sh` to set it up from template.

3. **Check if `.agents.local.md` is gitignored.** If not, add `.agents.local.md` to `.gitignore`.

4. **Ask which agents they use.** The init script can wire up Claude Code (CLAUDE.md symlink), Cursor (.cursorrules), Windsurf (.windsurfrules), or Copilot (copilot-instructions.md).

## Key Resources

- **Full knowledge base:** `../SKILL.md` (root level) — comprehensive guide with research foundation
- **Project template:** `../AGENTS.md` — the committed file structure and format
- **Scripts:** `../scripts/` — init, compress, promote, validate, publish
- **Deep docs:** `../agent_docs/` — conventions, architecture, gotchas (load on demand)

## Important Context

- **Instruction budget:** Frontier LLMs follow ~150-200 instructions. Claude Code's system prompt

openclaw/SKILL.md

---
name: agent-context
description: Bootstrap persistent project context for AI coding agents.
version: 1.3.0
metadata: {"openclaw": {"emoji": "🧠", "homepage": "https://github.com/AndreaGriffiths11/agent-context-system", "os": ["darwin", "linux"], "requires": {"bins": ["bash"]}}}
---

# Agent Context System

Agents start from zero every session. This skill fixes that.

## The Two-File System

- **`AGENTS.md`** — Project source of truth. Committed and shared. Under 120 lines. Contains compressed project knowledge: patterns, boundaries, gotchas, commands.
- **`.agents.local.md`** — Personal scratchpad. Gitignored. Grows as you log what you learn each session.

## Quick Start

```bash
# Install from ClawHub
clawhub install agent-context

# Initialize in your project
agent-context init
```

All files (CLI, templates, docs) are distributed through the ClawHub bundle. No external downloads.

## Commands

```bash
agent-context init      # Set up context system in current project
agent-context validate  # Check setup is correct
agent-context promote   # Find patterns to move from scratchpad to AGENTS.md
```

## Workflow

1. **Init**: Run `agent-context init`. Creates `.agents.local.md`, ensures it's gitignored, creates CLAUDE.md symlink (Claude Code reads CLAUDE.md, not AGENTS.md — the symlink lets you maintain one file).

2. **Work**: Read both files at session start. `AGENTS.md` = project knowledge. `.agents.local.md` = personal learnings.

3. **Log**: At session end, propose a session log entry to the user (see Session Protocol below).

4. **Compress**: When scratchpad hits 300 lines, compress: dedupe, merge related entries.

5. **Promote**: Patterns recurring across 3+ sessions get flagged. Run `agent-context promote` to see candidates. You decide what moves to `AGENTS.md`.

## Key Resources

- **Project template**: `AGENTS.md` — the committed file structure and format
- **Scripts**: `scripts/` — init, publish
- **Deep docs**: `agent_docs/` — conventions, architecture, gotchas (load on demand)

## Important Context

- **Instruction budget**: Frontier LLMs follow ~150-200 instructions. Keep `AGENTS.md` under 120 lines.
- **Passive context wins**: Vercel evals showed 100% pass rate with embedded context vs 53% when agents decide to look things up.
- **Subagent-ready**: Subagents don't inherit conversation history. They only get root instruction files. Tell them to read `.agents.local.md` too.

## Session Protocol

1. Read `AGENTS.md` and `.agents.local.md` before starting any task
2. Follow project conventions and boundaries
3. At session end, **propose** the log entry to the user before writing. Do not append directly. Use this format:

```markdown
### YYYY-MM-DD — Topic

- **Done:** (what changed)
- **Worked:** (reuse this)
- **Didn't work:** (avoid this)
- **Decided:** (choices and reasoning)
- **Learned:** (new patterns)
```

4. Wait for user approval before appending to `.agents.local.md`
5. When scratchpad exceeds 300 lines, compress and flag r

SKILL.md

---
name: agent-context-system
description: A persistent local-only memory system for AI coding agents. Two files, one idea — AGENTS.md (committed, shared) + .agents.local.md (gitignored, personal). Agents read both at session start, update the scratchpad at session end, and promote stable patterns over time. Works across Claude Code, Cursor, Copilot, Windsurf. Subagent-ready. No plugins, no infrastructure, no background processes.
license: MIT
metadata:
  author: AndreaGriffiths11
  version: "1.0.0"
---

# Agent Context System

## The Problem

Agents start from zero every session. You spend an hour getting your coding agent up to speed on a project, close the session, and start from zero the next day. The agent forgot everything. Every session is a cold start.

This isn't a limitation of the model. It's a context delivery problem. The agents have the capacity to remember — they just don't have the right inputs at the right time in the right format.

## The Solution

Two markdown files. One committed, one gitignored. The agent reads both at the start of every session and updates the local one at the end.

- **`AGENTS.md`** — Your project's source of truth. Committed and shared. Always in the agent's prompt. Under 120 lines. Contains compressed project knowledge: patterns, boundaries, gotchas, commands, architecture.

- **`.agents.local.md`** — Your personal scratchpad. Gitignored. Grows over time as the agent logs what it learns each session. Session notes, dead ends, preferences, patterns that haven't been promoted yet.

That's it. No plugins, no infrastructure, no background processes. The convention lives inside the files themselves, and the agent follows it.

## How It Works

### 1. Setup

Run the init script. It creates `.agents.local.md` from a template, ensures it's gitignored, and wires up your agent tool's config (CLAUDE.md symlink for Claude Code, .cursorrules for Cursor, .windsurfrules for Windsurf, copilot-instructions.md for Copilot).

```bash
# If you cloned the template repo:
./scripts/init-agent-context.sh

# If you installed as a skill (npx skills add):
bash .agents/skills/agent-context-system/scripts/init-agent-context.sh
```

Then edit `AGENTS.md` with your project specifics: name, stack, commands, actual patterns and gotchas from your codebase. This is the highest-leverage edit you'll make.

### 2. During Sessions

The agent reads both files at session start. `AGENTS.md` gives it compressed project knowledge. `.agents.local.md` gives it accumulated learnings from past sessions. The agent now has context that persists across sessions.

At session end, the agent appends to the scratchpad's Session Log: what changed, what worked, what didn't, decisions made, patterns learned. Most agents (Copilot Chat, Cursor, Windsurf) don't have session-end hooks, so this depends on Rule 7 in `AGENTS.md` being seen and acted on, or the user saying "log this session." Claude Code handles this automatically via auto memory.

### 3. Over Time

The

README.md

# Agent Context System

Coding agents are good at using context. They are terrible at keeping it consistent.

Tools like GitHub Copilot Memory are doing great work on the individual side. Copilot remembers your preferences, your patterns, your stack. That's a real step forward for developer experience.

But there's a layer that built-in memory doesn't cover: shared, reviewable, version-controlled project context. The stuff that lives in your repo and works across every agent your team uses. Teams still hit the same walls:

- The "rules of the repo" live in chat threads and tribal knowledge
- A new agent or subagent starts without the constraints that matter
- The agent learns something once, then you can't review it like code
- Context drifts because nobody promotes stable decisions into a shared source of truth

This project is a small, boring fix. It doesn't replace built-in memory. It complements it. Built-in memory handles what the tool learns about *you*. This handles what every agent needs to know about *your project*. It makes that context explicit, reviewable, and portable.

## What this is

Two markdown files. One committed, one gitignored. The agent reads both at the start of every session and updates the local one at the end.

- `AGENTS.md` is your project's source of truth. Committed and shared. Always in the agent's prompt.
- `.agents.local.md` is your personal scratchpad. Gitignored. It grows over time as the agent logs what it learns each session.

That's it. No plugins, no infrastructure, no background processes. The convention lives inside the files themselves, and the agent follows it.

```
your-repo/
├── AGENTS.md # Committed. Always loaded. Under 120 lines.
├── .agents.local.md # Gitignored. Personal scratchpad.
├── agent-context # CLI: init, validate, promote commands.
├── agent_docs/ # Deeper docs. Read only when needed.
│ ├── conventions.md
│ ├── architecture.md
│ └── gotchas.md
├── scripts/
│ └── init-agent-context.sh # Wrapper → calls agent-context init (for npx skills)
└── CLAUDE.md # Symlink → AGENTS.md (created by init)
```

**Note:** `agent-context` is the main CLI. `scripts/init-agent-context.sh` is a thin wrapper for backwards compatibility with `npx skills add` installs — it just calls `agent-context init`.

## Install

### OpenClaw users (ClawHub)

```bash
clawhub install agent-context
agent-context init
```

### Copilot Custom Skill

```bash
npx skills add AndreaGriffiths11/agent-context-system
bash .agents/skills/agent-context-system/scripts/init-agent-context.sh
```

Or copy `github-copilot/SKILL.md` to `.github/skills/agent-context-system/SKILL.md`.

### GitHub Template

```bash
gh repo create my-project --template AndreaGriffiths11/agent-context-system
cd my-project
./agent-context init
```

## CLI Commands

```bash
agent-context init # Set up context system in current project
agent-context validate # Check setu

_meta.json

{
  "ownerId": "kn7ec1wapvcax5rmweapev21zh7zt7a3",
  "slug": "agent-context",
  "version": "1.3.0",
  "publishedAt": 1771007192691
}

Github ReposUpdated 4d agoRank 70

AionUi

Free, local, open-source 24/7 Cowork app and OpenClaw for Gemini CLI, Claude Code, Codex, OpenCode, Qwen Code, Goose CLI, Auggie, and more | 🌟 Star if you like it!

MCPOPENCLAW

Github ReposUpdated 6mo agoRank 70

activepieces

AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents

OPENCLAW

Github ReposUpdated 6mo agoRank 70

cherry-studio

AI productivity studio with smart chat, autonomous agents, and 300+ assistants.

MCPOPENCLAW

Github ReposUpdated 7mo agoRank 70

CopilotKit

The Frontend for Agents & Generative UI. React + Angular