Generated banner for Third Brain V8.1 Skills
Generated logo for Third Brain V8.1 Skills

Third Brain V8.1 Skills

LLM wiki kit

First committed by Mark393295827

Published in Mark393295827/third-brain-v7-skills. Publisher page

140 GitHub stars

What it is

agent wiki +engineering skills
— the description by Mark393295827

AutoGineer overview, from the brain’s own files

Third Brain V8.1 provides a structured, verification-first operating model for AI agents, treating the LLM as a CPU, context as RAM, and an Obsidian vault as a durable disk. It offers 21 reusable agent skills designed to manage knowledge ingestion, daily loops, research, and multi-agent orchestration. The system enforces strict provenance, governance, and quality gates, ensuring that agent actions are backed by evidence and that knowledge compounds over time through a structured taxonomy.

How it works

Memory model: LLM wiki

AutoGineer overview, from the brain’s own files

The system organizes information into a structured folder hierarchy including sources, concepts, entities, and maps. It uses a 5-stage worker assembly pipeline (Ingest, Cognitive, GraphWeaver, Governance, Deliverable) to process information. Skills are executed as programs within a harness that provides scheduling, permissions, and observability. It relies on a transactional runtime to manage state and ensure that all knowledge updates are verified and linked within the Obsidian vault.

Folders
FolderRoleFiles
.githubagent-config5
assetsattachments5
commandsagent-instructions4
docsdocs21
examplesexamples10
hookshooks1
skillsagent-instructions40
sourcesraw-sources13
teststests8
toolsscripts51
adaptersfolder2
artifactsfolder28
contractsfolder18
corefolder6
experimentsfolder7
mapsfolder1
outreachfolder46
systemfolder33
workflowsfolder1

Requirements

Works with: Claude Code, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Amp, Cline, JetBrains Junie, Devin (ex-Windsurf)

Set it up

  1. This brain runs code automatically: 2 scripts. Review install.ps1, install.sh before opening the folder in Claude Code. No step below turns a hook on for you.

    • install.ps1: pwsh install.ps1
    • install.sh: sh install.sh
  2. Clone the repository at the commit AutoGineer scanned:

    git clone https://github.com/Mark393295827/third-brain-v7-skills.git && cd third-brain-v7-skills && git checkout 5a645148a108d71c76521715117b737ae60b1423
  3. Claude Code reads CLAUDE.md from this folder automatically.

  4. cd third-brain-v7-skills && claude

  5. AutoGineer scanned these files at commit 5a64514.

  6. First committed by Mark393295827. Published in Mark393295827/third-brain-v7-skills. Licence: MIT License.

Usage

AutoGineer overview, from the brain’s own files

  • Ingesting research papers or articles into a linked wiki
  • Running daily knowledge loops to compound insights
  • Enforcing verification gates before claiming task completion
  • Orchestrating multi-agent teams with isolated write scopes
  • Managing context budgets and state checkpoints for long-running tasks
“Use wiki-ingest on this source. Stage an immutable source, author a governed concept candidate, plan navigation updates, and return a verification summary.”
The agent creates an immutable note in the sources folder, updates the relevant concept pages in the wiki, and provides a summary of the verification steps taken.
“Run the daily-okr skill for today.”
The agent executes the 7-KR cycle, generating a daily insight, updating the wiki, and producing a receipt for the completed work.

Documentation by Mark393295827

Third Brain V8.1 Skills

<p align="center"> <img src="assets/third-brain-v8.1-actual-system-architecture.png" alt="Third Brain V8.1 actual Codex OS architecture: Codex host, repository control plane, transactional worker runtime, live Obsidian Vault, verification evidence, and declared debt" width="900"> </p>

Verification-first Agent Skills for Codex OS, with optional compatibility adapters for Claude Code, Gemini, Cursor, and Windsurf. Build a persistent knowledge operating system with Obsidian provenance, scheduled loops, bounded static dependency graphs, context management, and multi-agent orchestration.

Install 21 reusable agent skills for ingesting sources, auditing workflows, compiling interlinked wikis, running daily knowledge loops, verifying claims before shipping, managing token costs, engineering bounded loops and static dependency graphs, and orchestrating multi-agent teams.

Use this if:

  • Your AI agent keeps forgetting context between sessions

  • You want to enforce verification gates before "done" claims

  • You need to structure knowledge as linked pages (like Obsidian) instead of scattered chat history

  • You're building agent workflows that should learn and compound over time

  • You want Obsidian wiki knowledge to update skills, SOPs, schemas, and automation through supervised promotion gates

Image: GitHub stars Image: License: MIT Image: Codex OS Image: Claude Code Image: Cursor Image: PRs Welcome


Quick Start

1. Clone & Install
git clone https://github.com/Mark393295827/third-brain-v5-skills.git
cd third-brain-v5-skills
bash install.sh codex  # Codex is the primary host/kernel

Windows PowerShell uses .\install.ps1 codex. Compatibility adapters require an explicit non-Codex target.

2. Try a Skill

Paste this into Codex:

Use wiki-ingest on this source. Stage an immutable source, author a governed concept candidate, plan navigation updates, and return a verification summary. Treat entity authoring as a separate reviewed capability.

Then paste a URL, article, PDF text, or any source you want to capture.

3. Next Steps

See the 3-Minute Quickstart for a complete walkthrough.

Full guide: GUIDE.md

Command centre and distribution: V8.1 Codex Agentic OS command centre. Start it with python tools/agentic_os_server.py --state-root .agentic-os-state; the host is localhost-only by default and requires T02 runtime receipts. Claude/Gemini/Cursor/Windsurf remain compatibility adapters, not the primary runtime.

中文历史进阶手册:V7 最大潜力使用手册(参考)

