fast-jev-compaction

What is it

fast-jev-compaction is a Claude Code plugin that replaces the default compaction summaries in Anthropic's Claude Code CLI agent with "Jev decisions" — a decision-oriented representation of what the agent has done, learned, and committed to, rather than a prose recap of the conversation. In plain terms: when an AI coding agent runs out of context window, it normally squashes history into a lossy narrative summary. This project swaps that mechanism for a structured decision log, so the agent retains what it decided and why, not just what was said. It's written in TypeScript and ships as a plugin, which means it hooks into Claude Code's lifecycle without forking the agent runtime.

The business significance is bigger than the plugin itself. Context compaction is the single most fragile part of long-running agent workflows — it's where agents forget constraints, re-litigate settled decisions, and burn tokens re-deriving state. Anyone who can make compaction reliable owns a chokepoint in the agent stack. That makes this a wedge into memory/state management for coding agents, a category with real willingness-to-pay from teams running agents in CI and production. The "fresh" tag and 2026-09-27 first-seen date mean this is early — you're looking at a market forming, not one that's formed.

Why now

Three forces converge in late 2026. First, Claude Code went from novelty to daily driver for a meaningful slice of professional developers, and long sessions are now the norm rather than the demo. Once agents run for hours across multi-file refactors, compaction stops being an edge case and becomes the primary failure mode. Second, the plugin/hook architecture in Claude Code matured enough that third parties can intercept lifecycle events — you couldn't cleanly replace compaction a year ago without forking. Third, the broader "agent memory" conversation shifted from vector-DB retrieval (RAG-style) to structured state — decision logs, task graphs, constraint sets — because teams learned that semantic search over chat history doesn't preserve invariants.

There's also a cost driver. Compaction burns tokens, and re-derivation after a bad summary burns them again. Teams running agents at scale feel this in their API bill before they feel it in quality. A decision-based compaction scheme that's more token-efficient and more faithful hits both pains simultaneously.

Finally, the ecosystem is fragmenting across agents — Claude Code, Cursor, Codex CLI, Gemini CLI — and portable context-management layers become valuable precisely when no single vendor owns the runtime. The timing is right because the pain is acute, the extension points exist, and the standards haven't hardened yet.

Market Evidence

The signal set is thin but directionally clean: 2 independent sources (GitHub and Juejin), 2 total mentions, 100% growth rate, stage "validating," trend score 59/100, opportunity score 44/100. Read that honestly — this is not a groundswell. Two mentions is a whisper, and 100% growth off a base of one is mathematically unimpressive. The "validating" stage label is accurate: someone built a thing, someone else wrote about it, and the community hasn't voted yet.

What makes it worth tracking rather than dismissing is the category signal around it. Compaction and context management are recurring complaints in Claude Code issue trackers and developer forums — the pain is documented even if this specific solution isn't yet adopted. The market score of 62/100 versus demand score of 38/100 tells the real story: the market exists and is large, but demonstrated demand for this particular approach is unproven. Competition score of 22/100 means almost nobody is defending this space, which cuts both ways — no incumbents to beat, but also no validated playbook.

My position: treat this as a thesis to validate, not a market to enter blind. The two-source threshold is the minimum for "real," not the bar for "investable." Watch whether mentions compound week-over-week and whether anyone files issues asking for features. If the next 30 days bring zero new mentions, this is a hobby project, not a trend.

Who's Behind It

The visible footprint is a single open-source author publishing on GitHub with a companion write-up on Juejin — the Chinese developer community platform. That's a classic indie pattern: one motivated builder scratching their own itch with Claude Code, documenting the approach for peers. No company, no funding announcement, no recognizable maintainer brand. The Juejin coverage suggests the author is embedded in the Chinese AI-agent developer scene, which matters for early adopter distribution but limits Western reach.

The "whales" here aren't behind the project — they're the gravitational field around it. Anthropic controls Claude Code's plugin API and could absorb decision-based compaction into the core product at any time; that's both validation and existential risk. Cursor and the other agent vendors have the same incentive. Below them, the memory-layer startups (the various "agent memory" and "context engineering" companies) are natural acquirers or competitors.

Competitive dynamics are currently nonexistent because the market is pre-competitive. The real question is whether this author builds a community before a vendor ships a first-party solution. Given the 14-day estimated dev time and TypeScript stack, the barrier to entry is low — expect clones within weeks of any traction.

TAM & Market Size

