Agent Memory
Plugin
jumbocli
Memory and Context Orchestration for Coding Agents
Plugin Signal73/100Solid
maintained92
capable61
documented75
adopted52
Install
$ npx -y skills add jumbocontext/jumbo.cli --agent claude-code
Stats
265
Stars
16
Forks
Active
Maintenance
TypeScript
Language
AGPL-3.0
License
15h ago
Last commit
8mo ago
Created
Repo: jumbocontext/jumbo.cli
In this plugin
- codify-jumbo-goal
- decompose-architecture-aggregate
- define-jumbo-goals
- formalize-objectives
- jumbo-add-component
- jumbo-add-decision
- jumbo-add-dependency
- jumbo-add-guideline
- jumbo-add-invariant
- jumbo-bootstrap-session
- jumbo-command-discovery
- jumbo-context-maintenance
- jumbo-correction-capture
- jumbo-design-goal
- refine-jumbo-goals
- reject-jumbo-goal
- review-jumbo-goal
- start-jumbo-goal
What's inside
Skill(18 skills)
/codify-jumbo-goalUse when a Jumbo goal has been approved by QA review and needs architectural reconciliation before closing. Captures new learnings, updates stale entities, and ensures documentation reflects the work performed./decompose-architecture-aggregateUse when a project has Architecture data that needs migrating to fine-grained entities (Decisions, Invariants, Components, Dependencies). Guides the agent through reading, mapping, confirming, and executing the migration with user oversight./define-jumbo-goalsAdd Jumbo goals liberally to decompose objectives into finite units of work with bounded context. Use when defining new Jumbo goals from user requests, or to augment your own work to maintain scope while ensuring complementary work is registered./formalize-objectivesUse when the user's prompt is delivered outside the execution context of an existing Jumbo goal, the prompt is imbued with an objective that is not already defined as a Jumbo goal./jumbo-add-componentUse liberally when you create, discover, or modify a software component. Registers the component with Jumbo so future sessions have accurate architectural context./jumbo-add-decisionUse liberally when you make an architectural choice, select a technology, or reject an alternative. Records the decision so future sessions understand why the codebase looks the way it does.
README
Jumbo Context
Tired of repeating yourself to Claude, Codex, Antigravity, Copilot and their cohorts?
Agents shouldn't have to be re-taught your project every session. Jumbo gives them the context they're missing, so you don't have to.
- Memory (Capture important details about your project once)
- Continuity across sessions
- Automatic goal specification
- Extended context windows
- Concurrent agents
- Harness and model agnostic
Can we address the elephant in the room?
(a.k.a. What problems does this solve?)
Working with coding agents is amazing. But let's be honest, it' not without frustration. Here are the common issues:
-
Agent Amnesia: It's a thing. Every session that came before is forgotten. You spend time and energy getting the agent caught up before you even start thinking about your goals.
-
Slop: AI without guardrails can produce code that kind of works, but it’s rarely production-ready. Worse, it can leave behind a mess that takes hours to untangle. That’s not a productivity boost — it’s a hassle.
-
Vendor lock-in: If an agent harness holds your memory, switching tools means losing that context. With new models and tools shipping every week, switching is inevitable. Your context should move with you.
How does Jumbo help?
Jumbo was created to address these frustrations and unlock the full joy of coding with agents.
-
Memory: Details about your project are saved, so your agents always have the correct context. Agent Amnesia is, well...forgotten.
-
Quality: Your coding agents write shippable code on the first shot. You save time and tokens.
-
Interoperability: Jumbo is harness- and model-agnostic.
-
Portability: Switch to new models when they're released. Your context stays with you.
-
Orchestration: Run different agents in parallel. Optimize for capability and cost. Jumbo keeps everything in sync.
Those solve the core problems. These make Jumbo pleasant to use:
-
Extended context windows: Run agents longer without context rot.*
-
Automatic: Hooks into your agent session and orchestrates the flow. It just works.
-
Full control: Jumbo's memories are yours. Stay in control and manage your data directly from the terminal.
-
Private: All data stays local. Nothing leaves your machine.
-
Fast: No network calls. No lag. Everything runs locally.
* Only works for harnesses that support hooks.
Quick Start
- Install Jumbo globally
> npm i -g jumbo-cli
- Browse your project folder and run Jumbo
> jumbo
Jumbo will guide you in getting started.
- Run your agent as normal (claude, codex, agy, vibe)
> claude
[Nudge your agent once its running]
> Follow instructions
Jumbo will automatically orient the agent about your project and available goals.
[!NOTE] Goals are the heart of Jumbo. Every memory, guideline, and constraint attaches to a goal — so define your work there first. (see
jumbo goal add --help)Your agent can help define goals too. It knows how to use Jumbo.
[!TIP] Hit the ground running with the Jumbo Memories repo — a curated library of best practice guidelines and invariants ready to drop into any project.
See the Getting started guide for the full workflow.
Compatibility
Jumbo seamlessly integrates with all frontier harnesses and models. Use them interchangeably or in parallel.
It also works with any agent that supports AGENTS.md and truly excels with harnesses that support open agent skills.
Use Jumbo in a harness that supports hooks and you'll never think about context windows again.
How does it work?
It's simple. You just define your goals — describe your objective, criteria, and scope. Then run your agents and Jumbo guides them through the workflow:
- Refine: Your agent collaborates with Jumbo to couple all relevant memories to your goal and build a context packet ready for the agent to implement.
- Implement: Jumbo serves a curated context packet to your agent when it starts work on your goal.
- Review: Your agent reviews the goal against criteria and project specification. Non-passing goals are rejected and queued for reimplementation.
- Codify: Agents update documentation, change logs, and register any missing details that need to be preserved for future goals.
You don't have to remember all these steps. Jumbo hooks into your agent sessions and guides the entire flow.
Every time you start Claude Code (or similar) Jumbo will orient the agent about the state of your project. The agent will prompt you with an overview of planned work and ask what you want to work on. Just point at a goal and watch the magic happen.
What's in the trunk?
Jumbo remembers:
Your domain:
- Project: What you are building and who it's for.
- Audiences: Who uses your project and their priorities.
- Audience Pains: The problems your audiences face that you aim to solve.
- Value Propositions: How your product addresses each audience pain.
Your solution:
- Architecture: Your solution design, structure, and patterns applied.
- Components: The parts comprising your solution and their roles.
- Dependencies: Third-party packages and external services your project relies on.
- Decisions: History of why you chose what you chose.
- Guidelines: Preferences, best practices, and the standards you adhere to.
- Invariants: Rules you simply won't compromise on.
- Relations: The graph that ties it all together.
Your operations:
- Goals: The specifics - objective, criteria, scope, boundaries, and contextual relations.
- Sessions: Manage work continuity with pause, resume, compact, and multi-agent support.
Architecture
Jumbo follows Clean Screaming Architecture — four layers, strict dependency rules, and file names that tell you exactly what they do.
- Domain: Aggregates, events, and policies. Zero dependencies on anything outside.
- Application: Command handlers, controllers, and gateway abstractions. Orchestrates the workflows.
- Infrastructure: Event store, SQLite projections, and gateway implementations. The concrete stuff.
- Presentation: CLI commands and output builders. Parses input, formats output, stays in its lane.
Dependencies always point inward. Swap out the infrastructure and nothing else notices.
Core patterns:
- Event Sourcing: Every state change is a domain event, appended to an immutable JSONL log. Full history, full replay.
- CQRS: Writes produce events through command handlers. Reads come from SQLite views. Each side is optimized independently.
- DDD: One aggregate per bounded context. Domain events live next to their entity. Business rules stay pure.
- Gateway Pattern: Controllers talk to abstractions. Infrastructure provides the implementations. Wired up at startup via Inversify.
Data lives in two stores:
- Event store: Append-only JSONL files. Human-readable. The source of truth.
- SQLite: Fast read views projected from the event stream. Rebuildable anytime with
jumbo db rebuild.
When your agent starts a goal, Jumbo assembles a context packet on the fly — pulling in the components, decisions, guidelines, invariants, and architecture linked to that goal through relations. No stale caches. Always current.
Built with
- Core Libraries:
better-sqlite3: Read-model projectionscommander: CLI frameworkinversify+reflect-metadata: Dependency injectionyaml: Context serialization
- Terminal UI:
- Utilities:
Spread some ❤️ and sponsor the projects or buy them a cup of coffee. I have.
Documentation
| Resource | Description |
|---|---|
| Quickstart | Get running in 5 minutes |
| Installation | Prerequisites and setup |
| Concepts | Understand sessions, goals, and context |
| What Jumbo Creates | Generated files, folders, and local state |
| Goal Management | Complete guide to tracking work |
| Project Initialization | Configure Jumbo for your project |
| Session Management | Manage pause, resume, and session continuity |
| Advanced Workflows | Command chaining and multi-agent collaboration patterns |
| Command Reference | Full command documentation |
| Shared Memories | Pluggable invariants, guidelines, and patterns to prime your project |
FAQs
Through hooks, with fallback to AGENTS.md. Your agent calls jumbo session start at the beginning of a session, and Jumbo returns a workflow router plus a bounded backlog preview. The selected workflow then loads the relevant context packet, such as jumbo project show --northstar --format json for goal design or jumbo goal start --id <id> for implementation. New insights are captured in the natural flow of your agent conversations.
Change agents and models at will. Jumbo just picks up where you left off.
Jumbo has been battle-tested with Claude Code, GitHub Copilot, Codex, and Antigravity. More are to be verified soon...
Theoretically, any IDE with an integrated coding agent that supports hooks or AGENTS.md should work. VS Code running GitHub Copilot has been tested and works well with all supported models. Cursor is to be verified soon...
Locally, in .jumbo/ in your project. Nothing leaves your machine unless you want it to.
Absolutely. You can manage Jumbo directly from the CLI. You control how you want your agent to interact with Jumbo. Stay in the loop by approving each command, or run with pre-approved Jumbo commands for an automated experience.
Not at all. Jumbo prescribes an opinionated workflow that you can always bypass. It works alongside your agent to enhance its capabilities.
Jumbo goes beyond static markdown files. It's an immutable event stream—capturing your entire project history, always current and auditable. You stay in your flow, never repeat yourself—only add new information when you need to. Markdown is a snapshot in time, Jumbo is your project's living memory.
Jumbo adds the .jumbo/ folder to your .gitignore by default. Jumbo employs the event sourcing pattern under the hood, and it is likely to result in conflicts if shared between the team.
Love Jumbo and want to use it in your team? A cloud version is coming soon. Sign up to get notified when it's launched here.
An elephant never forgets. Neither should your agent
License
File tree
jumbocontext/jumbo.cliView on GitHub
.github/
workflows/
pr-gate.yml
publish.yml
.gitignore
AGENTS.md
assets/
agent-files/
json/
antigravity-hooks.fragment.json
claude-settings.fragment.json
codex-hooks.fragment.json
copilot-hooks.fragment.json
cursor-hooks.fragment.json
markdown/
AGENTS.md
CLAUDE.md
copilot-instructions.md
cursor-rules.mdc
GEMINI.md
JUMBO.md
scripts/
antigravity-hook.mjs
amp-logo.svg
claude-logo.svg
codex-logo.svg
cursor-logo.svg
github-copilot-logo.svg
images/
this-is-jumbo.gif
mistral-logo.svg
skills/
codify-jumbo-goal/
SKILL.md
decompose-architecture-aggregate/
SKILL.md
define-jumbo-goals/
SKILL.md
formalize-objectives/
SKILL.md
jumbo-add-component/
SKILL.md
jumbo-add-decision/
SKILL.md
jumbo-add-dependency/
SKILL.md
jumbo-add-guideline/
SKILL.md
jumbo-add-invariant/
SKILL.md
jumbo-bootstrap-session/
SKILL.md
jumbo-command-discovery/
SKILL.md
jumbo-context-maintenance/
SKILL.md
jumbo-correction-capture/
SKILL.md
jumbo-design-goal/
SKILL.md
refine-jumbo-goals/
SKILL.md
reject-jumbo-goal/
SKILL.md
review-jumbo-goal/
SKILL.md
start-jumbo-goal/
SKILL.md
vscode-logo.svg
warp-logo.svg
benchmarks/
replay-transaction-benchmark.mjs
build/
copy-migrations.mjs
generate-command-registry.mjs
inject-telemetry-config.mjs
CHANGELOG.md
CONTRIBUTING.md
docs/
CONTRIBUTING-DOCS.md
getting-started/
concepts.md
first-run.md
index.md
installation.md
what-jumbo-creates.md
guides/
advanced-workflows.md
goal-management.md
index.md
README.md
reference/
commands/
architecture.md
audience-pains.md
audiences.md
components.md
decisions.md
dependencies.md
goal.md
guidelines.md
index.md
invariants.md
maintenance.md
project.md
relations.md
search-index.md
search.md
session.md
telemetry.md
value-propositions.md
work.md
worker.md
index.md
project-initialization.md
upgrading/
v2.md
eslint.config.js
eslint.config.mjs
jest.config.cjs
jumbo-logo.svg
JUMBO.md
LICENSE.txt
package-lock.json
package.json
README.md
src/
application/
agents/
AgentInvocation.ts
IAgentGateway.ts
cli-metadata/
query/
ICliMetadataReader.ts
update/
CliPackageName.ts
CliPackageVersionLookupResult.ts
CliUpdateCheckResult.ts
CliUpdateController.ts
CliUpdateFailureReason.ts
CliUpgradeFeasibility.ts
CliUpgradeResult.ts
CliVersionComparator.ts
CliVersionComparison.ts
ICliPackageUpgradeGateway.ts
ICliPackageVersionGateway.ts
context/
architecture/
ArchitectureDeprecationConstants.ts
ArchitectureView.ts
define/
ArchitectureDefinedEventHandler.ts
DefineArchitectureController.ts
DefineArchitectureRequest.ts
DefineArchitectureResponse.ts
IArchitectureDefinedEventWriter.ts
IArchitectureDefinedProjector.ts
IArchitectureDefineReader.ts
IDefineArchitectureGateway.ts
LocalDefineArchitectureGateway.ts
deprecate/
ArchitectureDeprecatedEventHandler.ts
IArchitectureDeprecatedEventWriter.ts
IArchitectureDeprecatedProjector.ts
get/
GetArchitectureController.ts
GetArchitectureRequest.ts
GetArchitectureResponse.ts
IGetArchitectureGateway.ts
LocalGetArchitectureGateway.ts
IArchitectureReader.ts
update/
ArchitectureUpdatedEventHandler.ts
IArchitectureUpdatedEventReader.ts
IArchitectureUpdatedEventWriter.ts
IArchitectureUpdatedProjector.ts
IArchitectureUpdateReader.ts
IUpdateArchitectureGateway.ts
LocalUpdateArchitectureGateway.ts
UpdateArchitectureController.ts
UpdateArchitectureRequest.ts
UpdateArchitectureResponse.ts
audience-pains/
add/
AddAudiencePainCommand.ts
AddAudiencePainCommandHandler.ts
AddAudiencePainController.ts
AddAudiencePainRequest.ts
AddAudiencePainResponse.ts
AudiencePainAddedEventHandler.ts
IAddAudiencePainGateway.ts
IAudiencePainAddedEventWriter.ts
IAudiencePainAddedProjector.ts
LocalAddAudiencePainGateway.ts
AudiencePainView.ts
list/
GetAudiencePainsController.ts
GetAudiencePainsRequest.ts
GetAudiencePainsResponse.ts
IGetAudiencePainsGateway.ts
LocalGetAudiencePainsGateway.ts
query/
IAudiencePainContextReader.ts
update/
AudiencePainUpdatedEventHandler.ts
IAudiencePainUpdatedEventWriter.ts
IAudiencePainUpdatedProjector.ts
IAudiencePainUpdateReader.ts
IUpdateAudiencePainGateway.ts
LocalUpdateAudiencePainGateway.ts
UpdateAudiencePainCommand.ts
UpdateAudiencePainCommandHandler.ts
UpdateAudiencePainController.ts
UpdateAudiencePainRequest.ts
UpdateAudiencePainResponse.ts
audiences/
add/
AddAudienceCommand.ts
AddAudienceCommandHandler.ts
AddAudienceController.ts
AddAudienceRequest.ts
AddAudienceResponse.ts
AudienceAddedEventHandler.ts
IAddAudienceGateway.ts
IAudienceAddedEventWriter.ts
IAudienceAddedProjector.ts
LocalAddAudienceGateway.ts
AudienceView.ts
list/
IListAudiencesGateway.ts
ListAudiencesController.ts
ListAudiencesRequest.ts
ListAudiencesResponse.ts
LocalListAudiencesGateway.ts
query/
IAudienceContextReader.ts
remove/
AudienceRemovedEventHandler.ts
IAudienceRemovedEventWriter.ts
IAudienceRemovedProjector.ts
IAudienceRemoveReader.ts
IRemoveAudienceGateway.ts
LocalRemoveAudienceGateway.ts
RemoveAudienceCommand.ts
RemoveAudienceCommandHandler.ts
RemoveAudienceController.ts
RemoveAudienceRequest.ts
RemoveAudienceResponse.ts
update/
AudienceUpdatedEventHandler.ts
IAudienceUpdatedEventWriter.ts
IAudienceUpdatedProjector.ts
IAudienceUpdateReader.ts
IUpdateAudienceGateway.ts
LocalUpdateAudienceGateway.ts
UpdateAudienceCommand.ts
UpdateAudienceCommandHandler.ts
UpdateAudienceController.ts
UpdateAudienceRequest.ts
UpdateAudienceResponse.ts
components/
add/
AddComponentCommand.ts
AddComponentCommandHandler.ts
AddComponentController.ts
AddComponentRequest.ts
AddComponentResponse.ts
ComponentAddedEventHandler.ts
IAddComponentGateway.ts
IComponentAddedEventWriter.ts
IComponentAddedProjector.ts
IComponentAddReader.ts
LocalAddComponentGateway.ts
ComponentView.ts
deprecate/
ComponentDeprecatedEventHandler.ts
DeprecateComponentCommand.ts
DeprecateComponentCommandHandler.ts
DeprecateComponentController.ts
DeprecateComponentRequest.ts
DeprecateComponentResponse.ts
IComponentDeprecatedEventWriter.ts
IComponentDeprecatedProjector.ts
IComponentDeprecateReader.ts
IDeprecateComponentGateway.ts
LocalDeprecateComponentGateway.ts
get/
GetComponentsQueryHandler.ts
IComponentReader.ts
IComponentViewReader.ts
list/
GetComponentsController.ts
GetComponentsRequest.ts
GetComponentsResponse.ts
IGetComponentsGateway.ts
LocalGetComponentsGateway.ts
remove/
ComponentRemovedEventHandler.ts
IComponentRemovedEventWriter.ts
IComponentRemovedProjector.ts
IComponentRemoveReader.ts
IRemoveComponentGateway.ts
LocalRemoveComponentGateway.ts
RemoveComponentCommand.ts
RemoveComponentCommandHandler.ts
RemoveComponentController.ts
RemoveComponentRequest.ts
RemoveComponentResponse.ts
rename/
ComponentRenamedEventHandler.ts
IComponentRenamedEventWriter.ts
IComponentRenamedProjector.ts
IComponentRenameReader.ts
IRenameComponentGateway.ts
LocalRenameComponentGateway.ts
RenameComponentCommand.ts
RenameComponentCommandHandler.ts
RenameComponentController.ts
RenameComponentRequest.ts
RenameComponentResponse.ts
search/
ComponentSearchCriteria.ts
ISearchComponentsGateway.ts
LocalSearchComponentsGateway.ts
SearchComponentsController.ts
SearchComponentsRequest.ts
SearchComponentsResponse.ts
show/
IShowComponentGateway.ts
LocalShowComponentGateway.ts
ShowComponentController.ts
ShowComponentRequest.ts
ShowComponentResponse.ts
undeprecate/
ComponentUndeprecatedEventHandler.ts
IComponentUndeprecatedEventWriter.ts
IComponentUndeprecatedProjector.ts
IComponentUndeprecateReader.ts
IUndeprecateComponentGateway.ts
LocalUndeprecateComponentGateway.ts
UndeprecateComponentCommand.ts
UndeprecateComponentCommandHandler.ts
UndeprecateComponentController.ts
UndeprecateComponentRequest.ts
UndeprecateComponentResponse.ts
update/
ComponentUpdatedEventHandler.ts
IComponentUpdatedEventWriter.ts
IComponentUpdatedProjector.ts
IComponentUpdateReader.ts
IUpdateComponentGateway.ts
LocalUpdateComponentGateway.ts
UpdateComponentCommand.ts
UpdateComponentCommandHandler.ts
UpdateComponentController.ts
UpdateComponentRequest.ts
UpdateComponentResponse.ts
decisions/
add/
AddDecisionCommand.ts
AddDecisionCommandHandler.ts
AddDecisionController.ts
AddDecisionRequest.ts
AddDecisionResponse.ts
DecisionAddedEventHandler.ts
IAddDecisionGateway.ts
IDecisionAddedEventWriter.ts
IDecisionAddedProjector.ts
LocalAddDecisionGateway.ts
DecisionView.ts
get/
GetDecisionsController.ts
GetDecisionsRequest.ts
GetDecisionsResponse.ts
IDecisionViewReader.ts
IGetDecisionsGateway.ts
LocalGetDecisionsGateway.ts
restore/
DecisionRestoredEventHandler.ts
IDecisionRestoredEventWriter.ts
IDecisionRestoredProjector.ts
IDecisionRestoreReader.ts
IRestoreDecisionGateway.ts
LocalRestoreDecisionGateway.ts
RestoreDecisionCommand.ts
RestoreDecisionCommandHandler.ts
RestoreDecisionController.ts
RestoreDecisionRequest.ts
RestoreDecisionResponse.ts
reverse/
DecisionReversedEventHandler.ts
IDecisionReversedEventWriter.ts
IDecisionReversedProjector.ts
IDecisionReverseReader.ts
IReverseDecisionGateway.ts
LocalReverseDecisionGateway.ts
ReverseDecisionCommand.ts
ReverseDecisionCommandHandler.ts
ReverseDecisionController.ts
ReverseDecisionRequest.ts
... 1600 moreShowing a partial view of a very large repo.
FAQ
jumbocli is a Claude Code plugin with 18 hand-picked skills for agent memory work, indexed on Flowy. Install it with the command on its page. It includes codify-jumbo-goal, decompose-architecture-aggregate, define-jumbo-goals. Its skills do not fire on their own yet. Request auto-invocation to have Flowy route them as you prompt. Free and open source.
- What is jumbocli?
- Memory and Context Orchestration for Coding Agents
- How do I install jumbocli?
- Run these in Claude Code: npx -y skills add jumbocontext/jumbo.cli --agent claude-code. Then prompt normally.
- Does jumbocli auto-invoke its skills?
- Not yet. It is indexed on Flowy as a plain plugin. Request auto-invocation on its page and Flowy will route its skills for you as you prompt.
- Is jumbocli free?
- Yes. Flowy is free and open source, with nothing gated. You can read every skill in full before you install.