Core is Lemonade's built-in knowledge base. Write conventions, decisions, and architecture notes once — your agents read them automatically at the start of every session.
No Obsidian. No plugins. No clipboard pasting. Just memory that works.
Named exports everywhere
2h ago
Zustand over Redux
1d ago
PTY session lifecycle
3d ago
DashMap not Mutex
5d ago
Tauri IPC command list
1w ago
Session 2026-04-11
Yesterday
Session 2026-04-10
2d ago
Max 8 agents (soft cap)
1w ago
The problem
Your agent doesn't know you use Zustand instead of Redux. It doesn't know the PTY buffer size was a deliberate choice. It doesn't know that the eight-agent limit is frontend-only. It forgets everything between sessions.
So you paste context into every new conversation. You re-explain conventions. You watch the agent undo a decision you made three weeks ago — because it was never written down anywhere it could actually read.
Context paste on every session
Developers paste the same architectural notes into every Claude Code session. Manually. Every time.
Decisions get re-opened
The agent suggests Zustand alternatives. Again. Because the decision to use Zustand exists nowhere it can see.
CLAUDE.md grows into a novel
You bloat your CLAUDE.md trying to cover everything. It burns tokens, degrades quality, and still misses context.
Obsidian is for humans, not agents
Graph view, canvas, 1000+ plugins — none of it is readable to an LLM. You'd need a custom script just to inject notes.
How Core works
One toggle per workspace. Core creates a .core/ directory inside your working directory. Your notes are plain .md files — readable by any editor, versionable with git.
Use the Core panel inside Lemonade, or write directly to the files. Each note has a type — Convention, Decision, Concept — and a simple toggle: inject into agent context or not.
When you launch a workspace, Core assembles all injected notes into a context payload and passes it to every agent via --append-system-prompt. Agents start the session already knowing your project's rules and history.
Note types
Named exports, file naming, component patterns, style rules. The things that should never change between sessions — and never do, because the agent reads them every time.
Why you chose Zustand. Why you use DashMap not Mutex<HashMap>. Why the 8-agent cap is frontend-only. Record the decision and the rationale — so the agent never re-opens closed questions.
What a "workspace snapshot" is. How the PTY session lifecycle works. What the singleton router does. Domain vocabulary and mental models your agent needs to reason about the codebase correctly.
At the end of a session, Core can generate a log of what changed, what was attempted, and what was left open. Not injected by default — reviewed by humans, referenced when needed. The memory that prevents re-solving the same bug twice.
Tauri IPC command list, plugin API notes, third-party SDK quirks. Reference notes are selectively injected — only when you tag them for the current session or they match the task at hand.
Agent integration
When you press Launch, Core collects all notes marked for injection, sorts them by priority, and assembles a structured context payload. Each agent receives it via their system prompt flag before the session begins.
The payload targets under 2,000 tokens — enough signal without diluting the context window. Notes are prioritized: Convention first, then Decision, then Concept.
.core/ notes read from disk
All .md files with inject: true
Sorted by priority
Convention → Decision → Concept → Reference
Written to temp file
Structured plaintext, ~1,240 tokens
Agent receives context at launch
--append-system-prompt core-context.md
5 injected notes · 760 tokens remaining for additional context
Core vs Obsidian
Obsidian remains an excellent tool for human note-taking. Core is designed for a different job — feeding agents context that makes them productive immediately.
Data model
Every Core note is a Markdown file with a tiny YAML header. There is no database, no proprietary format, no binary files. You can edit Core notes in any editor. You can grep them, git-blame them, and read them in any terminal.
The schema is minimal by design. Five fields in frontmatter, and they all have obvious meanings. Wikilinks ([[other-note]]) let notes reference each other — Core resolves them transitively during injection.
type — convention | decision | concept | session | reference
inject — true | false
tags — free-form array
updated — ISO-8601
agents — which agents contributed (optional)
Your agent knows your stack on session one. No copy-pasting architecture notes. No "as I mentioned earlier." The context is already there.
When the agent knows you chose Zustand deliberately — with a reason — it stops suggesting alternatives. Closed questions stay closed.
Move heavy context out of CLAUDE.md into typed Core notes. Keep your CLAUDE.md under 100 lines. Stop burning tokens on boilerplate that belongs in structured memory.
Claude Code, Gemini CLI, Aider, Codex — any agent that accepts a system prompt flag benefits from Core. One knowledge base, every agent in the grid.
.core/ is just a folder. Commit it. The team shares the same knowledge base. PR reviews show what context changed. History is auditable.
Claude Code can create Core notes directly. Spot a convention you want captured? Ask your agent to write it. The knowledge base grows as the project grows.
FAQ
Core is in active development and coming soon to Lemonade. All existing Lemonade customers will receive Core as part of the standard update — no extra cost, no extra subscription.
No. Core and Obsidian serve different purposes. Obsidian is excellent for personal knowledge management — journal, research, long-form thinking. Core is purpose-built for coding agent context: structured, scoped per-project, and automatically injected. Many developers will use both.
Yes. Claude Code (and any agent with file write access) can create and update .core/ files directly. The note format is simple enough that a well-prompted agent writes valid Core notes in one pass. You can tell Claude: "Create a Core convention note for named exports" and it knows exactly what to produce.
Core uses a priority system — Conventions first, then Decisions, then Concepts. If you exceed the token budget, lower-priority notes are trimmed. You can also use tags to create focused injection profiles: tag notes with #sprint-2 and only inject the sprint-relevant context for that session.
Core injects context for every agent in the workspace at launch. If you have 4 agents running, all 4 receive the same Core payload. This means your entire agent grid starts each session sharing the same project understanding — no inconsistency between agents on the same codebase.
$29 one-time. Every future feature — Core, Blueprint, Cluster — ships as a free update. No subscription, ever.
7-day money-back guarantee. All future updates included.