Who buys? Three concentric rings. The inner ring is individual professional developers running Claude Code daily — a population plausibly in the low hundreds of thousands globally by late 2026, given Claude Code's adoption curve. They pay for tools in the $10-30/month band without much deliberation. The middle ring is engineering teams of 5-50 running agents in shared workflows, where a $20-50/seat tool that prevents context-loss bugs pays for itself in an afternoon. The outer ring is platform teams and CI/CD owners who'd pay for an enterprise-grade context-management layer at $500-5,000/month.

Price tolerance is set by the alternative cost: a single bad compaction that derails a two-hour agent run wastes maybe $5-15 in tokens plus developer time. If your tool prevents one derailment per developer per week, $20/month is trivially justified. The demand score of 38/100 is the honest constraint — buyers exist but haven't articulated this as a budget line yet. Opportunity score 44/100 reflects that gap: real market, immature demand.

Bottom line: the addressable market is credible at the low millions of dollars annually for a focused tool, with upside if agent adoption keeps compounding. Don't model a billion-dollar TAM. Model a profitable $1-5M ARR niche with an acquisition path to an agent vendor.

Competitive Landscape

Direct competitors are essentially absent — competition score 22/100 is accurate. The nearest analogues are general agent-memory projects (the various open-source memory servers and MCP-based context stores) and the built-in compaction in Claude Code itself, which is the real incumbent: free, bundled, and "good enough" for most users. Your enemy isn't a startup; it's default behavior.

Indirect competition is more serious. Anthropic ships compaction improvements continuously; any first-party decision-log feature would instantly commoditize this plugin. Cursor and Codex CLI are building their own context strategies. The memory-layer startups have funding and teams. Open-source clones will appear fast given the low technical barrier.

The gap worth owning: portability and auditability. A decision log that works across agents and produces a human-readable record of what the agent decided is something no vendor will build, because vendors want lock-in. That's a durable differentiation — cross-agent context portability plus an auditable decision trail for compliance-minded teams.

Time horizon if Big Tech enters: assume 6-9 months from a credible signal to a first-party feature. That's your window to build a community and a paid tier. Don't build anything that only works because Anthropic hasn't shipped it yet.

Business Model

Recommendation: open-core with a hosted paid tier, not pure subscription and not pure one-time. The plugin itself should be free and open source — that's how you get distribution against a free incumbent. Monetization comes from the parts teams need but individuals won't build: a hosted decision-log service with sync across machines and teammates, audit export, and team policy controls.

Pricing: free for individuals (single agent, local storage). Team tier at $15/seat/month with a 5-seat minimum ($75/month floor) — this undercuts the "just buy more tokens" alternative and sits below the mental threshold for a manager's card. Enterprise at $500/month base plus usage, for audit trails, SSO, and retention controls. Skip a one-time license; it caps revenue and signals hobbyist.

12-month forecast, honestly modeled off a thin top-of-funnel: conservative $8K MRR (roughly 100 team seats plus a handful of enterprise), base $25K MRR (300 seats, 10 enterprise), optimistic $60K MRR (requires the plugin to hit ~5K GitHub stars and one vendor partnership). CAC via developer content and GitHub is low — estimate $40-80 per team seat through organic channels, payback under two months at $15/seat. Paid acquisition won't work here; the audience is ad-blind and the price point is too low.

MVP Blueprint

Ship in 2-7 days, not 14. The 14-day estimate includes polish you don't need for validation. Core feature set, ruthlessly cut:

1. A Claude Code hook that intercepts pre-compaction and writes a structured decision log (JSON: decisions, constraints, open questions, file touchpoints) to a local file.
2. A post-compaction injector that feeds that log back as context instead of the default summary.
3. A CLI command to inspect and diff decision logs (jev log, jev diff) so users can see the value.
4. One config file with sensible defaults.

Cut everything else: no cloud sync, no team features, no web UI, no multi-agent support, no MCP server yet. Those are week-3 problems.

