clo for every agent

Turn how people work into reusable mentor skills

CLO is the memory layer for coding agents. Cursor, Codex, Gemini CLI, Claude Code, and any MCP host connect to the same MCP endpoint over Streamable HTTP. The installer also teaches the local agent the CLO loop: load relevant mentor guidance, turn meaningful work into a skill, ask for approval, then save it back to Cognition.

The important shift: this is not tied to one model. Whatever AI the person already uses becomes the one that distills their decisions, taste, debugging path, and hard-won workflow into a reusable skill. Later, someone else can ask for that person's help and their own AI can pull the skill from CLO as over-the-shoulder guidance.

step 1

Agent learns

At task start, the agent calls cognition_assist for relevant people, skills, and context.

step 2

Person approves

At wrap-up, the agent drafts the skill and shows the user before saving anything.

step 3

CLO teaches

Another agent later pulls that person's pattern and applies it like a mentor in the room.

MCP URL

https://www.cognitionus.com/api/integrations/claude-code/mcp/v1

Auth: Authorization: Bearer <cog_me_* or cog_live_*>

Cursor

Add to global ~/.cursor/mcp.json (or project .cursor/mcp.json). Set COGNITION_KEY in your environment before starting Cursor so ${env:COGNITION_KEY} resolves. See Cursor MCP docs.

The installer also writes ~/.cursor/rules/cognition.mdc, so Cursor knows to call cognition_assist and cognition_save_skill during normal work.

{
  "mcpServers": {
    "cognition": {
      "url": "https://www.cognitionus.com/api/integrations/claude-code/mcp/v1",
      "headers": {
        "Authorization": "Bearer ${env:COGNITION_KEY}"
      }
    }
  }
}

One-liner (bash / Git Bash): COGNITION_KEY=cog_me_xxx curl -fsSL https://www.cognitionus.com/api/install/cursor | sh

PowerShell (Git's bash): $env:COGNITION_KEY="cog_me_xxx"; & "$env:ProgramFiles\Git\bin\bash.exe" -lc "curl -fsSL https://www.cognitionus.com/api/install/cursor | sh"

OpenAI Codex (CLI / IDE)

Configure in ~/.codex/config.toml or run codex mcp add. Export COGNITION_KEY in the environment where Codex runs. Reference: Codex MCP.

The installer writes global instructions to ~/.codex/AGENTS.md. Codex reads that file at session start, so every repo inherits the CLO mentor-memory loop.

[mcp_servers.cognition]
url = "https://www.cognitionus.com/api/integrations/claude-code/mcp/v1"
bearer_token_env_var = "COGNITION_KEY"
enabled = true

CLI (non-destructive if block already exists): codex mcp add cognition --url https://www.cognitionus.com/api/integrations/claude-code/mcp/v1 --bearer-token-env-var COGNITION_KEY

Installer: COGNITION_KEY=cog_me_xxx curl -fsSL https://www.cognitionus.com/api/install/codex | sh

Google Gemini CLI

Add Cognition to ~/.gemini/settings.json under mcpServers. Export COGNITION_KEY before launching Gemini CLI. Gemini loads global instructions from ~/.gemini/GEMINI.md, where the installer writes the CLO operating rule.

{
  "mcpServers": {
    "cognition": {
      "httpUrl": "https://www.cognitionus.com/api/integrations/claude-code/mcp/v1",
      "headers": {
        "Authorization": "Bearer ${COGNITION_KEY}"
      },
      "trust": false
    }
  }
}

Installer: COGNITION_KEY=cog_me_xxx curl -fsSL https://www.cognitionus.com/api/install/gemini | sh

Claude Code and other agents

Claude Code uses the same default installer at /api/install. It registers Cognition MCP and writes the same operating rule into ~/.claude/CLAUDE.md. Any other MCP-capable host can use the same URL and Bearer scheme; add the rule below to that agent's instruction file.

## Cognition CLO Mentor Memory

Cognition is the mentor-memory layer for this coding agent. Use the connected `cognition` MCP server as the shared brain.

- At the start of a meaningful coding task, call `cognition_assist` with the user's intent and relevant file paths. Apply returned mentor skills as over-the-shoulder guidance, and mention whose pattern you are borrowing when it matters.
- If the user asks for help from a specific person, teammate, founder, or mentor, call `cognition_assist` with that person's name and the task. Use the returned skill/context to guide both the user and the agent.
- When a session produces reusable judgment, draft a skill before wrapping up. Capture what the person did, the decisions they made, rejected alternatives, debugging path, taste/heuristics, and any commands or files that mattered.
- Always show the user the proposed SKILL.md first. Only after they approve, call `cognition_save_skill` to store it in CLO under that person's identity.
- Keep skills practical: include `# When to fire`, `# Steps`, and `# Why it works`. Prefer concrete paths, commands, and decision rules over generic advice.
- Do not upload secrets, private keys, raw environment values, or unrelated personal data. Summarize sensitive context instead of copying it.

What gets saved

CLO skills are small, practical mentor artifacts. They capture a person's judgment: what they did, what they ruled out, why the decision worked, and when another agent should reuse it.

# When to fire
- When debugging a webhook that passes locally but fails in production.

# Steps
1. Reproduce the failing request with the exact production headers.
2. Check signature verification before touching business logic.
3. Compare the raw body path against the framework's JSON parser.

# Why it works
Vedant treats webhook bugs as trust-boundary bugs first, not routing bugs. He rules out signature/body mutation before changing handlers, which avoids masking the real failure.

Start Claude Code install