🔥 V8.1 多智能体 Worker 流水线手册 & Worker Flows 规范:事务式流水线(Stage → Author → Graph Plan → Govern → Commit/Postcheck → optional Deliverable),归档只发生在验证提交之后。


The Problem

ScenarioBeforeAfter
Research PDFSummarized once, then forgottenwiki-ingest: source notes, concept pages, linked wiki
Coding sessionAgent: "I fixed it" (no proof)verify-before-claim: requires test output + exit code before any claim
Daily workTasks and ideas scatter across chatdaily-okr: one insight, one wiki update, one action, one output, daily score

V8.1 Operating Model

V8.1 keeps the wiki as durable disk and governance, gives every skill a profile-aware execution contract, and makes python -m tools.worker_flow.cli the only canonical transactional runtime:

Input -> Source -> Wiki compile -> Daily loop -> Agent/Wiki flywheel -> Skill/SOP upgrade -> Verification

The upgrade adds seven hard defaults:

  • Profiles match risk: one-shot, stateful, loop, and high-risk work load only the controls they need.

  • Source provenance stays immutable: raw source notes and block refs remain the audit layer.

  • Loops have contracts: Trigger -> Execute -> Verify -> State, with budgets and recovery.

  • Context is zero-overhead by default: hot paths load only what the task needs.

  • Automation is bounded: scans and queues can run unattended; semantic writes stay supervised.

  • Teams need ownership: multi-agent work requires write scopes, IPC, join gates, cleanup, and evidence.

  • Rules promote through evidence: wiki insights become schema or skill rules only after repeated support and a cheap check.

See the V8.1 Worker Flow, the Agent Skills standard, and the historical V7 release notes.

V8.1 keeps graph-engineering bounded to static DAGs; dynamic expansion and cyclic graphs remain out of scope.


Core Skills (Start Here)

🧠 Knowledge & Verification
SkillWhat it does
wiki-ingestPreserve an immutable source, compile linked understanding, enforce promotion boundaries, and verify every touched file.
verify-before-claimIron rule: no completion claim without fresh, scope-matched evidence; consequential actions also require independent verification, approval, and rollback.
📅 Daily Loop
SkillWhat it does
daily-okrExecute a 7-KR cycle: Input → Cognition → Wiki → Behavior → Creativity → Output → Feedback, with an artifact or receipt for every completed KR.
🎯 Behavior & Creativity
SkillWhat it does
behavior-designTurn outcomes into observable minimum behavior, cues, SOPs, recovery, evidence, and review.
creativity-engineGenerate mechanism-diverse options, rank evidence gaps, and define three bounded minimum experiments.
🔬 Research & Quality
SkillWhat it does
deep-researchSTOW-compatible research harness with evidence trails, source/claim ledgers, privacy checks, and direct handoff to wiki-ingest.
session-learnExtract knowledge patterns from sessions — concepts, entities, corrections, patterns, ideas, decisions, gaps. Closure protocol ensures learning feeds back into the wiki.
📊 Context & Engineering
SkillWhat it does
context-managerDerive budgets at runtime, checkpoint state, compact with KEEP/SUMMARIZE/DROP/RETRIEVE, and route by capability.
loop-engineeringControl temporal depth: turn repeatable work into a bounded Trigger -> Execute -> Verify -> State loop with durable state, finite budgets, and explicit stop/recovery rules.
graph-engineeringControl dependency width: validate bounded static DAGs with explicit dependencies, independent branches, typed joins, and node-local recovery.
agentic-engineeringDesign agent workflows as spec-driven macro actions with quality ceilings, verification gates, delegated-action boundaries, and state checkpoints.
harness-engineeringProvide the runtime scheduler, permissions, leases, tools, provenance, and observability needed to execute agent workflows safely.
agent-teams-commandAdmit and command multi-agent processes with exclusive ownership, typed IPC, isolated writes, serial integration, evidence, and cleanup.

Complete Skill List

📥 Ingestion & Knowledge
  • wiki-ingest — Stage immutable sources, author governed concept candidates, plan graph updates, and hand off optional entity authoring for separate review

  • knowledge-ops — Multi-layer knowledge management: classify, deduplicate, preserve evidence hierarchy, vector + Markdown retrieval

  • wiki-lint — Health check: P0/P1 graph health, frontmatter, source refs, wikilink density, provenance debt

🔄 Daily Workflow
  • daily-okr — 7-KR evidence cycle with minimum-day degradation and durable closeout

  • cognitive-compile — 8-section framework: Question → Facts → Concepts → Pattern Recognition → Conflict Detection → Hypothesis Generation

🎨 Behavior & Creativity
  • behavior-design — Outcome → minimum behavior → cue → SOP → evidence → review

  • creativity-engine — Mechanism-diverse combinations, scoring, and falsifiable minimum tests

🔬 Research & Quality
  • deep-research — STOW-compatible research harness, evidence trails, source/claim ledgers

  • verify-before-claim — Fresh scope-matched evidence, independent checks, approval, rollback

🔄 Learning & Flow
  • session-learn — 7 signal types: concepts, entities, corrections, patterns, ideas, decisions, gaps

  • project-flow-ops — Execution flow: triage, plan, track, review across projects

📊 Context
  • context-manager — Runtime budgets, checkpoint replay, compaction, retrieval, capability routing

Utility command: commands/token-cost-tracker.md estimates, logs, and reports token usage; it is not one of the 21 Agent Skills.

🏗️ Engineering
  • loop-engineering — Temporal depth through bounded loop contracts, independent verification, finite budgets, and stop/recovery rules

  • graph-engineering — Dependency width through bounded static DAGs, explicit branches, typed joins, and node-local recovery

  • agentic-engineering — Spec-driven macro actions, quality ceilings, verification gates, state checks

  • harness-engineering — Runtime scheduler, permissions, system-call tools, delegated gates, provenance, observability

  • agent-teams-command — Multi-agent process ownership, IPC, integration, async budgets, and evidence gates