Tech stack: TypeScript (matches the source project and Claude Code's ecosystem), Node 20+, a single-file JSON store, commander for the CLI, and vitest for tests. Publish to npm as @yourscope/jev-compaction and to the Claude Code plugin directory. Write a 600-word README with a before/after demo GIF — the demo is the marketing.

Fastest path to launch: build the hook against a real 90-minute agent session you record yourself, prove the log preserves a constraint the default summary drops, publish, and post the demo to the Claude Code community and Juejin. Target: live within 72 hours of starting.

Commercial Opportunities

Direction 1: Hosted team decision-log service. Target: 10-50 person engineering teams running agents in shared repos. Price $15/seat/month. Expected $5-20K MRR within a year if adoption holds. Beats alternatives because it solves the coordination problem — teammates see what the agent decided across sessions — which no free plugin addresses.

Direction 2: Cross-agent context portability SDK. Target: platform teams and tool vendors who need context to survive switching between Claude Code, Cursor, and Codex. License the SDK at $2-5K/month per integrator. This is the highest-ceiling play because it's vendor-neutral infrastructure, and it's defensible if you move first on the format.

Direction 3: Audit/compliance export for regulated teams. Target: fintech and healthcare engineering orgs where "what did the AI change and why" is a compliance question. $500-2,000/month. Smaller market, but buyers with real budget and no price sensitivity — and the decision log is already an audit artifact, so the marginal build is an export and retention layer.

Direction 1 is the right starting point: fastest revenue, clearest buyer, and it funds the SDK work.

Product Ideas

🥇 JevLog — the decision-log plugin plus inspector CLI. One-line value prop: "Your agent forgets what it decided; JevLog makes it remember." Target user: individual developers and small teams running Claude Code for multi-hour tasks. Why now: compaction pain is acute, the plugin API exists, and no one owns the category. Ship free, monetize the hosted sync later. This is the wedge — build it first, get stars, learn from issues.

🥈 ContextBridge — cross-agent decision-log format and SDK. Value prop: "One decision log, every coding agent." Target: platform teams and tool vendors. Why now: the agent ecosystem is fragmenting and no standard exists; whoever defines the format owns the integration surface. Build after JevLog proves the format works in practice. Charge per integrator.

🥉 JevAudit — compliance export for AI-assisted code changes. Value prop: "Every agent decision, exportable and auditable." Target: regulated engineering orgs. Why now: AI-generated code is entering audit scope, and teams have no artifact showing agent reasoning. Highest price point, slowest sales cycle — build once you have a paying team customer asking for it.

Ranking rationale: distribution first (🥇), defensibility second (🥈), revenue-per-customer third (🥉).

SEO Opportunity

Search demand is nascent — queries like "claude code compaction" and "claude code context management" are growing but low-volume. That's fine: SEO difficulty is 15/100, essentially greenfield. Target long-tails: "claude code compaction alternative," "claude code plugin context management," "agent decision log," "claude code memory plugin," "context compaction best practices." Strategy: one definitive technical post ("How Claude Code compaction actually works, and how to replace it") that ranks for the head term and links to the plugin. Publish on your own domain and cross-post to dev.to and Juejin. Low competition means one good post wins the query for a year.

Risk Assessment

The thesis breaks if any of three things happen. Tech risk: Anthropic ships first-party decision-based compaction, or changes the plugin API to block pre-compaction hooks. Mitigation: keep the core logic vendor-agnostic and maintain a second integration target (Cursor or Codex CLI) from month two. Market risk: the pain is real but developers won't pay — they'll use the free plugin and never upgrade. This is the most likely failure mode given the demand score of 38/100. Mitigation: validate willingness-to-pay before building the hosted tier by pre-selling to 5 teams. Execution risk: a single-maintainer project can't keep pace with agent-vendor API churn. Mitigation: recruit one co-maintainer from early contributors.

Cheap validation: publish the free plugin, add a "notify me about team features" form, and count signups. If 100+ developers install and 10+ request team features in 30 days, build the paid tier. Walk away if installs stay under 50 after a month of promotion — that means the free incumbent is good enough and the category isn't ready.

Action Plan

Today: Fork or scaffold the plugin, record a 90-minute Claude Code session, and capture a concrete case where default compaction drops a constraint. That recording is your proof and your demo. This week: ship the free plugin to npm and the Claude Code plugin directory, publish the demo post, and post to the Claude Code community plus Juejin. Add the team-features waitlist form. Month 1: hit 100 installs or diagnose why not; talk to 10 users; decide on the hosted tier based on waitlist conversion. Month 3: if validated, launch the $15/seat team tier with 5 paying teams as the bar; start the cross-agent SDK spike. If not validated by month 3, open-source the whole thing, write the post-mortem, and move on — the 14-day dev estimate means the sunk cost is small.

The single metric that matters: weekly active installs of the free plugin. Everything else is downstream.

Related Terms

MCP (Model Context Protocol) — the standard for connecting agents to tools and data; a Jev decision log exposed as an MCP server would let any MCP-compatible agent consume it, which is the natural distribution path for ContextBridge. Agent memory / context engineering — the broader trend this sits inside; decision logs are a structured-memory approach competing with vector retrieval, and the two are complementary rather than exclusive. Claude Code plugins — the distribution channel and the platform risk; every plugin in this ecosystem lives under Anthropic's roadmap.