Agent Kernel makes an AI coding agent stateful with four markdown files and a git clone

The entire setup is a clone and a launch

There is nothing to install. The quick start is three commands, and the third one is the agent you already use.

git clone https://github.com/oguzbilgic/agent-kernel.git my-agent
cd my-agent
opencode     # or claude, codex, cursor, etc.

The clone target name becomes the agent's name in practice, which is why the instructions clone into my-agent rather than into the default directory. After that, the described behaviour is that the agent reads the kernel, realizes it is new, and asks who you want it to be. You answer, and it remembers.

The list of compatible agents is stated as OpenCode, Claude Code, Codex, Cursor, Windsurf and others, and the second quick start uses a bare word in the third line rather than a specific binary, which is the whole point: the launch command is the only variable.

No package manifest, no dependency file, no lockfile and no configuration step appears anywhere in the repository listing. The top level holds exactly four files: AGENTS.md, IDENTITY.md, KNOWLEDGE.md and README.md. There is no source tree to build.

Four files, split by who edits them and when

The memory structure is the design, and it is worth reading closely because the annotations carry the rules.

AGENTS.md          ← kernel (generic, don't edit)
IDENTITY.md        ← who this agent is (agent maintains)
KNOWLEDGE.md       ← index of knowledge files (agent maintains)
knowledge/         ← facts about the world (mutable)
notes/             ← daily session logs (append-only)

AGENTS.md is labelled generic and marked do not edit. That is the kernel: the instructions that teach the agent how to remember, kept identical across every agent you create.

The two middle files are marked agent maintains, which means you set them up in conversation rather than by hand-editing them, and the agent keeps them current afterwards.

The two directories have opposite rules. knowledge/ holds state, facts about how things are right now, and the agent updates those when reality changes. notes/ holds narrative, what happened each session including decisions, actions and open items, and it is append-only and never modified after the day ends.

That asymmetry is the load-bearing part of the whole design. Current state can be corrected; the record of a session cannot.

It reuses the convention agents already follow

The stated reason this works is not novel file format engineering. AI agents already read AGENTS.md, or CLAUDE.md, or .cursorrules and similar files, as project instructions. This kernel uses that existing mechanism to teach the agent how to remember.

So the integration cost is a file the agent was going to read anyway. There is no plugin to register, no MCP server to configure, no API key, no model provider setting and nothing to import.

The claimed requirements are deliberately minimal: a file that says you are stateful and here is how, a git repo to store memory in, and plain markdown files. The README is explicit that the agent does not need a database, a vector store, or a custom framework, and that the repository ships exactly three markdown files plus a git repo, described in the opening as no framework and no database.

That framing has a consequence worth naming. There is no retrieval step, no embedding, no index rebuild and no query. An agent with a large notes/ directory reads files. Whether that stays cheap is a function of how many sessions accumulate, and nothing in the repository sets a retention policy or a compaction rule.

Each agent is a separate clone, not a shared brain

Creating a second agent is the same command with a different directory name.

git clone https://github.com/oguzbilgic/agent-kernel.git another-agent
cd another-agent
opencode     # or claude, codex, etc.

Each agent is its own repo. Same kernel, different identity, different knowledge, and the README gives three suggested roles: a homelab agent, an investing agent and a health agent, all running the same operating system.

The consequence is that isolation is the default and coordination is absent. Two clones share nothing. If the investing agent learns something the health agent needs, there is no mechanism in this repository to move it, and copying by hand is the only route.

That is a reasonable trade for a template whose cost is one command, but it means a multi-agent setup is a set of independent repos rather than a system. Anyone expecting shared state across agents will not find it here.

There is also a note about a related project that is worth separating carefully. The README points at kern-ai, described as a runtime built for agent-kernel with daemon mode, Telegram, Slack, and one brain across every channel, installed with npx kern-ai init my-agent followed by npx kern-ai tui. Those capabilities live in that separate repository, not in this one.

The repository has no releases, no licence file and one language entry

The repository metadata is thin in a way that matters for something you are meant to clone and rely on. There are no GitHub releases, so there is no version to pin: cloning gives you whatever is on the default branch, main, at the moment you run it.

The last commit is dated 2026-03-25 and the repository is not archived. Nothing has been pushed in the six months since, which for a project whose entire payload is four markdown files means the files are stable or the project is dormant, and the repository does not distinguish between the two.

No primary language is recorded and no licence identifier is populated in the repository metadata, yet the README states MIT as the licence. There is no LICENSE file in the top-level listing, so the licence text lives only in that README sentence rather than in the file most tooling looks for.

The project also has a homepage, agent-kernel.dev, which is not in the repository listing and so is not something this material describes.

The top-level listing being four files is also the honest signal about the project's size. There is no tests directory, no CI configuration and no scripts directory. The content is documentation, and documentation is exactly what an agent reads.

Editorial conclusion

Adopt Agent Kernel if you want an agent that carries state between sessions and you already use a coding agent that reads AGENTS.md, whether that is OpenCode, Claude Code, Codex, Cursor or Windsurf. The whole mechanism is a clone, and the memory model is plain markdown you can read and edit yourself. Do not adopt it expecting a runtime, a scheduler, or a shared brain between agents, because the repository ships four files and no code, and the daemon, Telegram and Slack support live in a separate project, kern-ai. Before you rely on it, check three things: that your agent actually reads AGENTS.md rather than a different filename such as CLAUDE.md or .cursorrules, that you have decided who edits IDENTITY.md and KNOWLEDGE.md since the kernel marks them as agent-maintained, and that you accept the append-only rule on notes/, which is the one part of the memory you cannot correct after the fact.

Frequently asked questions

Official sources

1. Issues
2. oguzbilgic/agent-kernel on GitHub
3. Project website
4. README