The Evolving Agent: How Jean2 Learns Across Sessions

A developer built Jean2, an AI coding agent that accumulates knowledge across sessions by writing to markdown files on disk instead of relying on vector databases or fine-tuning. The agent features four persistent knowledge layers—workspace memory, agent memory, workspace skills, and agent skills—each stored as plain files that the agent reads and writes itself. Users opt in to each layer via workspace settings, allowing them to build a customized agent that remembers project conventions and personal preferences over time.

I've been coding with AI agents for about two years. Every major one. Cursor, Copilot, Codex, OpenCode. They're good at generating code. They all share one problem. They forget everything. You finish a session, close the window, and the agent resets. Next time you open it, you're starting from zero. "We use pnpm, not npm." "The database is SQLite, not Postgres." "Don't touch the migrations folder." You repeat yourself. Every. Single. Time. Some tools added memory features. Usually as an afterthought. A pinned file. A custom instruction. A context window that grows until it hits a wall and everything old gets silently dropped. I didn't want a bigger context window. I wanted an agent that accumulates knowledge the way a colleague does. Not by being retrained. By taking notes, writing down what it learned, and reading those notes next time. That's what Jean2 can do. Not through fine-tuning. Not through vector embeddings. Through files on disk that the agent reads and writes itself. But here's the thing: none of this is on by default. By default, Jean2 is as bare as Codex or OpenCode. A blank prompt. No memory. No skills. No session search. You opt in to each layer in workspace settings. That's the point. You build the agent you want, layer by layer. If you turn them on, Jean2's agent has four knowledge layers that persist across sessions. They're not features bolted on top. They're part of the system prompt that gets composed every time a session starts. Turn on workspace memory in workspace settings , and the workspace gets two files: MEMORY.md for shared knowledge and USER.md for your personal preferences within that workspace. Both live at <workspace /.jean2/ . The concept is simple. Shared knowledge that's useful for any agent working in that workspace. "We use pnpm." "The database is SQLite." "Don't touch the migrations folder." Whatever agent you bring in, coding specialist, reviewer, docs writer, they all get the same context. Workspace Memory - Build system: pnpm not npm, not yarn - Database: SQLite via bun:sqlite - Test runner: bun:test for server/tools, vitest for client - Never modify files in packages/sdk without updating version.ts - The migrations folder is managed by a separate script. Don't auto-generate migrations. The agent writes this itself. You don't manage it manually. When it learns something worth remembering, it saves it. When it makes a mistake and you correct it, it saves the correction. It's not fancy. There's no vector database, no embedding pipeline. It's a markdown file on disk. And it works. Same concept. Same two files: MEMORY.md and USER.md . Different scope. Each agent in Jean2 has its own home directory: ~/.jean2/agents/<agent-name / . The memory lives there. This is where the agent evolves its role . Its specialization. Its understanding of how it should work. Workspace memory is shared context: "this project uses pnpm." Agent memory is identity: "I am the TypeScript specialist, and here's what I've learned about how Daniel likes his code." It travels with the agent across every workspace it participates in. The agent maintains these with the agent memory tool. Same mechanism as workspace memory, just a different relationship to the knowledge. Same split as memory. Workspace scope, agent scope. Workspace skills live in <workspace /.agents/skills/ . Shared playbooks for any agent working in that workspace. "This is how we deploy." "This is our code review process." Whatever agent you bring in picks them up. Agent skills live in the agent's home directory. They travel with the agent's role. "This is how I debug TypeScript." "This is my approach to refactoring." They belong to the agent, not the project. Both are SKILL.md files. Procedural playbooks the agent can discover and load when relevant. The skill tool lets it read existing skills. The skill manage tool lets it create new ones . You have to enable skill management for the agent to use them. Here's what that looks like in practice: deployment-checklist.md skill. Deployment Checklist When to Use Before deploying to production or staging. Steps 1. Run bun run typecheck . Must pass. 2. Run bun run lint . Must pass. 3. Run bun run test . All suites. 4. Check packages/server/src/version.ts matches changelog. 5. Verify the binary builds locally: bun run build:bin . That's a real skill from my own setup. The agent wrote it. I didn't ask it to. It noticed the pattern and saved it. Same split. Workspace scope, agent scope. Workspace scope : any preconfig or agent working in a workspace can search through all sessions in that workspace. "Did someone already solve this in this project?" Agent scope : the agent can search through sessions it participated in, regardless of which workspace they happened in. "Have I seen this kind of problem before, anywhere?" One tool, session search , powered by SQLite FTS5. Turn it on, and the agent searches its own history: "Last week I worked on a WebSocket reconnection bug. Let me search for that." The agent finds the relevant session, reads what it tried, what worked, what didn't. Then applies that knowledge to the current problem. Without you having to explain the history. The four layers don't exist in isolation. They feed each other. The result is an agent that gets better the more you use it. Not because the model improved. Because the files got richer. On day 1, your Jean2 agent is a blank slate. It knows nothing about your project, your preferences, or your workflow. It's capable, same model, same tools, but it has no context. And it stays that way unless you choose to evolve it. On day 30: The model didn't change. The knowledge accumulated. On disk. In files you can read, edit, version control, and share. That is what "evolving agent" means. Not a model that retrains itself. An agent that takes notes. But only because you opted in. You could also leave it bare and it would work like any other coding agent. Jean2 is at v1.1.0 . Still in active development, but very usable. I've been coding with it every day for months. The agent that helps me today is noticeably better than the one I started with, because it's been accumulating skills and memory the whole time. If this sounds interesting, try it out https://jean2.ai . Got questions about how memory or skills work? Join the Discord https://discord.com/invite/38sUKnUNPQ or hit me up at @danielbilekq0 https://twitter.com/danielbilekq0 . This post originally appeared on jean2.ai. Star the project on GitHub.