# I Built Genesis: The First Brain for AI Agents (Agent-skills) > Source: > Published: 2026-08-10 13:35:36+00:00 AI coding agents are getting better at writing code. But there is still a problem I keep seeing: **Every new agent session starts by rediscovering the project.** It has to figure out the architecture. It has to discover conventions. It has to understand previous decisions. It has to learn how the team works. And after the session ends, a lot of that understanding disappears. So I built something to address that problem. **Genesis.** [GitHub — raiyanu/agent-genesis](https://github.com/raiyanu/agent-genesis) [Skill.sh — raiyanu/agent-genesis](https://www.skills.sh/raiyanu/agent-genesis/agent-genesis) Genesis is a **project-local cognitive layer for AI agents**. I think of it as the **first brain of an agent**. Before an agent starts working on a project, Genesis gives it a structured way to: The core idea is simple: Understand before acting. Learn while working. Remember for the next agent. The workflow looks like this: ``` Genesis ↓ Understand ↓ Plan ↓ Execute ↓ Learn ↓ Remember ↺ ``` The important part is the last step. The agent doesn't just finish a task. It can leave behind **knowledge that makes the next session better**. I didn't want Genesis to depend on a particular AI provider, IDE, or agent runtime. The knowledge belongs to the **project**. That means it can live alongside the codebase and be version controlled with Git. A simplified structure looks like: ``` .agents/ ├── SKILL.md └── agent_md/ ├── project-learn.md ├── user-learn.md ├── domains/ ├── patterns/ ├── decisions/ └── debugging/ ``` This makes project knowledge: Imagine three developers working on the same project. Developer A teaches an AI agent about an important architectural decision. Developer B starts a new session tomorrow. Without persistent knowledge, the agent may have to rediscover that decision. With Genesis, the project can retain it. ``` Developer A ↓ Agent ↓ Discovers Knowledge ↓ Genesis ↓ Project Memory ↓ Developer B ↓ Agent ↓ Starts with that knowledge ``` The project gradually becomes better at communicating with its agents. This is an important distinction. I don't see Genesis as simply a memory folder. Memory is only one part of it. Genesis is about the **agent's relationship with the project**: **Before the task** Understand what already exists. **During the task** Follow the project's architecture and conventions. **After the task** Identify what was learned and preserve knowledge that can help future work. That creates a continuous learning loop. I intentionally kept the foundation simple. No database. No vector store. No proprietary format. Just files that humans and AI agents can both understand. That gives the knowledge the same benefits as source code: ``` Git ↓ Versioning ↓ Review ↓ History ↓ Collaboration ``` Project knowledge becomes part of the project itself. I think we're moving toward a world where projects won't just contain source code. They will also contain **context for the agents working on that source code**. Today we have: ``` Source Code Documentation Tests Configuration ``` I think we'll increasingly have: ``` Source Code Documentation Tests Configuration Agent Knowledge Agent Instructions Agent Decisions ``` The goal isn't to make agents magically smarter. It's to make sure they **don't have to forget everything every time they start**. After using Genesis in my own agent workflow, I noticed a significant reduction in the time spent on project discovery and repeated context-building. For my workflow, it was **roughly 80% faster** to get an agent into a productive state. The important part isn't that Genesis makes the AI model itself faster. It reduces the repeated work around the model: ``` Without Genesis Agent → Explore → Rediscover(grepping 10+ function and reading 1200+ lines of code) → Understand → Start Working With Genesis Agent → Load Context → Understand → Start Working ``` That difference becomes especially noticeable when working across multiple sessions or switching between CLI and IDE agents. The agent doesn't have to start from zero every time. It starts with what the project has already learned. For every Module, First prompt was slower but second prompt doesnt matter if it's different session or account or agent or system it become faster than before. for my ecommerce project it improved agent time in searching for code from 2-3 minute to 20 seconds. The name comes from the idea of a beginning. Genesis is the point where the agent starts. Not with assumptions. Not with a blank context. But with the knowledge the project has already accumulated. Every agent session should start smarter than the previous one. Genesis is my first step toward that idea. The project is open source, and I'm interested in seeing how this concept evolves with the rapidly changing AI-agent ecosystem. If you're building CLI agents, IDE agents, coding agents, or autonomous development workflows, I'd love to hear how you're solving the **persistent context problem**.