💼 Strategy & Operations
  • startup-evaluation — Startup health: entrepreneurship, VC 5T, PMF, runway, team, unit economics

  • anthropic-os — Governed operating-system experiments: Four-C, 3B, prediction errors, permission ladder

  • ai-six-sigma-property-os — AI + Ontology + DMAIC for property work orders, dispatch, quotes, evidence


How These Skills Fit Together

                        LLM (CPU) + Context (RAM) + Wiki (Disk)

External Sources ──→ wiki-ingest + knowledge-ops ──→ Knowledge Layers
                            ↓
                    Daily Loop (daily-okr)
                    /    /    \    \    \
               Input  Cognition  Wiki  Behavior  Creativity
                            |
                        Output → Feedback
                            ↓
                    session-learn (extract patterns)
                            ↓
                    verify-before-claim (quality gate)
                             ↓
             Loop depth / Graph dependency width
                             ↓
                Multi-agent teams (agent-teams-command)

The system is a closed loop: ingest sources → process daily → extract learning → verify claims → promote rules → scale to teams.


Architecture & Design

Third Brain V8.1 treats agents as LLM OS processes:

  • LLM = CPU

  • Context = RAM

  • Wiki/Obsidian = Disk

  • Tools = System calls

  • Skills = Executable programs

  • Harness = Kernel

  • Agent teams = Processes

Design Layers
LayerPrincipleSkills
🧠 Knowledge OSCapture, structure, lint, and promote knowledge over timewiki-ingest, knowledge-ops, wiki-lint
⚡ Daily LoopClose the knowledge-to-action cycle every daydaily-okr, cognitive-compile
🎯 Behavior & CreativityTurn knowledge into habits and novel ideasbehavior-design, creativity-engine
🔬 Research & QualityVerify before claiming, research with rigordeep-research, verify-before-claim
🔄 Continuous LearningExtract patterns from every sessionsession-learn, project-flow-ops
📊 ContextManage hot context, durable checkpoints, and runtime budgetscontext-manager
🏗️ EngineeringDesign bounded loops, static dependency graphs, harnesses, agent workflows, and multi-agent systemsloop-engineering, graph-engineering, agentic-engineering, harness-engineering, agent-teams-command
💼 Strategy & OperationsEvaluate startups, design AI quality systemsstartup-evaluation, anthropic-os, ai-six-sigma-property-os

Engineering boundaries are deliberate: Loop Engineering controls temporal depth; Graph Engineering controls dependency width; Agent Teams Command controls process ownership, IPC, and integration; Harness Engineering supplies the runtime scheduler, permissions, and observability. A graph node may contain a Loop or Agent Team, but V8.1 does not support dynamic or cyclic graphs.


Skill Adoption Path

Start small. Add skills as you need them.

StageCore SkillsUnlock When
Week 1wiki-ingest + verify-before-claimYou can ingest 1 source/day + every claim has fresh evidence
Weeks 2-4+ daily-okr + session-learnDaily artifacts and verified learnings feed back to the wiki
Month 2++ cognitive-compile + behavior-design + creativity-engineWiki has 50+ pages or repeated decisions need synthesis
Month 3++ knowledge-ops + loop-engineering + harness-engineering + agentic-engineeringRetrieval, looping reliability, permissions, or delegated actions become bottlenecks
Dependency graph+ graph-engineering after loop-engineeringExplicit dependencies, independent branches, typed joins, or node-local recovery create more value than orchestration and review cost
Multi-agent+ agent-teams-command + project-flow-opsWork splits into separate owners with clear integration gates
Strategy+ startup-evaluation + anthropic-os + deep-researchNeed startup health, market, operating-system decisions
Operations+ ai-six-sigma-property-osNeed measurable service quality, dispatch, evidence loops

Installation

For Codex CLI (Primary host/kernel)
# Personal skills (available across all projects)
bash install.sh codex
For Cursor
bash install.sh cursor
For Windsurf
bash install.sh windsurf
Compatibility adapters: Claude Code / Gemini CLI
bash install.sh claude
bash install.sh gemini

Full guide: GUIDE.md


Example Workflows

Each workflow is copyable into your agent. See examples/ for complete, verified examples:


Wiki Structure

Skills default to STOW paths (configurable via system/config.md):

sources/          ← Immutable source notes (articles, PDFs, transcripts)
wiki/
├── concepts/     ← 13 contracted domains
├── entities/     ← people, companies, funds-investors, products, orgs
└── outputs/      ← gmail-digests, evaluations, compilations
maps/
├── domain-mocs/
├── system-indexes/
├── project-maps/
└── canvases/
system/           ← Deployed contracts, config, schema, templates, runs

Tools & References

ResourcePurpose
tools/index.htmlV8.1 visual skill navigator
tools/token-calculator.htmlHistorical V5 cost-model calculator; not a runtime authority
GUIDE.mdFull installation & troubleshooting
V7 最大潜力使用手册(历史参考)Earlier profile、知识飞轮、Agent 工程、治理和 30 天采用路径
CLAUDE.mdClaude Code setup
CONTRIBUTING.mdHow to contribute skills

What This Is NOT

  • Not a chat wrapper. Skills are executable prompts that agents follow; they're not productivity theater.

  • Not a productivity tool with 100 metrics. Daily OKR has seven causally linked KRs with evidence.

  • Not an all-in-one framework. Pick skills incrementally. You don't need all 20 to start.

  • Not prescriptive. Adapt paths, frontmatter, and skill triggers to your workflow.


Philosophy

