> ## Content Index
> Fetch the complete content index at: https://wire.fourthweb.ai/llms.txt
> Use this file to discover other available public pages before exploring further.

# COG Ships Self-Grading AI Agents That Store Memory in Markdown, Not Databases
- URL: https://wire.fourthweb.ai/cog-ships-self-grading-ai-agents-that-store-memory-in-markdown-not-databases/
- Published: 2026-11-16T09:01:36.000Z
- Updated: 2026-11-16T09:01:37.000Z
- Description: Someone just open-sourced the actual architecture for agents that grade each other's work instead of their own — and it lives in markdown files, not a database you can't leave.
- Author: Travis Wright
- Tags: AI Agent Economy, Agentic Workflows, AI Agents, AI Infrastructure, DeFi, OpenAI, Anthropic, Google AI, Funding Rounds

**Someone just open-sourced the actual architecture for agents that grade each other's work instead of their own — and it lives in markdown files, not a database you can't leave.**

### The Summary

- [COG-second-brain](https://github.com/huytieu/COG-second-brain?ref=wire.fourthweb.ai) is an open-source agent framework with 35 skills, 10 agents, and a "closed-loop harness" where workers never verify their own output — separate read-only agents do the grading
- Runs entirely on markdown files synced via Git and iCloud, zero vendor lock-in, works with [Claude](https://wire.fourthweb.ai/tag/anthropic/) Code, Cursor, Kiro, [Gemini](https://wire.fourthweb.ai/tag/google-ai/) CLI, and any AI that reads markdown
- Ships with anti-slop design skills for marketing and product UI, plus integrations to GitHub, Linear, Slack, and PostHog
- Two-minute setup, agent-agnostic architecture, built on the principle that verification should be structurally separate from execution

### The Signal

The hard problem in agentic systems isn't giving them more tools. It's keeping them honest. COG tackles this with what it calls a "V-model verification lifecycle" — workers execute, verifiers observe, and never the twain shall meet. The worker that writes the code doesn't grade the code. A separate read-only agent does. This maps to how actual engineering teams work: you don't review your own pull requests.

Most agent frameworks are black boxes wrapped in APIs. You pay per token, your data lives in someone else's database, and when the vendor pivots or raises prices, you're stuck. [COG runs on markdown files](https://github.com/huytieu/COG-second-brain?ref=wire.fourthweb.ai). Your knowledge graph is \`.md\` files in a folder. Your agent memory is \`.md\` files in a folder. Your tasks, contacts, and conversation history are \`.md\` files in a folder. Git handles version control. iCloud handles sync. Obsidian handles the human interface. You can grep your second brain. You can fork your second brain.

> "No database, no vendor lock-in — just .md files that think."

The framework ships 35 skills out of the box. Some are standard agent fare: research, summarization, task breakdown. But COG includes "anti-slop design skills" for marketing copy and product UI, explicitly positioning itself against the bland sameness of AI-generated content. The implication: agents need taste enforcement baked into the toolchain, not tacked on with a system prompt.

The agent-agnostic design is the real unlock. COG doesn't care if you're using Claude Code, Cursor, Kiro, Gemini CLI, or some local model running in your basement. Each platform gets a native surface — \`.claude/skills/\` for Claude Code, \`.kiro/powers/\` for Kiro, \`GEMINI.md\` for Gemini CLI. The core logic lives in \`AGENTS.md\` and markdown skill files. This is the opposite of the walled-garden approach most AI companies are building toward. You're not locked to a vendor. You're not even locked to a protocol. You're locked to a file format invented in 2004.

The people CRM angle matters more than it sounds. Most second-brain tools treat people as tags or backlinks. COG treats them as entities with context that agents can read and update. When an agent drafts an email, it can pull your last three interactions with that person, their role, the status of shared projects. This isn't Salesforce automation. It's agent-accessible relationship memory that lives in plaintext.

The GitHub trending list is noisy, but this one has design choices worth studying:

- Closed-loop verification separates execution from evaluation
- Markdown-first architecture means human-readable, version-controlled, grep-able agent memory
- Multi-agent compatibility without a shared API layer
- Explicit anti-slop tooling as a core feature, not an afterthought

### The Implication

If agents are going to build while you sleep, someone needs to be awake to check their work. COG's answer is: other agents, with different permissions, reading the same files. This is how you avoid the garbage-in-garbage-out spiral that kills most agentic workflows after the demo.

For builders, the markdown-native approach is a blueprint. You don't need a vector database and a proprietary API to ship agent infrastructure. You need a good file format and a separation of concerns. The fact that this works across five different agent platforms suggests the future isn't one dominant agent runtime — it's interoperable markdown surfaces that any LLM can read.

For everyone else: watch what happens when people can fork, modify, and self-host their agent tooling. The closed platforms will have better UX for six months. The open ones will have better longevity forever.

### Sources

[GitHub Trending Python](https://github.com/huytieu/COG-second-brain?ref=wire.fourthweb.ai)