Agent Kernel
Three markdown files that give any AI coding agent persistent memory between sessions — no framework, no database, just git.
Agent Kernel is a genuinely clever leverage play: rather than building another memory layer, it hijacks the AGENTS.md convention that coding agents already respect, so memory arrives with zero integration work. The split between mutable knowledge/ files and append-only notes/ is the right call — facts get corrected, history doesn't get rewritten. Choose it if you live in the terminal, already run OpenCode or Claude Code daily, and want git diff as your agent audit log. Look elsewhere if you want a GUI, a managed backend, or role-based access — and be aware that heavyweight orchestration stacks remain a different category entirely, not a drop-in upgrade.
Verified 2d ago · liveness 75/100 · cite: rightaichoice.com/tools/agent-kernel
- Developers who already run a coding agent daily and want memory without a framework
- Power users running several agents for different domains
- Small teams comfortable with git and markdown who want an auditable agent memory
- Hobbyists experimenting with stateful agent workflows
- Non-technical users uncomfortable with the command line and git
- Anyone wanting a GUI or zero-setup managed service
- Enterprise teams needing RBAC, SSO, or compliance features
We scan live Reddit threads, YouTube comments, X posts, G2 reviews and other communities — and hand you an honest verdict in under a minute.
- Honest verdict, not marketing
- Real pros & cons from real users
- Attributed quotes with receipts
3 free scans · no card needed
Skip Agent Kernel if you want a GUI, a hosted service, or role-based access controls — it is markdown files in a git repo you maintain yourself, and everything from knowledge upkeep to per-agent repo separation is manual work you own.
Running several agents multiplies the repos you maintain — each clone has its own knowledge/ and notes/ to keep current, and that upkeep is your time, not the tool's.
Agent Kernel itself is free and open source, with 200+ GitHub stars and no paid tier published on its site. That puts it in a different category from hosted agent-memory and orchestration services you pay per seat or per token for: you trade a subscription for your own time on knowledge upkeep, git hygiene, and repo separation. The optional kern-ai runtime is published on the same free basis.
In short
Agent Kernel — Three markdown files that give any AI coding agent persistent memory between sessions — no framework, no database, just git. Best for Developers who already run a coding agent daily and want memory without a framework, Power users running several agents for different domains, Small teams comfortable with git and markdown who want an auditable agent memory. Free to use.
What people actually say about Agent Kernel — is it worth it?
We ran a structured research pass across product reviews, community discussions, and post-purchase forum threads to surface the patterns vendors won't publish themselves. Below: the recurring strengths, the hidden costs people mention most, and the cohort that consistently regrets adopting this tool.
35 mentions across 4 sources (Hacker News, Bluesky, GitHub, Lemmy) · researched Jul 6, 2026.
Average across the 4 sources that answered — each source counts once, not each post.
- +Extremely simple: three markdown files and a git repo.
- +Works with any AI agent that reads AGENTS.md.
- +Persistent memory across sessions without databases or servers.
- +Version control built-in via git for full history and rollback.
- +Free and open source with permissive license.
- −Documentation is sparse, especially for non-English users.
- −Installation issues reported with missing modules (agentkernel_standalone).
- −No official support channels, only GitHub issues.
- −Confusion with other projects named 'Agent Kernel'.
- −Requires git knowledge; not beginner-friendly for non-developers.
- • Optional kern-ai runtime may have its own pricing (unclear from data)
Viability Score
How well maintained and how widely used is Agent Kernel? Built from what the vendor actually publishes (docs, changelog, tutorials, integrations, pricing), whether the site is live, and how much real users discuss it. How we calculate this
Last calculated: October 2026
How we score →Key Features
- Persistent memory across sessions via three markdown files
- Uses the AGENTS.md convention that coding agents already read
- IDENTITY.md defines who the agent is
- KNOWLEDGE.md indexes the agent's knowledge files
- knowledge/ holds mutable world facts with last-updated timestamps
- notes/ holds append-only daily session logs (decisions, actions, open items)
- Git-based version history, rollback, and diffs
- Multiple agents via separate repos with the same kernel
- Quick start: git clone, cd, launch your agent
- Works with OpenCode, Claude Code, Codex, Cursor, and Windsurf
- No framework, database, or external service required
- Optional kern-ai runtime: Telegram integration
- Optional kern-ai runtime: Slack integration
- Daemon mode via kern-ai
- User pairing and backup/restore via kern-ai
About Agent Kernel
Agent Kernel is an open-source tool that makes AI coding agents stateful using three markdown files and a git repository. AI coding agents like OpenCode, Claude Code, Codex, Cursor, and Windsurf already read AGENTS.md as project instructions; Agent Kernel uses that same mechanism to teach them how to remember. You clone the repo (git clone https://github.com/oguzbilgic/agent-kernel.git my-agent), start your coding agent in that directory, and it reads the kernel, notices it's new, and asks who you want it to be. You tell it, and it remembers. The memory is structured as plain markdown. AGENTS.md is the kernel — generic, and you don't edit it. IDENTITY.md defines who the agent is. KNOWLEDGE.md indexes the knowledge files. knowledge/ holds mutable facts about the world, and each file tracks when it was last updated. notes/ holds append-only daily session logs capturing decisions, actions, and open items — never modified after the day ends. Because everything lives under git, you get version history, rollback, and portability across machines at no extra cost. Multiple agents are handled by giving each its own repo: same kernel, different identity, different knowledge — a homelab agent, an investing agent, a health agent, each cloned separately. An optional runtime called kern-ai (npx kern-ai init my-agent) extends the same brain across the TUI, Telegram, and Slack, and adds daemon mode, user pairing, and backup and restore. This is for terminal-comfortable developers who want persistent agent memory without a heavyweight orchestration framework. It is not for people who want a GUI, a managed service, or enterprise controls — it demands comfort with git and markdown and returns unmatched transparency and control. It is free and open source, with 200+ GitHub stars.
Behind the Verdict
Agent Kernel's core insight is that it doesn't need to be a framework at all. The entire memory layer is three markdown files — AGENTS.md (the generic kernel you don't edit), IDENTITY.md (who the agent is), and KNOWLEDGE.md (an index of the knowledge files) — plus two directories: knowledge/ for mutable facts about how things are right now, and notes/ for append-only daily session logs of decisions, actions, and open items. The design earns its keep in the separation of those two directories. Facts change; you correct a knowledge file. History doesn't change; notes/ is never modified after the day ends. Because both sit inside a git repo, you get diffs, commit history, rollback, and portability across machines without building any of it. If you have ever tried to audit what an agent believed last Tuesday, git log on a plain-text file is a refreshingly boring answer. Setup is three steps: clone the kernel (git clone https://github.com/oguzbilgic/agent-kernel.git my-agent), start your coding agent in that directory (cd my-agent && opencode), and talk to it. The agent reads the kernel, realizes it's new, asks who you want it to be, and remembers the answer. It works with any coding agent that reads AGENTS.md — OpenCode, Claude Code, Codex, Cursor, Windsurf — so there is nothing to integrate. Multiple agents are handled the way git handles everything: separate clones. git clone agent-kernel homelab-agent, investing-agent, health-agent — same kernel, different identity, different knowledge, no cross-contamination. The optional kern-ai runtime (npx kern-ai init my-agent) extends one brain across the TUI, Telegram, and Slack, and adds daemon mode, user pairing, and backup and restore. The honest tradeoffs are all of the "you own it" variety. There is no managed backend: knowledge upkeep, conflict resolution, and per-agent repo separation are manual work you do, not work the product does. It only works with agents that already read AGENTS.md. Telegram, Slack, and daemon mode require the separate kern-ai runtime. And if you want a GUI, a hosted service, or role-based access controls, this is the wrong shape of tool for you. For terminal-comfortable developers already running a coding agent daily, though, it is close to free leverage: 200+ GitHub stars, no database, no external service, and a memory you can read with cat.
Researching Agent Kernel? Get your full AI stack in 60 seconds.
Free, no signup — tell us your goal and get tools matched to your budget & existing stack.
Real-world workflow fit
Concrete scenarios for the personas Agent Kernel actually fits — and what changes day-one when you adopt it.
You clone the kernel into my-agent, start opencode in that directory, and the agent reads AGENTS.md, notices it's new, and asks who you want it to be. You answer, and it writes IDENTITY.md.
Outcome: Every later session opens with the same identity and prior context, and git log gives you a readable diff of what the agent believed and when.
You clone the kernel three times — homelab-agent, investing-agent, health-agent — and give each its own identity and knowledge files while sharing the same unedited kernel.
Outcome: The three agents keep separate memories with no cross-contamination, and each repo can be backed up, diffed, or rolled back independently.
You run npx kern-ai init my-agent and enable the optional runtime so the same brain is reachable from the TUI, Telegram, and Slack, with daemon mode and user pairing.
Outcome: You message the same stateful agent from whichever channel you're on, without standing up a database or a managed backend.
Use Cases
- Give an OpenCode agent persistent memory for a long-running personal research project
- Run a Claude Code agent that remembers your todo list and daily progress across sessions
- Keep separate homelab, investing, and health agents, each with its own identity and knowledge repo
- Self-host one stateful agent reachable from the terminal, Telegram, and Slack via kern-ai
- Version-control your agent's knowledge files and session logs so you can diff or roll back changes
Limitations
- Agent Kernel provides persistent memory to AI coding agents through markdown files (AGENTS.md, IDENTITY.md, KNOWLEDGE.md) plus knowledge/ and notes/ directories inside a git repository.
- It relies on agents that already read AGENTS.md, so it is limited to compatible coding agents such as OpenCode, Claude Code, Codex, and Cursor.
- Setup requires cloning a git repo and running a coding agent in that directory — there is no managed backend, and knowledge upkeep, conflict resolution, and per-agent repo separation are manual work you own.
- Telegram, Slack, and daemon mode require the separate optional kern-ai runtime.
as of 2026-10-15
Verification history
We have re-verified Agent Kernel 7 times since . Each pass re-reads the vendor's own pages and re-checks every listed field against that evidence; passes where nothing had changed are marked as such.
- — re-checked, vendor evidence unchanged
- — re-checked, vendor evidence unchanged
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-checked, vendor evidence unchanged
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
Showing the 6 most recent of 7 verification passes.
Free to cite with attribution — this page re-verifies continuously.
12-month cost
Project the real annual outlay, including the implied monthly cost when only an annual tier is published.
Vendor list price only. Add-on usage, seat overages, and contract minimums are surfaced under Hidden costs & gotchas.
Plans compared
For each published Agent Kernel tier: who it actually fits, and what it adds vs. the previous tier. Cross-reference the cost calculator above for projected annual outlay.
Agent Kernel (core)
$0/mo
Ideal for
Developers who already run a coding agent such as OpenCode, Claude Code, Codex, Cursor, or Windsurf daily and want persistent memory without adopting a framework.
What this tier adds
Starting tier: the full kernel — AGENTS.md, IDENTITY.md, KNOWLEDGE.md, knowledge/, and notes/ — plus git history, rollback, and multiple agents via separate repos.
kern-ai runtime (optional)
$0/mo
Ideal for
Self-hosters who want one agent brain reachable from the terminal, Telegram, and Slack rather than only inside a coding agent session.
What this tier adds
Adds the channel and operations layer on top of the core memory files: Telegram and Slack integration, daemon mode, user pairing, and backup and restore.
Where the pricing makes sense
The company stage and team size where Agent Kernel's pricing actually pencils out — and where peers do it cheaper.
Agent Kernel itself is free and open source, with 200+ GitHub stars and no paid tier published on its site. That puts it in a different category from hosted agent-memory and orchestration services you pay per seat or per token for: you trade a subscription for your own time on knowledge upkeep, git hygiene, and repo separation. The optional kern-ai runtime is published on the same free basis.
Setup time & first value
How long it actually takes to get something useful out of Agent Kernel — broken out by persona, not the marketing-page minute.
Terminal-comfortable developers: first value in minutes — git clone the kernel, cd into it, launch your coding agent, and answer its identity question. Adding the optional kern-ai runtime for Telegram, Slack, and daemon mode is a separate npx kern-ai init step. Non-technical users without git habits should not start here.
Switching to or from Agent Kernel
How to bring data in from common predecessors and how to get it back out — written for the switcher, not the buyer.
- →From ad-hoc AGENTS.md files: copy your existing instructions into IDENTITY.md and move mutable facts into knowledge/ so the kernel can index them.
- →From a chat-history-only agent: clone the kernel alongside your project and let notes/ accumulate session logs instead of relying on scrollback.
- →From a heavyweight orchestration framework: clone the kernel per agent and keep the markdown files as the memory layer if you only need persistence and git history.
- →From a single shared agent: split it into per-domain clones (homelab, investing, health) so each gets its own identity and knowledge files.
- ↗To a managed agent-memory service: export knowledge/ and notes/ as plain markdown and import them into the hosted store, accepting the loss of git-native diffing.
- ↗To a hosted orchestration platform: keep the markdown files as your source of truth and re-point the platform's ingestion at the repo.
- ↗To a different AGENTS.md-compatible agent: the kernel is agent-agnostic, so launch the new agent in the same directory and the same memory carries over.
- ↗To your own custom memory layer: the files are plain markdown and the kernel is open source, so you can fork or reimplement without a data export.
Integrations
Resources & Guides
Tutorials & Learning
YouTube returned 6 videos for “Agent Kernel”, and we withheld 6: 6 did not mention Agent Kernel. We are showing none, because we could not prove any of them are about Agent Kernel.
Official links
Tools that pair well with Agent Kernel
Common stack mates teams adopt alongside Agent Kernel, with the specific reason each pairing earns its keep.
PMB
Local-first memory layer that gives your AI coding agent a SQLite file it can recall from between sessions.
Brain.Md
A persistent, file-based memory layer for coding agents that lives as a brain/ Markdown folder in your repo.
Agentmemory
Open-source memory runtime that gives coding agents persistent recall between sessions, stored on your machine.
Featured Head-to-Head Comparisons
Agent Kernel vs Locus Robotics
Locus Robotics and Agent Kernel serve entirely different domains—physical warehouse automation vs. developer tooling. If you run a warehouse needing 2-3x productivity gains with flexible AMRs, Locus is the clear choice. If you're a developer wanting persistent memory for your AI coding agent with zero cost and minimal setup, Agent Kernel wins. They are not competitors; choose based on your problem domain.
Agent Kernel vs Presto Voice
Choose Presto Voice if you run a QSR chain wanting to automate drive-thru ordering with proven ROI and upselling capabilities. Choose Agent Kernel if you're a developer needing a simple, open-source way to give AI coding agents persistent memory across sessions. They serve completely different domains.
Agent Kernel vs Truleo
Truleo and Agent Kernel serve completely different worlds: Truleo is a paid, law-enforcement-specific intelligence platform for connecting siloed data (jail calls, BWC, RMS) into automated leads, while Agent Kernel is a free, open-source tool for developers to give coding agents persistent memory using markdown files. Choose Truleo if you're a police agency needing to cut report-writing time and surface case leads; choose Agent Kernel if you're a developer who wants your AI agent to remember context across sessions without a database.
Alternatives to Agent Kernel
View allPMB
Local-first memory layer that gives your AI coding agent a SQLite file it can recall from between sessions.
Brain.Md
A persistent, file-based memory layer for coding agents that lives as a brain/ Markdown folder in your repo.
Agentmemory
Open-source memory runtime that gives coding agents persistent recall between sessions, stored on your machine.
Frequently Asked Questions
Categories
Used Agent Kernel? Help shape our editorial sentiment research.