Three core principles:

  1. Verification first: No "done" without proof. No claims without evidence. Expected value over confidence.

  2. Knowledge compounds: Every session should improve the wiki, not scatter across chat history.

  3. Closed loops: Ingest → Process → Learn → Scale → Verify. No loose ends.



Contributing

Bug reports, skill improvements, and PRs are welcome. See CONTRIBUTING.md and CHANGELOG.md.


License

MIT — see LICENSE.


Transparency Note

This project includes growth and outreach tools (in tools/ and outreach/) designed to help the repository reach users via GitHub search and Awesome lists. These tools are optional, dry-run-by-default, and separate from the core skills. If you're installing skills for your own workflow, you don't need them.

The skill frameworks and philosophy are genuine. Use what works for you; ignore what doesn't.

GUIDE.md

Third Brain V8.1 Skills — Installation & Usage Guide

21 profile-aware skills for a persistent Codex knowledge and agent execution system. Claude Code, Gemini CLI, Cursor, and Windsurf are optional compatibility adapters.

Codex is the primary host/kernel for V8.1. The other harnesses are compatibility adapters and must be selected explicitly when Codex is not the host.


Table of Contents

  1. Installation

  2. Platform Setup

  3. Quick Start Wizard

  4. Skill Reference

  5. Workflow Scenarios

  6. Daily Routine

  7. Advanced Configurations

  8. Troubleshooting


1. Installation

Codex Agentic OS command centre

After installing the Codex skills, run python tools/agentic_os_server.py --state-root .agentic-os-state and open http://127.0.0.1:8765/. The command centre reads /api/snapshot from the T02 runtime and displays real evidence only. It disables host-dependent actions and treats only a terminal receipt whose verifier is PASS as success. See docs/agentic-os-command-center.md for packaging, readiness, and the separately approved Codex Vault AGENTS.md sync.

Prerequisites
  • Codex CLI as the primary host/kernel, or an explicitly selected compatibility adapter

  • Git (git --version)

  • Python 3.8+ (for linting, loop validation, token-cost utility, and optional vector adapters)

  • Bash, or PowerShell 5.1+ on Windows, for the installer

  • Obsidian (recommended for wiki knowledge base)

One-Line Install
# Clone the repository
git clone https://github.com/Mark393295827/third-brain-v5-skills.git
cd third-brain-v5-skills
git switch main
bash install.sh

Windows PowerShell:

.\install.ps1
.\install.ps1 codex

Explicit targets:

bash install.sh codex
bash install.sh claude
bash install.sh gemini
bash install.sh cursor
bash install.sh windsurf
bash install.sh all

Use the same targets with .\install.ps1 <target> on Windows.

Install for Your Platform
Codex CLI (Primary host/kernel)
# Personal skills (available across all projects)
bash install.sh codex

# Verify installation
ls ~/.agents/skills/ | wc -l
# Expected output: 21
Claude Code (Compatibility adapter)
bash install.sh claude
Gemini CLI
bash install.sh gemini
Cursor

