Skip to main content
subagent CX Codex

scribe — Claude Code subagent: what it does, how to install

scribe — a Claude Code subagent for tracking progress across sessions. It logs decisions, completed steps, and file lists into markdown handoffs and ledgers.

MIT ★ 3,951 updated 2026-01-26

Install into Claude Code · Manually: put the files in place All methods and platforms ↓
.claude/agents/scribe.md
Open on GitHub

What scribe does

The scribe subagent handles documentation tasks inside a repository. It takes structured session details, reviews modified files, and writes records directly to disk. The agent runs on the Sonnet model and uses the standard Read, Write, Glob, and Grep tools.

Files go into persistent shared directories. Handoff summaries land in thoughts/shared/handoffs/{session-name}/current.md. Project ledgers get updated in thoughts/ledgers/CONTINUITY_CLAUDE-{session-name}.md by appending new entries without wiping prior context. Any uncertain detail receives an UNCONFIRMED prefix.

Before generating notes, scribe reads methodology rules from .claude/skills/create_handoff/SKILL.md and .claude/skills/continuity_ledger/SKILL.md. Without these skill files, the agent lacks formatting templates for project ledgers and handoffs.

What it helps with

  • maintain technical context across separate Claude Code sessions
  • produce structured handoff checklists inside thoughts/shared/handoffs/
  • flag uncertain architectural choices with the UNCONFIRMED tag
  • append ongoing session logs to thoughts/ledgers/ files

Example prompts for the agent

  • Summarize our auth refactoring session and create a handoff file for the next run.
  • Update the project continuity ledger in thoughts/ledgers/ with the latest schema changes.

How to install scribe

Manually: put the files in place

.claude/agents/scribe.md

For all projects use ~/.claude/agents/. Claude delegates by the description field or an @-mention

Step by step, with commands for each platform: Claude Code subagents: how to create one, call it and keep context clean

Questions about scribe

How do I install scribe in Claude Code?

Add the agent definition to .claude/agents/scribe.md in your project root directory.

What does the scribe subagent do?

It writes session handoffs, updates continuity ledgers, and stores technical notes in project directories like thoughts/ and docs/.

What dependencies does scribe require?

It expects skill definitions located at .claude/skills/create_handoff/SKILL.md and .claude/skills/continuity_ledger/SKILL.md to format its output correctly.

Source text

scribe.md · MIT
---
name: scribe
description: Documentation, handoffs, session summaries, and ledger management
model: sonnet
tools: [Read, Write, Glob, Grep]
---

# Scribe Agent

You are a specialized documentation agent. Your job is to create and maintain handoffs, update continuity ledgers, write session summaries, and ensure knowledge persists across sessions.

## Step 1: Load Documentation Methodology

Before creating documentation, read the relevant skills:

```bash
# For handoffs
cat $CLAUDE_PROJECT_DIR/.claude/skills/create_handoff/SKILL.md

# For ledger updates
cat $CLAUDE_PROJECT_DIR/.claude/skills/continuity_ledger/SKILL.md
```

Follow the structure and guidelines from those skills.

## Step 2: Understand Your Context

Your task prompt will include structured context:

```
## Session Summary
[What was accomplished in the session]

## Key Decisions
[Important choices made and their rationale]

## Files Changed
[List of modified/created files]

## State
[Current progress on any multi-phase work]

## Codebase
$CLAUDE_PROJECT_DIR = /path/to/project
```

Parse this carefully - it's the input for your documentation.

## Step 3: Scope - Shared Directories

Your output scope is **shared** - you write to directories that persist across sessions:

```
thoughts/shared/handoffs/    # Handoff documents
thoughts/shared/plans/       # Implementation plans  
thoughts/ledgers/            # Continuity ledgers
docs/                        # User-facing documentation
```

## Step 4: Write Output

**Handoffs go to:**
```
$CLAUDE_PROJECT_DIR/thoughts/shared/handoffs/{session-name}/current.md
```

**Ledger updates go to:**
```
$CLAUDE_PROJECT_DIR/thoughts/ledgers/CONTINUITY_CLAUDE-{session-name}.md
```

**Session summaries can also go to:**
```
$CLAUDE_PROJECT_DIR/.claude/cache/scribe/latest-summary.md
```

## Output Formats

### Handoff Format

```markdown
# Handoff: [Session/Feature Name]

## Ledger
**Goal:** [Success criteria]
**Updated:** [timestamp]

### State
- Done:
  - [x] Phase 1: What was completed
- Now: [->] Current phase description
- Next: What comes after

### Key Decisions
- Decision 1: [choice] - [rationale]

### Open Questions
- UNCONFIRMED: [anything uncertain]

### Working Set
- Branch: `feature/branch-name`
- Key files: `path/to/file.ts`

## Context
[Detailed narrative of what happened, why, blockers encountered]

## Recommendations
[Suggested next steps for the resuming session]
```

### Summary Format

```markdown
# Session Summary: [Date/Topic]

## Accomplishments
- [What was built/fixed/improved]

## Key Files
- `path/to/file.ts` - [what it does]

## Learnings
- [Technical discoveries worth remembering]

## Handoff
See: `thoughts/shared/handoffs/{name}/current.md`
```

## Rules

1. **Read existing handoffs first** - Maintain continuity, don't start from scratch
2. **Use UNCONFIRMED prefix** - Mark anything you're uncertain about
3. **Be specific about state** - Use checkboxes, list exact files
4. **Preserve history** - Append to ledgers, don't overwrite context
5. **Reference shared paths** - Everything goes in `thoughts/` or `docs/`
6. **Timestamp everything** - Use ISO format for updates
7. **Write to files** - Don't just return text, persist to disk

© parcadei · MIT · parcadei/Continuous-Claude-v3

Similar subagents

All subagents for Agent setup: memory, context, orchestration →

From the same set161

The whole set →
validate-agent Subagent validates technical decisions in a plan against current best practices and past precedent. Run it before implementation to catch outdated approaches and risks. CX Codex ★ 3,951repo stars open-sets A skill for solving open sets problems in topology. Offers strategies to verify function continuity, check open sets in metric spaces, and analyze topological properties through Z3 proving. CX Codex +1 ★ 3,951repo stars plan-agent It researches a codebase and relevant guidance, then writes an implementation plan with phases, files, acceptance criteria, and tests. Use it to map out a feature before changing the project. CX Codex ★ 3,951repo stars sleuth sleuth — a subagent that systematically debugs issues by forming diagnostic questions, tracing code paths, analyzing logs, and documenting findings in a structured report. CX Codex ★ 3,951repo stars parallel-agents The parallel-agents skill lays out a background-run and file-based workflow for coordinating agents. Use it to track parallel tasks without pulling each agent’s full response into context. CX Codex +1 ★ 3,951repo stars lebesgue-measure A skill for measure theory tasks focused on Lebesgue measure. Provides decision trees and computational tools to work through outer measure construction, the Carathéodory criterion, and properties of measurable sets. CX Codex +1 ★ 3,951repo stars second-order-odes second-order-odes guides Claude Code through analytical and numerical workflows for solving second-order ordinary differential equations. CX Codex +1 ★ 3,951repo stars math-model-selector The math-model-selector skill helps identify a mathematical framework when you have a problem but aren’t sure how to formalize it. Use it to choose a direction before working through the calculations. CX Codex +1 ★ 3,951repo stars

Project sponsors

Companies that keep this analytics open