Knowledge Capture Automation

This note defines how the universal Agent Knowledge Capture SOP lands inside MyOS.

MyOS does not get a separate /record methodology. The same method should work across Codex, Claude, Hermes/Athena, MyOS role agents, and future coding agents. MyOS only supplies destination rules: Obsidian paths, Hermes sync behavior, and role-memory boundaries.

Principle

Knowledge capture should be an operating loop, not a writing chore.

Arijit should be able to say one short command, such as /record, and the active agent should turn the current work into durable knowledge: raw evidence, distilled structure, decisions, connections, and follow-up actions.

The command should preserve the conversation without making raw chat history the source of truth.

The Command

Target command:

/record

Optional variants:

/record
/record decision
/record process
/record project:My OS
/record workspace:Competitive Intelligence
/record raw-only
/record distill-only

Default behavior should be smart enough that Arijit does not need to provide a long instruction. If no target is named, Athena infers the project or workspace from the current conversation and asks at most one clarifying question only when the target is genuinely ambiguous.

Universal Method

The portable method is recorded in:

• Agent Knowledge Capture SOP
• Agentic Knowledge Capture

The reusable skill package is:

/Volumes/Data/Dropbox/AI-Development/Personal/arijit-skills/skills/general-skills/agent-knowledge-capture

That package should be used consistently by Codex, Claude, Hermes, and MyOS. Each runtime may need different installation mechanics, but the capture contract should stay the same.

Install State

As of 2026-06-20:

Shared source:
/Volumes/Data/Dropbox/AI-Development/Personal/arijit-skills/skills/general-skills/agent-knowledge-capture

Codex skill link:
/Users/arijitchowdhury/.codex/skills/agent-knowledge-capture

Claude skill link:
/Users/arijitchowdhury/.claude/skills/agent-knowledge-capture

Claude slash command:
/Users/arijitchowdhury/.claude/commands/record.md

Codex skill discovery happens when a new Codex session loads available skills. This already-running Codex thread can follow the method from the files, but a literal custom /record slash command is not installed for Codex unless Codex adds a local command mechanism. Claude has a global /record command file.

Cross-machine install after the skill is committed and pushed:

git clone https://github.com/arijitchowdhury80/arijit-skills.git
cd arijit-skills/skills/general-skills/agent-knowledge-capture
chmod +x install-skill.sh
./install-skill.sh --all

Why Hermes Should Expose The Same Method As A Skill

Hermes quick commands are useful for instant shell commands and short status checks. They do not invoke the LLM and are bounded by short command timeouts.

/record requires judgment:

• Identify what changed.
• Separate raw evidence from durable knowledge.
• Decide whether a decision record is needed.
• Update wiki pages and indexes.
• Preserve links and cross-references.
• Avoid recording secrets or noise.
• Produce a short confirmation to Arijit.

Therefore Hermes should expose the same /record method as a skill named record or knowledge-capture, because skill commands can invoke LLM judgment and file edits. Codex and Claude should use the same SOP through their own skill/command mechanisms.

End-To-End Flow

conversation or work session
  -> /record
  -> capture raw evidence
  -> extract durable facts, decisions, processes, questions, and tasks
  -> route each item to the right vault layer
  -> update links and indexes
  -> sync to Hermes when needed
  -> report what was recorded

Vault Layers

Raw Capture

Purpose: preserve evidence.

Default destinations:

Projects/{Workspace}/raw/
Projects/{Workspace}/logs/
Chowmes-Inbox/

Raw capture may include:

• Conversation summary with representative quotes.
• Files changed.
• Commands run.
• Evidence paths.
• Source URLs.
• Unresolved questions.

Raw capture should not become the default operating context.

Distilled Workspace Knowledge

Purpose: keep a project recoverable.

Default destinations:

Projects/{Workspace}/index.md
Projects/{Workspace}/workspace-state.md
Projects/{Workspace}/wiki/
Projects/{Workspace}/decisions/
Projects/{Workspace}/logs/

Use this layer for:

• Project facts.
• Current state.
• Build plans.
• Role decisions.
• Operating procedures.
• Quality gates.
• Known failure modes.

Shared Organization Knowledge

Purpose: preserve reusable My OS rules.

Default destinations:

Projects/My OS/
Knowledge/wiki/concepts/
Knowledge/wiki/syntheses/
Architecture/
Standards/

Promote knowledge here only when it applies across projects or changes the operating model.

Role Memory

Purpose: preserve how an advisor thinks.

Role memory should capture:

• Advisor-specific judgment.
• Recurring critique patterns.
• Durable preferences.
• Lessons that improve future role behavior.

Role memory should not be the only place project facts live. Project facts belong in the workspace.

Classification Rules

/record should classify captured material into these buckets:

Bucket	Destination	Example
Raw evidence	raw/ or logs/	Chat summary, command evidence, artifact paths
Decision	decisions/YYYY-MM-DD-topic.md	"Use skill slash command, not quick command, for /record"
Process	project wiki or My OS note	Knowledge capture pipeline
Project state	workspace-state.md or .company/status.json	Current phase, blockers, next actions
Reusable concept	Knowledge/wiki/concepts/	Knowledge compounding
Synthesis	Knowledge/wiki/syntheses/	Cross-project pattern or comparison
Open question	06-open-questions.md or project open-questions.md	Ambiguous command scope
Memory proposal	Chowmes-Inbox/ or memory approval flow	Durable user preference or role behavior

Output Contract

After /record, Athena should reply with a compact receipt:

Recorded:
- Raw/log: path
- Decision: path, if created
- Updated: path(s)
- Open questions: count
- Not recorded: secrets/noise/duplicates, if relevant

Do not paste the full recorded note back into Telegram unless Arijit asks.

Safety Rules

• Do not record secrets, tokens, private keys, passwords, or identity documents.
• Do not promote raw transcripts into canonical notes without distillation.
• Do not create a new workspace for every idea.
• Do not create a decision record unless a decision was actually made.
• Do not overwrite canonical notes without preserving the previous state or making a targeted patch.
• Prefer one clarifying question over guessing when the destination is risky.

First Version

The first useful version should do five things:

1. Infer the workspace from the current conversation.
2. Write a session log.
3. Create a decision record when the conversation contains a real decision.
4. Update one canonical note or index when the knowledge changes the operating model.
5. Return a short receipt.

It does not need full graph intelligence on day one. The right v1 is a reliable promotion ritual.

Future Version

Later, /record can become a richer knowledge operator:

• Detect entities and update entity pages.
• Maintain backlinks and maps of content.
• Compare new claims against old notes.
• Create memory proposals for Athena and ELT profiles.
• Spawn review agents for high-stakes decisions.
• Add scheduled "unrecorded decisions" audits.
• Support voice or meeting transcript ingestion.

Success Standard

The workflow is working when Arijit can brainstorm freely with Athena and role agents, then say /record, and the important knowledge lands in Obsidian as:

• Raw evidence when needed.
• Distilled durable notes.
• Separate decisions.
• Linked project state.
• Reusable operating knowledge.

The vault should feel like it is learning, not accumulating debris.