Cursor support uses a project-rule adapter that routes requests to the skills/*/SKILL.md files kept in this repository.

bash install.sh cursor
Windsurf / Cascade

Windsurf can use these as native workspace skills, with an optional routing rule.

bash install.sh windsurf

For details, see docs/compatibility.md.

Claude command adapter (Optional compatibility path)
# Copy command files for token tracking
cp commands/* ~/.claude/commands/

2. Platform Setup

2.1 Graph Engineering (Optional)

Use graph-engineering for dependency width only when explicit dependencies, independently executable branches, typed joins, or node-local recovery justify more orchestration and review cost than a serial workflow. V8.1 accepts bounded static DAGs; it rejects dynamic expansion and cyclic graphs.

2.2 Agent Teams (Optional)

First inspect whether the installed runtime exposes isolated workers, task state, and integration controls. Product/version-specific flags belong in local runtime configuration, not durable skills. If workers are unavailable, use one agent plus an independent verifier.

Use agent-teams-command only after its admission gate shows that independent workstreams justify coordination and review cost.

2.3 Wiki Path Configuration

The canonical runtime reads contracts/vault-contract.json; deployed Vaults receive the versioned copy at system/contracts/v8.1/vault-contract.json. system/config.md is a readable summary, not the machine authority. Resolve the explicit Vault root and inspect a staging plan before any write-heavy operation.

Create the default layout when starting a new vault:

mkdir -p sources/{"$(date +%Y-%m)",pre-2026,books}
mkdir -p wiki/concepts/{ai-engineering,ai-economics,ai-science,behavioral-econ,business-strategy,entrepreneurship,general-concepts,geopolitics-energy,identity-culture,investing-macro,investing-quant,investing-vc,knowledge-systems}
mkdir -p wiki/entities/{people,companies,funds-investors,products,orgs}
mkdir -p wiki/outputs/{gmail-digests,evaluations,compilations} wiki/sops
mkdir -p maps/{domain-mocs,system-indexes,project-maps,canvases} system/{templates,runs,queues}

Minimum required variables:

VariableDefault
SOURCES_DIRsources/
CONCEPTS_DIRwiki/concepts/
ENTITIES_DIRwiki/entities/
OUTPUTS_DIRwiki/outputs/
SYSTEM_DIRsystem/
LOG_FILEsystem/log.md
2.3 Token Tracking (Optional)
# Create token log
touch .token-log.csv
echo "date,task,model_id,capability_class,input_tokens,cached_input_tokens,output_tokens,input_rate,cached_input_rate,output_rate,currency,cost,rate_source,notes" > .token-log.csv
2.4 Vector Search (Optional, for knowledge-ops)
pip install chromadb sentence-transformers watchdog

3. Quick Start Wizard

Run this sequence to verify everything works:

# Step 1: Verify skills are installed
codex "What skills do I have?"

# Step 2: Ingest a piece of knowledge
codex "I just read that Curiosity Rover found organic molecules on Mars. Ingest this into my wiki."

# Step 3: Run daily OKR
codex "Run my daily OKR."

# Step 4: Check wiki health
codex "Lint my wiki."

# Step 5: Create an agent team (if enabled)
codex "Create a team of 3 agents to research this topic."

4. Skill Reference

📥 Ingestion & Knowledge Pipeline
SkillWhat It DoesTrigger Phrase
wiki-ingestIngests sources with risk classification, macro-action scope, wiki pages, clipping archive, Karpathy understanding gate, governance notes, and post-ingest lint"ingest this into my wiki"
knowledge-opsManages multi-layer knowledge; dedup, classify, preserve evidence hierarchy, use Markdown-first retrieval, vectorize optionally, and queue knowledge debt"save this to my knowledge base"
wiki-lintHealth-check: P0/P1 graph health, source refs, frontmatter, links, provenance debt, clipping lifecycle, and understanding integrity"lint my wiki"
🔄 Daily Workflow
SkillWhat It DoesTrigger Phrase
daily-okr7-KR cycle: Input→Cognition→Wiki→Behavior→Creativity→Output→Feedback"run my daily OKR"
cognitive-compile8-section deep learning compile: Question→Facts→Concepts→Patterns→Conflicts→Hypotheses→Decision→Action"do a cognitive compile on X"
🎨 Behavior & Creativity
SkillWhat It DoesTrigger Phrase
behavior-designConvert outcomes into minimum behavior, cues, SOPs, evidence, recovery, and review"design a habit for X"
creativity-engineGenerate mechanism-diverse options and falsifiable minimum experiments"generate ideas about X"
🔬 Research & Quality
SkillWhat It DoesTrigger Phrase
deep-researchResearch harness with preflight, source/claim ledgers, activity trace, citations, privacy checks, and STOW handoff"research X for me"
verify-before-claimNo completion claims without fresh verification evidence"verify before I ship"
🔄 Learning & Flow
SkillWhat It DoesTrigger Phrase
session-learnExtract 7 knowledge signals from sessions. Closure Protocol"extract what we learned"
project-flow-opsTriage, plan, track, review across projects"triage my tasks"
📊 Context & Cost
SkillWhat It DoesTrigger Phrase
context-managerRuntime budgets, checkpoint replay, compaction, retrieval, capability routing"I'm hitting context limits"

token-cost-tracker is a utility command under commands/, not an Agent Skill.

🏗️ Engineering
SkillWhat It DoesTrigger Phrase
loop-engineeringControls temporal depth with bounded Goal/Loop/Automation/AutoResearch contracts, durable state, and recovery"turn this into a verified loop"
graph-engineeringControls dependency width with bounded static DAGs, explicit branches, typed joins, and node-local recovery"model these dependencies as a verified graph"
agentic-engineeringRefactors workflows into spec-driven macro actions with quality ceilings, delegated-action boundaries, autonomy defaults, write-back, and verification"make this workflow more agentic"
harness-engineeringRuntime kernel: scheduler, permissions, tools as system calls, delegated-action gates, provenance ledgers, observability, and recovery"how do I make this agent safe?"
agent-teams-commandMulti-agent process ownership and orchestration with IPC, async budget envelopes, integration, cleanup, evidence gates, and red-team review"create an agent team to build X"

Routing boundary: Loop = temporal depth; Graph = dependency width; Agent Teams = process ownership, IPC, and integration; Harness = runtime scheduler, permissions, and observability. Add Graph Engineering after Loop Engineering only when its admission value exceeds orchestration and review cost.

💼 Strategy & Operations
SkillWhat It DoesTrigger Phrase
startup-evaluationStartup health diagnosis: customer pain, market, PMF, team, unit economics, runway, VC 5T, and next cheapest test"evaluate this startup"
anthropic-osSelf-evolving work method engine. CASH, 70/30, hive mind, 3B algorithms"launch Anthropic OS"
ai-six-sigma-property-osAI + Ontology + DMAIC Black Belt model for property work orders, dispatch, quotes, evidence, CTQ metrics, and quality dashboards"design my Property Agent OS"

5. Workflow Scenarios

For copyable, standalone workflow files, see examples/. The recommended starting workflows are:

WorkflowExample FileBest Skill Entry
3-minute source ingestexamples/3-minute-quickstart.mdwiki-ingest
Research PDF to wiki briefexamples/research-pdf-to-wiki.mdwiki-ingest + cognitive-compile
Deep research to STOW handoffexamples/deep-research-stow-handoff.mddeep-research + optional wiki-ingest
Verified code sessionexamples/verified-code-session.mdverify-before-claim
Daily knowledge loopexamples/daily-knowledge-loop.mddaily-okr
Startup evaluation sprintexamples/startup-evaluation-sprint.mdstartup-evaluation
Scenario 1: Knowledge Capture & Compounding

Goal: Capture an article, understand it deeply, and make the knowledge compound.

Step 1 — Ingest:
  "I just read a fascinating article about AlphaFold 3.
   Ingest it into my wiki."

Step 2 — Deep Understanding:
  "Run a cognitive compile on AlphaFold 3's impact on drug discovery."

Step 3 — Behavioral Action:
  "Design a habit to follow AI-in-biology news weekly."

Step 4 — Generate Ideas:
  "Use the creativity engine to generate 5 startup ideas at the
   intersection of AI and protein folding."

Step 5 — Extract Learning:
  "Extract what we learned from this session."
Scenario 2: Full-Stack Development Sprint

Goal: Build a feature with an agent team.

Step 1 — Plan with Context:
  "I'm building a CLI tool for tracking TODO comments.
   Run a cognitive compile on the best architecture."

Step 2 — Create Agent Team:
  "Create a team of 3 teammates and route them by implementation,
   domain, and independent-evaluation capability.
   Teammate 1: Frontend (React).
   Teammate 2: Backend (FastAPI).
   Teammate 3: QA (Playwright tests).
   Build me a working prototype."

Step 3 — Quality Check:
  "Verify before I ship: run tests and check for edge cases."

Step 4 — Document:
  "Save the architecture decisions to my wiki."
Scenario 3: Startup Evaluation

Goal: Evaluate a startup idea systematically.

Step 1 — Market Analysis:
  "Run a cognitive compile on the AI-powered legal tech market."

Step 2 — Startup Evaluation:
  "Evaluate this startup idea:
   An AI that automates contract review for small businesses.
   Use the startup-evaluation framework."

Step 3 — Research:
  "Use deep-research to analyze existing competitors in AI legal tech.
   Include source access, claim ledger, activity trace, and STOW handoff."

Step 4 — Strategy:
  "Launch anthropic-os. Evaluate this idea using 70/30 allocation.
   What's the Big Bet vs BAU growth strategy?"
Scenario 4: Marketing Campaign Design

Goal: Design and execute a marketing campaign.

Step 1 — Research:
  "Use deep-research on latest trends in AI marketing automation.
   Run the preflight, source ledger, claim ledger, and activity trace."

Step 2 — Creativity:
  "Generate 10 campaign ideas combining AI and emotional storytelling."

Step 3 — Behavior Design:
  "Design a daily content creation habit."

Step 4 — Knowledge Capture:
  "Extract what we learned. Save the winning ideas to my wiki."
Scenario 5: Startup Evaluation Sprint

Goal: Turn an early idea into an evidence map and validation plan.

Step 1 — Frame the Idea:
  "Use startup-evaluation on this idea:
   An AI coach that turns reading notes into daily behavior experiments."

Step 2 — Separate Facts from Assumptions:
  "List what we know, what we assume, and what would kill the idea."

Step 3 — Define the Cheapest Test:
  "Design a 7-day validation test with one target customer segment,
   one success metric, and one interview script."

Step 4 — Preserve Learning:
  "Use session-learn to save the decision, assumptions, and next test
   into my wiki."

6. Daily Routine

Morning Session (15 min)
1.  "Run my daily OKR."
    └── KR1: Input → Scan 3 high-quality sources
    └── KR2: Cognition → Extract 1 key insight
    └── KR3: Wiki → Save insight to wiki
    └── KR4: Behavior → Plan 1 action ≤15 min
    └── KR5: Creativity → 1 new idea
    └── KR6: Output → 1 reusable artifact
    └── KR7: Feedback + Stop Doing List (Buffett/Munger)
Deep Work Session (2-4 hours)
1. "Run a cognitive compile on [topic]."
2. "Research [topic] with deep-research, including source boundary,
    claim ledger, activity trace, and STOW handoff if durable."
3. "Ingest findings into wiki."

For complex build tasks:
4. "Create an agent team to build [feature]."
5. "Verify before I ship."

For strategic decisions:
6. "Launch anthropic-os for this decision."
Evening Review (10 min)
1. "Extract what we learned from today."
2. "Update project status with project-flow-ops."
3. "Estimate token cost for tomorrow's planned tasks."

7. Advanced Configurations

7.1 Capability Routing by Task
TaskRequired capabilityRuntime preference
Daily OKRStructured extraction, low latencyLowest-cost capable route
Cognitive CompileDeep reasoning, evidence separationReasoning route with adequate context
Wiki IngestFile/tool use, structured outputReliable tool-use route
Agent TeamsRole-specific capability plus independent evaluatorSmallest justified team
Deep ResearchSearch, synthesis, citation disciplineResearch-capable route with current access
Creativity EngineDivergence plus constraint evaluationFast route unless domain risk is high
Token EstimationArithmetic or deterministic calculatorScript/tool before a model
7.2 Runtime Settings

Discover team, sandbox, connector, and approval settings from the installed runtime. Keep product/version-specific flags in local configuration, not durable skills; verify the feature is active before claiming workers were launched.

7.3 Git Hooks Integration
# Post-commit hook: auto-lint wiki
cat > .git/hooks/post-commit << 'EOF'
codex "Lint my wiki after this change."
EOF
chmod +x .git/hooks/post-commit
7.4 Token Budget Management
# Estimate before expensive tasks
codex "Estimate token cost for a cognitive compile on this 50-page PDF."

# Log after tasks
codex "Log this task: cognitive-compile, runtime-model-id, 150K input, 35K output, using today's billing rates."

# Weekly report
codex "Generate my weekly token report."

8. Troubleshooting

IssueLikely CauseSolution
Skill not foundSkills not installed to the correct directoryRun bash install.sh with the explicit harness target
Agent Teams not workingRuntime lacks workers or team mode is disabledInspect current runtime capabilities/settings; use one process if unavailable
Token cost too highCapability route or context scope is oversizedUse runtime pricing plus context-manager budget and compaction rules
Wiki links brokenWiki structure not set up or config paths mismatchCheck system/config.md, then create the configured concept/entity folders.
Vector search failingChromaDB not installedpip install chromadb sentence-transformers
Session-learn emptyNo reusable, source-grounded delta existsReturn no-op evidence or provide the missing session artifact
Cognitive compile too longQuestion or source boundary is too broadNarrow the decision question and preserve source locators
LLM context fullNo truncation strategyUse context-manager to budget and trim
Quick Diagnostics
# Check skills installed
ls ~/.agents/skills/

# Verify Codex version
codex --version

# Check the installed Codex navigation contract
test -f AGENTS.md && test -d ~/.agents/skills

# Check token log
cat .token-log.csv | tail -5

Appendix: Skill Interaction Map

                    ┌──────────────────┐
                    │   External       │
                    │   Sources        │
                    └────────┬─────────┘
                             ▼
              ┌──────────────────────────┐
              │    wiki-ingest            │◄── daily-okr (KR1)
              │    knowledge-ops          │
              └──────┬──────────┬────────┘
                     │          │
              ┌──────▼          └──────────┐
              │  Knowledge Layers           │
              │  ├ wiki-lint (health check) │
              │  └ session-learn (extract)  │
              └─────────────────────────────┘
                     │
        ┌────────────┼────────────┬──────────────┐
        ▼            ▼            ▼              ▼
┌─────────────┐ ┌──────────┐ ┌──────────┐ ┌──────────────┐
│ daily-okr   │ │cognitive │ │ behavior │ │ creativity   │
│ (7 KR loop) │ │-compile  │ │ -design  │ │ -engine      │
│ + evidence  │ │ 8 parts  │ │ + review │ │ + experiments│
└─────────────┘ └──────────┘ └──────────┘ └──────────────┘
        │            │            │              │
        └────────────┼────────────┼──────────────┘
                     ▼
    ┌───────────────────────────────────────────────┐
    │ verify-before-claim   ← quality gate          │
    │ deep-research         ← synthesis             │
    │ project-flow-ops      ← execution             │
    │ loop-engineering      ← temporal depth        │
    │ graph-engineering     ← dependency width      │
    │ context-manager       ← context optimization  │
    │ harness-engineering   ← runtime controls      │
    └───────────────────────────────────────────────┘
                     │
        ┌────────────┴────────────┐
        ▼                         ▼
┌──────────────┐         ┌─────────────────┐
│ agent-teams  │         │ anthropic-os    │
│ -command     │         │ + CASH + 3B     │
│ (fleet ops)  │         │ + Predictive    │
└──────────────┘         │   Coding        │
                         └─────────────────┘

Next: Open Codex and say: "Run my daily OKR."

318 files · 7 not served here

Advantages

Limitations

  • Does not support dynamic or cyclic graphs; graph-engineering is bounded to static DAGs. evidence: README.md
  • Requires a specific transactional runtime for full functionality. evidence: AGENTS.md

Security

Risk level: Low risk

This brain runs

Agent instructions that run or fetch something (88)

  • AGENTS.md: V8.1 defines an explicit **5-Stage Worker Assembly Pipeline** in `workflows/worker-flows.md`, enforced by the canonical transactional runtime `python -m tools.worker_flow.cli`.
  • AGENTS.md: **loop-engineering** — Temporal-depth control through bounded Trigger → Execute → Verify → State loops, durable contracts, hard budgets, and stop/recovery rules.
  • AGENTS.md: `## Success Metrics` — minimum observable result for one successful run.
  • GEMINI.md: V8.1 defines a transactional **5-Stage Worker Assembly Pipeline** (`workflows/worker-flows.md`) enforced by `python -m tools.worker_flow.cli`.
  • skills/agent-teams-command/SKILL.md: <execute>
  • skills/agent-teams-command/SKILL.md: Run regression tests.
  • skills/agent-teams-command/SKILL.md: </execute>
  • skills/agentic-engineering/SKILL.md: Run the adoption gate: use an agent only when ambiguity/adaptation outweigh orchestration, verification, and maintenance cost.
  • skills/agentic-engineering/SKILL.md: <execute>
  • skills/agentic-engineering/SKILL.md: only host code may execute tools or decide continuation.
  • skills/agentic-engineering/SKILL.md: Run a thin loop: understand -> plan -> smallest change -> targeted test -> inspect diff/state -> broader check.
  • skills/agentic-engineering/SKILL.md: </execute>
  • skills/ai-six-sigma-property-os/SKILL.md: bounded agents execute and audit;
  • skills/ai-six-sigma-property-os/SKILL.md: <execute>
  • skills/ai-six-sigma-property-os/SKILL.md: </execute>
  • skills/anthropic-os/SKILL.md: Run Four-C in order: **Context** (truth/history), **Connections** (systems/accounts), **Capabilities** (skills/SOPs/evals), **Cadence** (triggers/reviews).
  • skills/anthropic-os/SKILL.md: <execute>
  • skills/anthropic-os/SKILL.md: Run dual prediction when useful: human and agent predict outcome independently;
  • skills/anthropic-os/SKILL.md: </execute>
  • skills/behavior-design/SKILL.md: <execute>
  • skills/behavior-design/SKILL.md: **H3 SOP:** write `trigger -> action -> evidence -> recovery -> stop` so a missed run has a next move.
  • skills/behavior-design/SKILL.md: </execute>
  • skills/behavior-design/SKILL.md: run a short observation period before optimizing.
  • skills/cognitive-compile/SKILL.md: <execute>
  • skills/cognitive-compile/SKILL.md: </execute>
  • skills/context-manager/SKILL.md: <execute>
  • skills/context-manager/SKILL.md: </execute>
  • skills/creativity-engine/SKILL.md: <execute>
  • skills/creativity-engine/SKILL.md: </execute>
  • skills/daily-okr/SKILL.md: Run one daily objective through seven linked Key Results.
  • skills/daily-okr/SKILL.md: <execute>
  • skills/daily-okr/SKILL.md: **Behavior:** execute one minimum behavior linked to the objective.
  • skills/daily-okr/SKILL.md: </execute>
  • skills/deep-research/SKILL.md: <execute>
  • skills/deep-research/SKILL.md: Run a broad discovery pass;
  • skills/deep-research/SKILL.md: Run a gap-fill pass only for decision-critical unknowns.
  • skills/deep-research/SKILL.md: Run an adversarial pass: strongest counterevidence, alternative mechanism, stale data, selection bias, and missing base rate.
  • skills/deep-research/SKILL.md: </execute>
  • skills/graph-engineering/SKILL.md: Run the admission gate before drawing a graph:
  • skills/graph-engineering/SKILL.md: Probe candidate independence with a small dry run.
  • skills/graph-engineering/SKILL.md: <execute>
  • skills/graph-engineering/SKILL.md: Write the JSON contract and run `scripts/validate_graph_contract.py <contract.json> --strict`.
  • skills/graph-engineering/SKILL.md: node success alone cannot certify graph success.
  • skills/graph-engineering/SKILL.md: </execute>
  • skills/graph-engineering/SKILL.md: run only independent ready nodes.
  • skills/harness-engineering/SKILL.md: Run the trace gate: the harness must be able to show what the agent saw, proposed, called, changed, and verified.
  • skills/harness-engineering/SKILL.md: <execute>
  • skills/harness-engineering/SKILL.md: The host decides whether to execute, continue, checkpoint, or escalate;
  • skills/harness-engineering/SKILL.md: </execute>
  • skills/harness-engineering/SKILL.md: Verify permissions with actual environment boundaries and run an independent end-to-end trace.
  • skills/harness-engineering/SKILL.md: A model emits plausible success text with a tool request: validate and execute the tool in host code, then verify its result;
  • skills/harness-engineering/SKILL.md: A maintenance run finds no eligible change: emit a verified `NO_OP` receipt and zero external outputs rather than creating notification or PR noise.
  • skills/harness-engineering/SKILL.md: The scheduler ran on time but the state store was stale: block mutation, mark the run failed, and recover from the last verified checkpoint.
  • skills/harness-engineering/SKILL.md: A Graph worker completes twice after lease expiry: deduplicate by node/run identity and release successors only from one verified transition.
  • skills/knowledge-ops/SKILL.md: <execute>
  • skills/knowledge-ops/SKILL.md: **Verify:** read after write, check links/source refs, rerun exact-identity search, and run representative retrieval queries.
  • skills/knowledge-ops/SKILL.md: Use idempotency keys for machine append operations: derive the key from operation, canonical source identity, target, and run/batch id;
  • skills/knowledge-ops/SKILL.md: </execute>
  • skills/knowledge-ops/SKILL.md: make no whole-vault claim.
  • skills/loop-engineering/SKILL.md: <skill_contract> <input>A repeatable task with inspectable state, finite budgets, permissions, and an independent verifier.</input> <output>A validated Trigger -> Execute -> Verify -> State contract plus resumable run receipts.</output> <done>The declared metric or stop condition is su …[+161 chars]
  • skills/loop-engineering/SKILL.md: **Goal:** run until a defined end state or cap.
  • skills/loop-engineering/SKILL.md: <execute>
  • skills/loop-engineering/SKILL.md: **Act:** execute one bounded action and capture artifact/diff/receipt.
  • skills/loop-engineering/SKILL.md: </execute>
  • skills/loop-engineering/SKILL.md: A scheduled job fired but produced no run receipt: status is triggered, not completed;
  • skills/project-flow-ops/SKILL.md: <execute>
  • skills/project-flow-ops/SKILL.md: Run the verification named in the definition of done.
  • skills/project-flow-ops/SKILL.md: </execute>
  • skills/session-learn/SKILL.md: <execute>
  • skills/session-learn/SKILL.md: **Pattern** — a reusable Trigger -> Execute -> Verify -> State sequence.
  • skills/session-learn/SKILL.md: </execute>
  • skills/startup-evaluation/SKILL.md: <execute>
  • skills/startup-evaluation/SKILL.md: </execute>
  • skills/verify-before-claim/SKILL.md: <execute>
  • skills/verify-before-claim/SKILL.md: Run the selected check after the final material change.
  • skills/verify-before-claim/SKILL.md: </execute>
  • skills/wiki-ingest/SKILL.md: record the identity query in the run ledger.
  • skills/wiki-ingest/SKILL.md: <execute>
  • skills/wiki-ingest/SKILL.md: Give every machine log entry an idempotency key derived from run/batch, operation, canonical source identity, and target;
  • skills/wiki-ingest/SKILL.md: **Verify:** run targeted link, source-ref, frontmatter, block-ref, empty-file, navigation, and post-write exact-identity checks over touched files.
  • skills/wiki-ingest/SKILL.md: </execute>
  • skills/wiki-lint/SKILL.md: make no content mutation unless separately authorized.
  • skills/wiki-lint/SKILL.md: <execute>
  • skills/wiki-lint/SKILL.md: Run twelve checks and preserve file-level evidence:
  • skills/wiki-lint/SKILL.md: </execute>
  • skills/wiki-lint/SKILL.md: If repair was authorized, run the relevant check again after each bounded repair.
  • skills/workflow-audit/SKILL.md: <execute> Extract a bounded list of distinct work candidates.
  • skills/workflow-audit/SKILL.md: </execute>

Install scripts (2)

  • install.ps1: pwsh install.ps1
  • install.sh: sh install.sh
  • Low risk: scripts-present (install.ps1)
  • Low risk: scripts-present (install.sh)

Attribution and licence

First committed by
GitHub avatar of Mark393295827Mark393295827
Publisher
Markk-gao (Community)
Source
Mark393295827/third-brain-v7-skills · commit 5a64514
Licence
MIT License (files served here)
  • ATTRIBUTION.md (written by AutoGineer)
Synced
Contributors
Mark393295827

AutoGineer is not affiliated with or endorsed by Mark393295827.

Install from source

7 of its files are not served here, so there is no ZIP. Mark393295827/third-brain-v7-skills at 5a64514