1	# Ingest Log
2
3	Chronological record of everything added to this wiki.
4
5	---
6
7	## 2026-07-10 (Pool Monitor test-log isolation)
8
9	- **[[Test Isolation for Runtime Activity Logs]]** (new concept, internal-origin) — The Pool Monitor suite’s `run_once()` tests were writing fixture alerts and failed-client errors into live dashboard files through module-level path constants. An autouse `tmp_path` fixture now redirects alerts, errors, state, and recalibration paths; a regression test confirms they are not the live `logs/` directory, and before/after hashes prove the complete suite leaves public data untouched.
10
11	## 2026-07-10 (projects index outage recovery)
12
13	- **[[LaunchAgent Quarantine and Tailscale Recovery]]** (new concept, internal-origin) — A reboot left the projects server loaded but never executed because launchd retained a quarantine trust state. Clear the plist's quarantine flag, then `bootout` and `bootstrap` the job before `kickstart`; a reload is needed because launchd retains the old trust state. Treat Tailscale separately: restart it when its CLI cannot load preferences or MagicDNS cannot resolve the hostname, then prove both local origin and Funnel routes with HTTP checks.
14
15	## 2026-07-10 (Hermes provider fallback config)
16
17	- **[[Hermes Provider Fallback Config]]** (new concept, internal-origin) — From configuring Hermes quota fallback: use top-level `fallback_providers` rather than code changes; put LM Studio first when cloud usage limits are the likely failure; verify `hermes auth list` before adding provider entries; include `base_url` for LM Studio/local OpenAI-compatible endpoints; and prove the config through `hermes fallback list`, provider resolver checks, and focused fallback/gateway tests.
18
19	## 2026-07-10 (Claude blog — Cognition on Fable 5)
20
21	- **[[Claude Blog - Cognition Claude Fable 5]]** (new source) — Silas Alberti (Cognition SVP of Research) validates Fable 5 in production: Devin now runs 8h overnight autonomously; Frontier Code benchmark 30% vs 10% prior Opus (3×). Key behavioral improvements: reasoning discipline, honest uncertainty, tool use under noise.
22	- **[[Frontier Code Evaluation]]** (new concept) — Cognition's evaluation methodology: use your best engineers, test on real production work, gate on "Would I keep this code?" Applicable to any model selection decision.
23	- **[[Claude Fable 5 and Mythos 5]]** (updated) — Added real-world performance validation section with Cognition's benchmark results and overnight autonomous run data.
24
25	## 2026-07-10 (Anthropic GitHub sweep #26)
26
27	- Another coordinated CI sweep, 30 repos, `newSkillCommits: []`. No new content. One new entry `claude-code-base-action` is a mirror of `claude-code-action` (already documented). Verticals (financial-services, healthcare, claude-for-legal), infra (buffa), and interpretability research (jacobian-lens) skipped per policy. All remaining repos already covered by sweep #25.
28
29	## 2026-07-09 (Anthropic GitHub sweep #25)
30
31	- **[[Anthropic SDK Go]]** (new tool page) — Official Go SDK for Anthropic Claude API. `go get anthropic-sdk-go@v1.56.0`, Go 1.24+. Type-safe model constants, standard Go idioms. Not previously documented.
32	- 30 repos updated in coordinated CI sweep; `newSkillCommits: []`. Remaining repos already covered or not relevant (cwc-long-running-agents: fully covered by Long-Running Agent Primitives; financial-services/life-sciences/legal: vertical skips; buffa/terragrunt: infra skips).
33
34	## 2026-07-08 (Claude blog — Marketing Ops Cowork Automation)
35
36	- **[[Claude Blog - Marketing Ops Cowork Automation]]** (new source) — Anthropic's own marketing ops team (Ian Chan + Annabel Custer) shows two Cowork deployments: scheduled weekly metrics report (1–2 days → 2h) and dispatcher-routed event/campaign builds with an independent audit agent. Ingested for the workflow patterns, not the domain.
37	- **[[Cowork Dispatcher-Specialist Pattern]]** (new concept) — Extracted from the above: dispatcher routes intake to specialist agents, independent audit agent verifies output before shipping, skill refinement loop feeds corrections back into skill instructions.
38
39	## 2026-07-08 (NanoClaw provider fallback tool-hallucination fix)
40
41	- **[[NanoClaw REST Fallback Tool-Call Hallucination]]** (new concept, internal-origin) — From a `/goal` session fixing garbled non-English-looking Slack replies. Root cause: a generic "please follow up" message didn't match the `needsClaudeCode()` keyword heuristic, so it routed to the toolless LM Studio fallback rung, which hallucinated a fake `<read_file .../>` tool-call tag instead of admitting it had no tools — and the existing `<message>`-block validation only checked the wrapper, not the content, so the raw tag reached the user. Fixed with an output-side tag-allowlist check + corrective retry + honest fallback message, deliberately not by tightening the routing heuristic (which can never cover every phrasing). RED→GREEN tests replay the exact reported text in `gemini-openai-claude.test.ts`.
42
43	## 2026-07-08 (Claude blog check)
44
45	- **Thomson Reuters / Fiduciary-Grade AI** — customer case study for legal/professional services vertical. No new Claude capabilities or engineering insights. Skipped per policy.
46
47	## 2026-07-08 (NanoClaw Slack engagement fix)
48
49	- **[[NanoClaw Slack Mention-Sticky Session Bug]]** (new concept, internal-origin) — From a `/goal` session fixing NanoClaw's Slack bot only replying to explicit `@mentions`. Root cause was two stacked router bugs: `session_mode='shared'` was unconditionally coerced to `'per-thread'` for any threaded-adapter (Slack/Discord/…) group chat, and `mention-sticky`'s engagement check always did an exact-thread session lookup regardless of the wiring's actual `session_mode`. Combined with Slack's own per-message thread-id fallback (an un-threaded reply gets its own fresh thread id), a plain reply to the bot's own question could never be recognized as a continuation. Fixed by honoring `session_mode` as configured and adding a scope-aware session lookup; RED→GREEN regression test in `src/host-core.test.ts`.
50
51	## 2026-07-08 (Anthropic GitHub sweep #24)
52
53	- No new wiki pages needed — all 30 updated repos in the `anthropics` org were already covered by sweep #23 (2026-07-07) or are not relevant (buffa, model-cards, financial-services/life-sciences/legal verticals, courses).
54	- No new skill commits (`newSkillCommits: []`).
55	- Repos verified as current: `launch-your-agent`, `cwc-long-running-agents`, `claude-agent-sdk-typescript`, `claude-agent-sdk-python`, `claude-tag-plugins`, `knowledge-work-plugins`, `defending-code-reference-harness`, `claudes-c-compiler`, `claude-plugins-official`, `claude-plugins-community`, `claude-code-action`, `claude-code-security-review`.
56
57	## 2026-07-07 (RoadSense ridden-indicator fix)
58
59	- **[[Orthogonal Visual Channels on Map Lines]]** (new concept, internal-origin) — From the RoadSense ridden-roads fix: keep line color reserved for the score, encode the ridden boolean as a near-black dotted overlay (Mapbox `line-dasharray` short-dash + round-cap dots; dasharray units are line-widths so dot spacing zoom-scales for free; overlay goes topmost to avoid junction clipping). Includes the puppeteer E2E pattern of driving the map via the app's own CustomEvents and toggling state through the public API.
60
61	## 2026-07-07 (Anthropic GitHub sweep #23)
62
63	- **[[Launch Your Agent]]** (new) — Claude Code skill that takes a founder from raw agent idea to a live Claude Managed Agent in one guided session: interview → scope → deploy → grade → optional schedule. Creates `my-agent/` folder with build docs, resumable script, and eval scaffolding. Deployable in the Anthropic Console.
64	- **[[Claude Tag Plugins]]** (new) — 19 SaaS integration plugins (Jira, Linear, Asana, Snowflake, BigQuery, Salesforce, HubSpot, Sentry, Datadog, Grafana, PagerDuty, Confluence, Google Drive, Notion, etc.) via Claude Tag CLI. Skills activate contextually, credentials runtime-injected.

... [543 lines truncated] ...


1	# Wiki Index
2
3	A catalog of everything in this knowledge base. Updated by Nano on every ingest.
4
5	## Tools & Software
6	*Guest-endorsed or actively used — not sponsors.*
7	- [[Agent Browser]] — Vercel Labs Rust CLI for AI-driven browser automation. Credential vault, accessibility-tree refs, React introspection, HAR recording.
8	- [[Devin]] — AI coding agent by Cognition. 15-thread code factory model.
9	- [[OpenClaw]] — Open-source AI executive assistant / chief of staff.
10	- [[ClawChief]] — Ryan Carson's open-sourced OpenClaw chief-of-staff config.
11	- [[Claude Code]] — Anthropic's coding agent. Ryan Carson's preferred coding tool.
12	- [[Codex]] — OpenAI's coding agent / browser testing tool.
13	- [[Sentry]] — Error monitoring. Used with Devin for automated bug triage.
14	- [[Tailscale]] — WireGuard mesh network. Used for remote access to Mac Mini services from phone. Includes full recipe for exposing any local port via `tailscale serve` + launchd.
15	- [[Figma]] — Design/wireframing. Visual context layer in Ravi Mehta's system.
16	- [[AgentsView]] — Agent token/cost accounting tool. Useful when new frontier-model pricing appears before dashboards and pricing databases catch up.
17	- [[Teach Skill]] — `/teach` by Matt Pocock. ZPD-based personalized tutor with persistent learning records. Trigger-based (no idle context cost). Claude Code only. Install: `npx skills add mattpocock/skills --skill teach`.
18
19	## Anthropic Official Repos & Resources
20	*Official Anthropic repositories — tools, SDKs, plugins, and reference implementations.*
21	- [[Anthropic Skills Repo]] — Reference implementations of the Claude Agent Skills system. Template for building custom skills.
22	- [[Claude Plugins Official]] — Anthropic's curated plugin marketplace for Claude Code. Install via `/plugin install`.
23	- [[Ralph Loop Plugin]] — Stop-hook-based autonomous iteration loop. Feeds Claude the same prompt until it outputs a completion promise. For well-defined tasks with clear success criteria and automatic verification.
24	- [[Hookify Plugin]] — Create Claude Code hooks from natural language. `/hookify warn me when I use rm -rf` → working hook instantly. No hooks.json editing required.
25	- [[Knowledge Work Plugins]] — 18 open-source role-specific plugins (sales, legal, finance, design, engineering, HR, ops, etc.) built on Claude Agent SDK.
26	- [[Claude for Legal]] — Deep legal workflow plugin suite (transactional + litigation + learning). Integrates with Westlaw, CourtListener.
27	- [[Claude for Life Sciences]] — Research marketplace: PubMed, BioRender, Synapse, Consensus + RNA-seq/Nextflow skills.
28	- [[Claude for Healthcare]] — Healthcare marketplace: FHIR developer, prior-auth review, clinical trial protocols + CMS/NPI servers.
29	- [[Claude for Financial Services]] — 10 named agents (Pitch Agent, GL Reconciler, Market Researcher, KYC Screener, etc.) + 9 vertical skill bundles (IB, ER, PE, WM, fund admin). Deployable as Cowork plugins or Managed Agent templates.
30	- [[Managed Agents]] — Anthropic's hosted agent orchestration platform. Self-hosted sandbox option (tool execution on your infra via outbound-polling worker), mid-session tool/MCP updates, large MCP output auto-offload. Scheduled deployments (cron, no custom infra). Env vars in vaults (credentials injected at network boundary). Opus 4.8 tool-description guidance included.
31	- [[Claude Agent SDK Demos]] — 8 local demo apps showcasing Claude Agent SDK patterns (multi-agent, streaming, email, docs).
32	- [[Anthropic SDK Go]] — `go get anthropic-sdk-go@v1.56.0`. Go 1.24+. Type-safe Claude API client for Go: model constants, context support, standard Go idioms.
33	- [[Claude Agent SDK TypeScript]] — `npm install @anthropic-ai/claude-agent-sdk`. Node.js 18+. Renamed from Claude Code SDK.
34	- [[Claude Agent SDK Python]] — `pip install claude-agent-sdk`. Python 3.10+. In-process MCP servers, hooks as Python functions, CLI bundled in wheel.
35	- [[Claude Cookbooks]] — Copy-paste code recipes and notebooks for Claude API (RAG, tool use, multimodal, agents).
36	- [[Claude Quickstarts]] — Production-ready starter projects: customer support, computer use, browser automation, coding agent.
37	- [[Anthropic Courses]] — 5-course official curriculum: API fundamentals → prompt engineering → real-world prompting → evals → tool use. Jupyter notebooks.
38	- [[Anthropic Prompt Engineering Tutorial]] — 9-chapter interactive prompt engineering course with exercise playgrounds. Available direct API and Amazon Bedrock variants.
39	- [[Claude Code Action]] — GitHub Action that brings Claude into PR review and CI/CD workflows.
40	- [[Defending Code Reference Harness]] — Reference impl for autonomous vuln discovery + human-reviewed patching. gVisor-sandboxed agents. Not actively maintained; Claude Security is the hosted version.
41	- [[Scone Bench]] — 417-task benchmark for evaluating LLM agents on smart-contract vuln discovery/exploitation. Historical DeFi incidents, MCP-based, Docker-sandboxed. From Anthropic Red Team.
42	- [[Claudes C Compiler]] — Claude Opus 4.6 wrote a dependency-free C compiler in Rust from scratch. Compiles PostgreSQL, SQLite, Linux kernel, FFmpeg. Capability showcase, not production-validated.
43	- [[Anthropic Performance Take-Home]] — Open version of Anthropic's original performance engineering take-home. Optimize a VLIW SIMD kernel; Claude Opus 4.5 scored 1,363 cycles vs 147,734 baseline (108× improvement).
44	- [[Claude Code Security Review]] — GitHub Action that auto-scans PRs for security vulnerabilities using Claude.
45	- [[Claude Desktop Buddy]] — ESP32 desk pet + Bluetooth API reference for makers integrating with Claude Desktop.
46	- [[HTML Effectiveness Examples]] — Anthropic's reference collection of single-file HTML artifacts (slide decks, dashboards, editing UIs, diagrams).
47	- [[Claude Code Setup Plugin]] — Official Anthropic plugin that scans your codebase and recommends tailored hooks, skills, MCP servers, subagents, and plugins. Read-only, 1-2 recs per category.
48	- [[Claude Code Monitoring Guide]] — Prometheus + OpenTelemetry toolkit for tracking Claude Code ROI, token spend, and team adoption.
49	- [[GitHub MCP Server]] — GitHub's official MCP server.
50	- [[PineForge MCP]] — Hosted MCP server for real Pine Script v6 backtests. `claude mcp add --transport http pineforge https://mcp.pineforge.dev/mcp`. No key/signup. 245/246 TradingView parity, 100 backtests/week, 13mo Binance data. Docker route for unlimited/custom data. 60+ tools: repos, issues, PRs, code search, security scanning.
51	- [[Devcontainer Features]] — One-line devcontainer.json feature that installs Claude Code CLI in any dev container.
52	- [[Claude Code Routines]] — Scheduled/triggered cloud automation. Runs on Anthropic infrastructure, not your machine. `/schedule` command, API + GitHub + time triggers. Research preview.
53	- [[Long-Running Agent Primitives]] — 3 core primitives (Default-FAIL, Fresh-context evaluator, Handoff) + 2 operator hooks (kill switch, STEER.md). From Anthropic's own patterns.
54	- [[Claude Plugins Community]] — Community plugin marketplace (security-reviewed). Submit at clau.de/plugin-directory-submission.
55	- [[Anthropic CLI]] — `ant` CLI for the Claude Developer Platform API. `brew install anthropics/tap/ant`.
56	- [[Anthropic CWC Workshops]] — 8 Code-with-Claude workshop curricula: Managed Agents, memory primitives (Dreaming Service), eval-driven dev, multi-agent decomposition, Deal Desk reference impl.
57	- [[Agent SDK Workshop]] — Hands-on workshop for Claude Agent SDK: 4-stage guided demo (chat → tools → subagents → memory) + breakout scenarios. Python 3.10+, flip switches in config.py.
58	- [[Long-Horizon Coding Agent Demo]] — Archived AWS re:Invent 2025 demo. GitHub issue → agent builds full-stack app → CloudFront preview → human approval gate. Bedrock AgentCore + Claude Agent SDK.
59	- [[Claude Foundation Models Swift Package]] — Swift package for hybrid Apple-platform apps: on-device model for fast/private tasks, Claude for reasoning + web search. iOS 27+, SPM install. Announced June 2026.

... [119 lines truncated] ...


Ingest Claude blog post on marketing operations automation


Conversation compacted


This session is being continued from a previous conversation that ran out of context. The summary below covers the earlier portion of the conversation.

Summary:
1. Primary Request and Intent:

This is an ongoing agentic session for James Lopez's nanoclaw AI assistant platform. The session has handled multiple automated tasks:

**Completed tasks:**
- Ingest Claude blog post on Anthropic's Marketing Ops Cowork automation (Jul 8) — created source + concept pages
- Autopilot cycle: StageHand MVP toolchain spec (Jul 8 9pm) — greenfield plan + red-team sent to Slack
- GitHub sweep #25: Documented `anthropic-sdk-go` Go SDK (Jul 9)
- Daily portfolio briefs for Jul 9 and Jul 10 — sent to `slack-infrastructure` (slack-daily-brief not wired)
- Queued @0xCodez tweet about "OpenAI agentic systems course" — flagged @0xCodez is a content creator not OpenAI, identified Coursera as likely source
- Ingested Claude blog post on Cognition/Devin using Fable 5 — created source + concept pages, updated Fable 5 tool page
- Multiple autopilot blocked cycles (all eligible projects blocked on James)

**Current task:** Autopilot reset-wake cycle triggered Jul 11 5:30am CT, high tier (75% burnable, 95% 7d remaining), all eligible projects still blocked on James.

2. Key Technical Concepts:
- **NanoClaw**: AI assistant platform, agents in containers; messaging via `mcp__nanoclaw__send_message`, scheduling via `mcp__nanoclaw__schedule_task`
- **Portfolio Autopilot**: Quota-aware autonomous work loop; reads BOARD.md + project cards; skips blocked projects; writes skip-lock to suppress repeated triggers; logs to `autopilot-run-log.jsonl`; schedules reset-wake after each cycle
- **Skip-lock**: JSON file at `/workspace/agent/autopilot-skip-lock.json` that suppresses trigger fires when all projects are blocked; agent writes it, trigger script reads it
- **Wiki ingestion pipeline**: Source pages in `wiki/sources/`, concept pages in `wiki/concepts/`, tool pages in `wiki/tools/`; always update `Home.md` and `Wiki Ingest Log.md`
- **Relevance policy**: Skip customer case studies for specific industries; prioritize Claude Code features, agent SDKs, workflows, founder/engineering content, Anthropic's own team usage
- **Cowork Dispatcher-Specialist Pattern**: Dispatcher routes intake → specialist agents → independent audit agent → human review; skills as living systems (corrections feed back into skill instructions)
- **Frontier Code Evaluation**: Test models on real production work with your best engineers; gate on "Would I keep this code?" — Cognition's methodology yielding 3× Fable 5 improvement
- **StageHand**: Real estate agent video suite at `~/projects/stagehand` (CreatorFlow); `listing_reel` and `video_narration` workflows are code-complete; next proposed workflow is Local Recs reel
- **Autopilot task types**: Greenfield (plan + red-team only), Continuation (implement autonomously), Review-required (produce change + send for approval)

3. Files and Code Sections:

- **`/workspace/extra/second-brain/wiki/sources/Claude Blog - Marketing Ops Cowork Automation.md`** (created Jul 8)
  - Documents Anthropic's own marketing ops team Cowork deployment patterns: dispatcher routing, audit agent, skill refinement loops

- **`/workspace/extra/second-brain/wiki/concepts/Cowork Dispatcher-Specialist Pattern.md`** (created Jul 8)
  - 3-layer pattern: Dispatcher → Specialist agents → Audit agent → Human review; skills as living systems

- **`/workspace/extra/second-brain/wiki/tools/Anthropic SDK Go.md`** (created Jul 9)
  - `go get anthropic-sdk-go@v1.56.0`, Go 1.24+; type-safe model constants; standard Go idioms

- **`/workspace/extra/second-brain/wiki/sources/Claude Blog - Cognition Claude Fable 5.md`** (created Jul 10)
  - Silas Alberti (Cognition SVP of Research): 8h overnight autonomous runs, ~30% vs ~10% prior Opus on Frontier Code hardest subset

- **`/workspace/extra/second-brain/wiki/concepts/Frontier Code Evaluation.md`** (created Jul 10)
  - Use best engineers to test models on real production work; "Would I keep this code?" as gating question

- **`/workspace/extra/second-brain/wiki/tools/Claude Fable 5 and Mythos 5.md`** (updated Jul 10)
  - Added "Real-world performance validation (Cognition/Devin)" section with 3× benchmark result; added 2 related links

- **`/workspace/extra/second-brain/wiki/Home.md`** (updated multiple times; also externally modified)
  - Added entries for all new sources and concepts; external additions include `[[Test Isolation for Runtime Activity Logs]]`, `[[LaunchAgent Quarantine and Tailscale Recovery]]`, `[[Hermes Provider Fallback Config]]`

- **`/workspace/extra/second-brain/wiki/Wiki Ingest Log.md`** (updated multiple times; also externally modified)
  - New entries prepended for each ingest event; external entries from other sessions added: Pool Monitor test-log isolation, projects index outage recovery, Hermes provider fallback config

- **`/workspace/extra/second-brain/portfolio/BOARD.md`** (unchanged since Jul 8 despite multiple reads)
  - All projects still show "Blocked on James"; StageHand last updated 2026-07-09

- **`/workspace/extra/second-brain/portfolio/projects/StageHand.md`** (updated Jul 9)
  - Next action: "Await James answers on 5 toolchain questions; Local Recs next if green-lit"
  - Blocked on James: voice, agent, posting, pricing, Local Recs y/n
  - 2026-07-09 note: MVP toolchain spec produced; 5 questions sent to James via Slack

- **`/workspace/agent/autopilot-run-log.jsonl`** (appended multiple times)
  - Last entries: StageHand greenfield (shipped), blocked cycles on Jul 9 (2×), blocked high-tier Jul 10

- **`/workspace/agent/autopilot-skip-lock.json`** (written multiple times)
  - Last value: `{"skip_lock_until":"2026-07-11T05:00:00Z","reason":"all_projects_blocked_on_james","set_at":"2026-07-10T21:30:00Z"}` — NOW EXPIRED (it's 5:30am CT = 10:30am UTC on Jul 11)

- **`/workspace/agent/pending-ingests.md`** (updated Jul 10)
  - Added @0xCodez tweet: 3h24m Twitter-hosted video, @0xCodez is content creator not OpenAI, Coursera "Building AI Agents with OpenAI Specialization" may be actual source, high priority for James

4. Errors and Fixes:
- **`slack-daily-brief` destination not found**: Tried to send daily brief to `slack-daily-brief`; got "Unknown destination" error. Fixed by falling back to `slack-infrastructure` and notifying James via Telegram that the destination needs to be wired.
- **WebFetch 402 on x.com**: Could not fetch the @0xCodez tweet page via WebFetch. Fixed by using `mcp__twitter-x__get_tweet_thread` to get tweet content, then WebSearch to identify the likely original source.
- **BOARD.md "wasted call"**: Tried to re-read BOARD.md with Read tool when it hadn't changed. System returned "Wasted call". Fixed by using Bash `cat` to force a fresh read.
- **Duplicate reset-wake scheduling**: After the 11pm Jul 8 cycle, noted that task-1783553618200-dzcmk3 was already scheduled from the 9pm cycle; chose not to duplicate. Subsequent cycles scheduled new tasks normally.

5. Problem Solving:
- **All eligible projects blocked**: The autopilot has been blocked since Jul 9 because James hasn't replied to any queued decisions. The system correctly logs blocked cycles, writes skip-locks to suppress repeated triggers, and sends brief notes to slack-infrastructure.
- **StageHand greenfield plan**: Successfully identified that `listing_reel` and `video_narration` are code-complete; produced prioritized toolchain spec (validate first → Local Recs reel next → Home Improvement deferred); identified TTS/voice as the key cross-cutting decision.
- **@0xCodez tweet**: Video too long (12234s) for direct ingest. Identified that @0xCodez ≠ OpenAI; found likely Coursera source; queued for overnight agent-browser ingest.

6. All User Messages:
- <task from="telegram-mg-17796" time="Jul 8, 2026, 5:00 PM">New Claude blog post detected — ingest `how-anthropics-marketing-operations-team-uses-claude-cowork-to-automate-reporting-and-campaign-builds`</task>
- <task from="telegram-mg-17796" time="Jul 8, 2026, 9:00 PM">Portfolio Autopilot reset-wake: burnable_pct: 36.8, tier: medium, StageHand and nanoclaw P1</task>
- <task from="telegram-mg-17796" time="Jul 8, 2026, 11:00 PM">Portfolio Autopilot run triggered: burnable_pct: 36.8, tier: medium</task>
- <task from="telegram-mg-17796" time="Jul 9, 2026, 8:00 AM">GitHub sweep — 30 updated repos including anthropics/anthropic-sdk-go, newSkillCommits: []</task>
- <task from="telegram-mg-17796" time="Jul 9, 2026, 12:00 PM">Prepare daily portfolio brief, send to slack-daily-brief</task>
- <task from="telegram-mg-17796" time="Jul 9, 2026, 5:00 PM">Portfolio Autopilot run triggered: burnable_pct: 35.4, tier: medium</task>
- <task from="telegram-mg-17796" time="Jul 9, 2026, 8:00 AM">GitHub sweep — 30 updated repos, newSkillCommits: [] (sweep #26)</task>
- <task from="telegram-mg-17796" time="Jul 9, 2026, 12:00 PM">Prepare daily portfolio brief (Jul 10)</task>
- <message id="1642" from="telegram-mg-17796" sender="James Lopez" time="Jul 10, 2026, 7:42 AM">https://x.com/0xcodez/status/2075243533515014238?s=52. Ingest please, first course I've heard of from OpenAI. This one sounds very relevant and useful. [link_ingestion failed: video_too_long_12234s]</message>
- <task from="telegram-mg-17796" time="Jul 10, 2026, 11:00 AM">New Claude blog post: `working-at-the-frontier-how-cognition-trusts-claude-fable-5-to-work-through-the-night`</task>
- <task from="telegram-mg-17796" time="Jul 10, 2026, 4:30 PM">Portfolio Autopilot run: burnable_pct: 75, tier: high, 7d: 98%</task>
- <task from="telegram-mg-17796" time="Jul 11, 2026, 5:30 AM">Portfolio Autopilot run: burnable_pct: 75, tier: high, 7d: 95%, next_reset_at: 2026-07-11T11:00:01.991Z [CURRENT]</task>

7. Pending Tasks:
- **Autopilot Jul 11 5:30am cycle** (CURRENT): All eligible projects blocked on James → write skip-lock, log blocked cycle, send slack note, schedule next reset-wake for 2026-07-11T11:00:01.991Z
- **@0xCodez tweet ingest**: Queued for overnight agent-browser ingest; find Coursera original source first
- **slack-daily-brief destination**: Needs to be wired in nanoclaw; currently falling back to slack-infrastructure
- **nanoclaw deploy**: James needs to run one-liner in Studio terminal
- **Decision queue** (unanswered for 3+ days):
  1. nanoclaw metric: approve "decisions answered per week from daily brief"?
  2. AgenticLever goal: "solution-selling site with question-led discovery flow" — confirm?
  3. TradingBot25 status: live, paper, or paused?
  4. RoadSense 5 launch questions (auth model, city, GIS license, creator posture, metric)
  5. StageHand 5 toolchain questions (voice, agent lined up?, posting model, competitor pricing, Local Recs green-light?)
- **Board confirmation queue**: AgenticLever, TradingBot25, qip-qien, FindRefurbishedAppleProduct, pool-monitor, congressional-trading all awaiting James's goal/card confirmation

8. Current Work:

The most recent task is the **Jul 11 5:30am autopilot cycle**:

```
burnable_pct: 75, tier: high
5h_remaining_pct: 100 (resets_in_sec: -1, already reset)
7d_remaining_pct: 95 (resets_in_sec: 53997, ~15 hours)
next_reset_at: 2026-07-11T11:00:01.991Z (6am CT — next 5h window)
eligible: StageHand(P1), nanoclaw(P1), AgenticLever(P2), RoadSense(P2), qip-qien(P2), congressional-trading(P3), TradingBot25(P3)
```

The skip-lock expired at 2026-07-11T05:00:00Z (midnight CT). It's now 5:30am CT = 10:30am UTC. The board is unchanged from Jul 8:
- StageHand: blocked (5 questions unanswered)
- nanoclaw: blocked (deploy + metric)
- AgenticLever/RoadSense/qip-qien/congressional-trading/TradingBot25: all blocked on James confirmations

This is a **blocked cycle** that needs: write new skip-lock, append to autopilot-run-log.jsonl, send brief note to slack-infrastructure, and schedule next reset-wake for `2026-07-11T11:00:01.991Z`.

9. Optional Next Step:

The current task is the Jul 11 5:30am autopilot cycle. Since all eligible projects remain blocked on James, the next step is to handle this as a blocked cycle:

1. Write skip-lock: `{"skip_lock_until":"2026-07-11T16:00:00Z","reason":"all_projects_blocked_on_james","set_at":"2026-07-11T10:30:00Z"}`
2. Append log entry to `autopilot-run-log.jsonl`: `{"timestamp":"2026-07-11T10:30:00.000Z","tier":"high","burnable_pct":75.0,"project":"none","task_type":"blocked","model_used":"none","outcome":"skipped","notes":"All eligible projects blocked on James for 3+ days. Decision queue unanswered. Skip-lock set until 2026-07-11T16:00:00Z (11am CT)."}`
3. Send brief note to `slack-infrastructure`
4. Schedule next reset-wake via `mcp__nanoclaw__schedule_task` with `processAfter: "2026-07-11T11:00:01.991Z"`

The task instruction states: "If no eligible project has a clear actionable next step, log it and send a brief note to `slack-infrastructure`: what's stalled and why."

---

You MUST wrap all responses in <message to="name">...</message> blocks.
Available destinations: `cli-local`, `cw-coder`, `ingest-into-wiki`, `slack-agenticlever-website`, `slack-infrastructure`, `slack-mg-17835`, `slack-mg-17835-2`, `slack-mg-17835-3`, `slack-mg-17835-4`, `slack-mg-17835-5`, `slack-mg-17835-6`, `slack-qip-qien`, `slack-roadsense`, `slack-stagehand`, `slack-tradingbot25`, `telegram-mg-17796`, `telegram-mg-17800`.

If you need specific details from before compaction (like exact code snippets, error messages, or content you generated), read the full transcript at: /home/node/.claude/projects/-workspace-agent/033a4a00-9171-4e08-9a79-6b99f177355d.jsonl
Continue the conversation from where it left off without asking the user any further questions. Resume directly — do not acknowledge the summary, do not recap what was happening, do not preface with "I'll continue" or similar. Pick up the last task as if the break never happened.


/workspace/extra/second-brain/wiki/tools/Claude Fable 5 and Mythos 5.md

# Claude Fable 5 and Mythos 5

**Type:** Frontier Claude models
**By:** Anthropic
**Status:** Fable 5 (GA), Mythos 5 (Preview)
**Source:** `anthropics/skills` — claude-api skill commit #1294 (June 9, 2026)

## What they are

**Claude Mythos 5** — The underlying frontier model. Preview availability.

**Claude Fable 5** — Same model as Mythos with Anthropic's additional safety/alignment layer applied. The production-ready version. Launch benchmark: state-of-the-art across most tested benchmarks; lead grows as tasks get longer and more complex (reported by practitioners — see [[X AI Signal Sweep - 2026-06-09]]).

## Key API differences from prior Claude models

### Always-on adaptive thinking
- Adaptive thinking is always on for Fable 5 — cannot be disabled.
- Sending `extended_thinking: { enabled: false }` returns HTTP 400.
- Plan for thinking token overhead in context budgets.

### New tokenizer
- Approximately **30% more tokens** per equivalent input compared to prior Claude models.
- Cost accounting must be recalibrated — don't assume prior per-task estimates carry over.
- Use [[AgentsView]] or independent accounting to track actual spend at launch (pricing databases may lag).

### Protected-thinking display and replay rules
- Extended thinking blocks have display/replay restrictions.
- Review Anthropic's current docs for exact rules before surfacing thinking content in products.

### Refusal stop reason + classifier fallback

Fable 5 has conservative classifiers that block requests in three specific areas:

| `stop_details.category` | Fires on |
|---|---|
| `"cyber"` | Offensive cybersecurity content — exploits, malware, attack tooling |
| `"bio"` | Biology / life-sciences — lab methods, molecular mechanisms |
| `"reasoning_extraction"` | Requests attempting to extract the model's summarized thinking |

Response shape on a block:
```json
{
  "stop_reason": "refusal",
  "stop_details": {
    "type": "refusal",
    "category": "cyber",
    "explanation": "..."
  }
}
```

Branch on **`stop_reason`**, not `content` or `stop_details`. `stop_details` can be `null` — treat that as a generic refusal.

**Server-side fallback (recommended):** Pass `fallbacks: [{"model": "claude-opus-4-8"}]` + beta header. On a classifier block, the API automatically retries with Opus 4.8. Currently supported on Claude API and Claude Platform on AWS.

```bash
-H "anthropic-beta: server-side-fallback-2026-06-01"
"fallbacks": [{ "model": "claude-opus-4-8" }]
```

**`stop_details.recommended_model`** — populated only when fallbacks are configured but the fallback model couldn't execute (rate-limited/overloaded). Names the model to retry directly.

**Billing change (when NOT using server-side fallback):** `stop_details.fallback_credit_token` lets you bill the fallback request as a cache read (cheaper). Requires action if you handle fallback client-side.

Source: `claude-cookbooks/fable_5_fallback_billing/guide.ipynb` (June 2026)

The skills repo also ships **SDK fallback middleware** for handling `"refusal"` stop_reason in production SDK flows.

### Data retention
- 30-day data-retention requirement (stricter than prior models in some configurations).
- Relevant for regulated use cases (HIPAA, etc.).

## Migration

Anthropic added a full "Migrating to Claude Fable 5" guide + checklist to the claude-api skill:

1. **Tokenizer recalibration** — update cost estimates, re-validate context-window budgets.
2. **Thinking opt-out removal** — remove any `extended_thinking: false` from request payloads.
3. **Refusal stop reason** — add `"refusal"` to stop_reason handlers and wire in SDK fallback middleware.
4. **Data retention review** — check compliance posture against the 30-day window.
5. **Prompt re-tuning** — Fable/Mythos has behavioral changes vs 4.x models; prompts that were tuned for 4.7 or Opus 4.8 may need adjustments (not API breaking changes, behavioral shifts).

**Mythos Preview path:** Separate migration checklist in the skill for moving from Mythos Preview → GA or Fable 5.

## Real-world performance validation (Cognition / Devin, July 2026)

Silas Alberti (Cognition SVP of Research) reports on Fable 5 powering Devin:
- **Overnight autonomous runs:** "I wake up, and it's been working for eight hours straight" — context coherence holds through messy production environments
- **Frontier Code benchmark:** ~30% on hardest internal subset vs ~10% for prior Opus (3× improvement). Internal eval using top engineers asking "Would I keep this code?" — more predictive than public benchmarks for production use.
- **Key behavioral improvements:** states invariants before execution; acknowledges knowledge gaps rather than fabricating; uses debugging tools correctly under noisy signals.

See [[Claude Blog - Cognition Claude Fable 5]] and [[Frontier Code Evaluation]] for full detail.

## Practical notes for James's stack

- **congressional-trading** — Recalibrate token budgets for any Fable 5 runs; the 30% tokenizer difference directly affects context window planning.
- **qip-qien** — Fable 5's strong performance on long, complex knowledge-work tasks (9+ hour autonomous sessions reported by Ethan Mollick) makes it the right model for the expert-draft pipeline when conviction threshold is high. Cognition's validation (honest uncertainty + no hallucinated answers) directly supports the expert-draft trust model.
- **Pool Monitor / Arduino** — No impact; those are Python scripts with no Claude API calls.
- **nanoclaw autopilot** — 8h overnight autonomous validation supports using Fable 5 for long autopilot cycles when quota allows.

## Practical usage guidance

Anthropic published a field guide (July 6, 2026) on how to work effectively with Fable:

> "Claude Fable is the first model where the quality of the work is bottlenecked by your ability to clarify its unknowns."

Fable executes instructions more literally and completely than prior models — the gap is no longer model capability, it's your specification quality. See [[Finding Your Unknowns Framework]] for a pre-flight protocol.

## Related

- [[Claude Blog - Field Guide to Claude Fable]] — Practical prompting guide: 4-quadrant unknowns model + 8 elicitation techniques
- [[Finding Your Unknowns Framework]] — Concept page distilling the field guide framework
- [[X AI Signal Sweep - 2026-06-09]] — Practitioner capability reports (Karpathy, Mollick, Shipper, Willison)
- [[Frontier Model Qualitative Step Change]] — Pattern for evaluating major model jumps
- [[AgentsView]] — Cost accounting when pricing databases lag launch
- [[Managed Agents]] — Opus 4.8 tool-description guidance (applicable to Fable 5 behavioral profile)
- [[Anthropic Skills Repo]] — Source of the migration guide and API reference
- [[Claude Blog - Cognition Claude Fable 5]] — Cognition's production validation: 3× Frontier Code improvement, 8h overnight autonomous runs
- [[Frontier Code Evaluation]] — Evaluation methodology concept from Cognition's approach

../extra/second-brain/wiki/tools/Claude Fable 5 and Mythos 5.md


# Frontier Code Evaluation

**Origin:** [[Claude Blog - Cognition Claude Fable 5]] (Silas Alberti, Cognition SVP of Research, July 2026)

## What it is

An evaluation methodology where you test AI models on **real production work** done by your best human engineers, using human judgment as the scoring mechanism.

The gating question: *"Would I keep this code?"*

No rubric. No synthetic benchmark. Just your strongest engineers asking whether the model's output is good enough to ship.

---

## Why it matters

Standard public evals measure what can be measured easily — which is often not what matters in production. The Frontier Code approach:

- Tests on work that's representative of your actual hardest problems
- Uses expert judgment calibrated to your quality bar, not a generic benchmark
- Surfaces behavioral differences (reasoning discipline, honest uncertainty, tool use under noise) that benchmarks don't catch

Cognition's results: **~30% (Fable 5) vs ~10% (prior Opus)** on their hardest internal subset — a gap far larger than standard benchmarks would have predicted.

---

## How to apply it

1. **Pick your evaluators carefully** — use your highest-performing practitioners, not average users. The benchmark is only as good as the calibration of the person asking "would I keep this?"
2. **Use real work** — actual tasks from your backlog, not constructed test cases
3. **Focus on your hardest subset** — easy tasks converge across models; hard tasks reveal the gap
4. **Grade the output, not the process** — don't watch the model work; evaluate what it produces

---

## When to use it

- **Model selection:** choosing between frontier models for a production use case
- **Feature evals:** testing whether a new model version improves your specific use case
- **Regression checks:** verifying a new model didn't regress on capabilities you rely on

---

## Relationship to public benchmarks

Public benchmarks are necessary for broad comparability but insufficient for production decisions. Use them to filter the candidate set; use Frontier Code-style eval to make the final call.

> "Their highest-performing developers personally test models on real work, asking: 'Would I keep this code?'" — Silas Alberti, Cognition

## Related
- [[Frontier Model Qualitative Step Change]] — broader pattern this methodology implements
- [[Claude Blog - Cognition Claude Fable 5]] — source, with Cognition's specific benchmark results
- [[Builder-Verifier Loop Pattern]] — the "separate evaluator" principle applies to human eval too


/workspace/extra/second-brain/wiki/sources/Claude Blog - Cognition Claude Fable 5.md

# Claude Blog — Working at the Frontier: How Cognition Trusts Claude Fable 5 to Work Through the Night

**Source:** https://claude.com/blog/working-at-the-frontier-how-cognition-trusts-claude-fable-5-to-work-through-the-night
**Author:** Silas Alberti, SVP of Research at Cognition
**Date:** July 10, 2026

## Summary

Cognition (makers of Devin, the autonomous AI software engineer) describes how Claude Fable 5 enabled a qualitative shift in their product — from tasks that could run for an hour to agents that reliably work for eight hours overnight without human rescue.

---

## Use case: Devin on Fable 5

Devin handles production work for enterprise clients:
- **Database migrations** with consistency verification
- **Incident triage** and log analysis
- **Proactive Slack monitoring** for issue detection
- **Production monitoring** and autonomous spike triage

Before Fable 5, agents could stay on task for minutes to an hour. Now: "I wake up, and it's been working for eight hours straight."

---

## Evaluation methodology: Frontier Code

Cognition does not rely on standard public evals. Instead:
- Their highest-performing developers personally test models on **real production work**
- The gating question: *"Would I keep this code?"*
- This benchmark is internal ("Frontier Code") and designed to catch what standard evals miss

**Results on Fable 5 vs. prior Opus:**
- Hardest Frontier Code subset: **~30% (Fable 5) vs ~10% (prior Opus)** — a 3× improvement

This is the same eval philosophy as the [[Frontier Model Qualitative Step Change]] pattern: practitioner judgment on real work, not synthetic benchmarks.

---

## Key Fable 5 capability improvements (Cognition's view)

| Capability | What changed |
|---|---|
| **Extended autonomy** | Hours → overnight; context stays coherent through messy, complex environments |
| **Reasoning discipline** | States invariants *before* execution; doesn't claim "the first plausible thing" |
| **Honest uncertainty** | Acknowledges knowledge gaps rather than fabricating plausible-sounding answers |
| **Tool use under noise** | Properly uses debugging tools and draws accurate conclusions despite noisy signals |

---

## Key quote

> "I wake up, and it's been working for eight hours straight."

> "It no longer confidently claims the first plausible thing… it actually acknowledges when it doesn't know and reasons carefully to a conclusion."

---

## Applicability to James's stack

- **nanoclaw** — 8h autonomous runs validate the architecture; Fable 5 is the right model for long autopilot cycles
- **qip-qien** — expert draft pipeline benefits from Fable 5's honest uncertainty + reasoning discipline (doesn't fabricate citations)
- **congressional-trading** — long multi-source research runs benefit from context coherence over hours
- **StageHand** — video generation orchestration with multiple steps; Fable 5's tool-use-under-noise property directly applies

## Related
- [[Claude Fable 5 and Mythos 5]] — full API reference, migration checklist, model characteristics
- [[Frontier Model Qualitative Step Change]] — pattern this article is a concrete data point for
- [[Frontier Code Evaluation]] — concept page extracted from Cognition's evaluation methodology
- [[Long-Running Agent Primitives]] — structural patterns for the autonomous overnight runs Fable 5 now enables
- [[Claude Blog - Field Guide to Claude Fable]] — Anthropic's own prompting guidance for Fable 5

../extra/second-brain/wiki/sources/Claude Blog - Cognition Claude Fable 5.md


<system>Your response was not delivered — it was not wrapped in <message to="name">...</message> blocks. All output must be wrapped: use <message to="name"> for content to send, or <internal> for scratchpad. Your destinations: cli-local, cw-coder, ingest-into-wiki, slack-agenticlever-website, slack-infrastructure, slack-mg-17835, slack-mg-17835-2, slack-mg-17835-3, slack-mg-17835-4, slack-mg-17835-5, slack-mg-17835-6, slack-qip-qien, slack-roadsense, slack-stagehand, slack-tradingbot25, telegram-mg-17796, telegram-mg-17800. Please re-send your response with the correct wrapping.</system>


Let me pick up where we left off. The current task is the Jul 11 5:30am autopilot cycle. All eligible projects are blocked on James. I need to:

1. Write skip-lock
2. Append to autopilot-run-log.jsonl
3. Send brief note to slack-infrastructure
4. Schedule next reset-wake for 2026-07-11T11:00:01.991Z

Let me do all of these now.


ToolSearch

Question: select:SendMessage,mcp__nanoclaw__schedule_task


Question: select:SendMessage,mcp__nanoclaw__schedule_task


Prompt: <system>Your response was not delivered — it was not wrapped in <message to="name">...</message> blocks. All output must be wrapped: use <message to="name"> for content to send, or <internal> for scratchpad. Your destinations: cli-local, cw-coder, ingest-into-wiki, slack-agenticlever-website, slack-infrastructure, slack-mg-17835, slack-mg-17835-2, slack-mg-17835-3, slack-mg-17835-4, slack-mg-17835-5, slack-mg-17835-6, slack-qip-qien, slack-roadsense, slack-stagehand, slack-tradingbot25, telegram-mg-17796, telegram-mg-17800. Please re-send your response with the correct wrapping.</system>


I need to handle the Jul 11 5:30am autopilot cycle. All eligible projects are blocked on James. I need to:

1. Write skip-lock
2. Append to autopilot-run-log.jsonl
3. Send brief note to slack-infrastructure
4. Schedule next reset-wake for 2026-07-11T11:00:01.991Z

Let me do all of these now, and remember to wrap all output in message blocks.


Write

{"skip_lock_until":"2026-07-11T16:00:00Z","reason":"all_projects_blocked_on_james","set_at":"2026-07-11T10:30:00Z"}


<tool_use_error>File has not been read yet. Read it first before writing to it.</tool_use_error>

Error: File has not been read yet. Read it first before writing to it.


1	{"skip_lock_until":"2026-07-11T05:00:00Z","reason":"all_projects_blocked_on_james","set_at":"2026-07-10T21:30:00Z"}
2


{"skip_lock_until":"2026-07-11T16:00:00Z","reason":"all_projects_blocked_on_james","set_at":"2026-07-11T10:30:00Z"}


The file /workspace/agent/autopilot-skip-lock.json has been updated successfully. (file state is current in your context — no need to Read it back)


Bash

echo '{"timestamp":"2026-07-11T10:30:00.000Z","tier":"high","burnable_pct":75.0,"project":"none","task_type":"blocked","model_used":"none","outcome":"skipped","notes":"All eligible projects blocked on James for 3+ days. Decision queue unanswered (nanoclaw metric, StageHand toolchain Qs, RoadSense launch Qs, board confirmations). Skip-lock set until 2026-07-11T16:00:00Z (11am CT)."}' >> /workspace/agent/autopilot-run-log.jsonl && echo "done"

Append blocked cycle entry to autopilot run log


done


Prompt: Portfolio Autopilot reset-wake. Read /workspace/agent/autopilot-run-log.jsonl (last 5 lines) and /workspace/extra/second-brain/portfolio/BOARD.md to assess current state. Check quota context from your task metadata. Run the autopilot cycle per your standard protocol: identify eligible projects (not blocked on James), pick highest priority with a clear next action, execute or log blocked. If all projects remain blocked on James, log the blocked cycle, write skip-lock, send a brief note to slack-infrastructure, and schedule the next reset-wake.


Task scheduled (id: task-1783749768742-jf7ss0, runs at: 2026-07-11T11:00:01.991Z)


<message to="slack-infrastructure">*Autopilot blocked — Jul 11, 5:30am CT (high tier, 75% burnable)*

All eligible projects still blocked on James. Decision queue has been unanswered for 3+ days:

• *StageHand* — 5 toolchain Qs (voice, agent, posting, pricing, Local Recs y/n)
• *nanoclaw* — deploy one-liner + metric confirmation
• *RoadSense* — 5 launch Qs (auth, city, GIS license, creator posture, metric)
• *AgenticLever/qip-qien/TradingBot25/congressional-trading* — board card confirmations

Next autopilot window: 6am CT. Skip-lock set until 11am CT.
→ Reply to any of the queued Qs above to unblock a project.</message>

<internal>That handles the blocked cycle. Next reset-wake is scheduled for 6am CT (2026-07-11T11:00:01.991Z). Skip-lock is set until 11am CT (16:00Z). Log entry appended. Slack note sent. All done for this cycle.</internal>


<context timezone="America/Chicago" />
<task from="telegram-mg-17796" time="Jul 10, 2026, 8:01 AM">Script output:
{
  "updatedRepos": [
    {
      "name": "anthropics/claude-cookbooks",
      "updated": "2026-07-11T07:59:35Z",
      "desc": "A collection of notebooks/recipes showcasing some fun and effective ways of using Claude.",
      "url": "https://github.com/anthropics/claude-cookbooks"
    },
    {
      "name": "anthropics/claude-code",
      "updated": "2026-07-11T07:59:24Z",
      "desc": "Claude Code is an agentic coding tool that lives in your terminal, understands your codebase, and helps you code faster by executing routine tasks, explaining complex code, and handling git workflows - all through natural language commands.",
      "url": "https://github.com/anthropics/claude-code"
    },
    {
      "name": "anthropics/skills",
      "updated": "2026-07-11T07:55:24Z",
      "desc": "Public repository for Agent Skills",
      "url": "https://github.com/anthropics/skills"
    },
    {
      "name": "anthropics/claude-for-legal",
      "updated": "2026-07-11T07:54:35Z",
      "desc": "A suite of plugins for legal workflows",
      "url": "https://github.com/anthropics/claude-for-legal"
    },
    {
      "name": "anthropics/anthropic-sdk-go",
      "updated": "2026-07-11T07:42:38Z",
      "desc": "Access to Anthropic's safety-first language model APIs via Go",
      "url": "https://github.com/anthropics/anthropic-sdk-go"
    },
    {
      "name": "anthropics/financial-services",
      "updated": "2026-07-11T07:38:57Z",
      "desc": null,
      "url": "https://github.com/anthropics/financial-services"
    },
    {
      "name": "anthropics/jacobian-lens",
      "updated": "2026-07-11T07:35:06Z",
      "desc": " Companion code for the global workspace interpretability paper",
      "url": "https://github.com/anthropics/jacobian-lens"
    },
    {
      "name": "anthropics/original_performance_takehome",
      "updated": "2026-07-11T07:13:06Z",
      "desc": "Anthropic's original performance take-home, now open for you to try!",
      "url": "https://github.com/anthropics/original_performance_takehome"
    },
    {
      "name": "anthropics/claude-agent-sdk-python",
      "updated": "2026-07-11T07:06:35Z",
      "desc": null,
      "url": "https://github.com/anthropics/claude-agent-sdk-python"
    },
    {
      "name": "anthropics/claude-plugins-official",
      "updated": "2026-07-11T07:05:38Z",
      "desc": "Official, Anthropic-managed directory of high quality Claude Code Plugins.",
      "url": "https://github.com/anthropics/claude-plugins-official"
    },
    {
      "name": "anthropics/claude-quickstarts",
      "updated": "2026-07-11T06:18:01Z",
      "desc": "A collection of projects designed to help developers quickly get started with building deployable applications using the Claude API",
      "url": "https://github.com/anthropics/claude-quickstarts"
    },
    {
      "name": "anthropics/evals",
      "updated": "2026-07-11T06:12:35Z",
      "desc": null,
      "url": "https://github.com/anthropics/evals"
    },
    {
      "name": "anthropics/courses",
      "updated": "2026-07-11T06:11:30Z",
      "desc": "Anthropic's educational courses",
      "url": "https://github.com/anthropics/courses"
    },
    {
      "name": "anthropics/prompt-eng-interactive-tutorial",
      "updated": "2026-07-11T06:00:07Z",
      "desc": "Anthropic's Interactive Prompt Engineering Tutorial",
      "url": "https://github.com/anthropics/prompt-eng-interactive-tutorial"
    },
    {
      "name": "anthropics/knowledge-work-plugins",
      "updated": "2026-07-11T05:58:43Z",
      "desc": "Open source repository of plugins primarily intended for knowledge workers to use in Claude Cowork",
      "url": "https://github.com/anthropics/knowledge-work-plugins"
    },
    {
      "name": "anthropics/cwc-workshops",
      "updated": "2026-07-11T05:19:53Z",
      "desc": null,
      "url": "https://github.com/anthropics/cwc-workshops"
    },
    {
      "name": "anthropics/html-effectiveness",
      "updated": "2026-07-11T05:10:12Z",
      "desc": "HTML effectiveness examples",
      "url": "https://github.com/anthropics/html-effectiveness"
    },
    {
      "name": "anthropics/buffa",
      "updated": "2026-07-11T05:01:09Z",
      "desc": "Rust implementation of protobuf with editions support, JSON serialization, and zero-copy views",
      "url": "https://github.com/anthropics/buffa"
    },
    {
      "name": "anthropics/defending-code-reference-harness",
      "updated": "2026-07-11T04:38:35Z",
      "desc": "Skills for threat modeling, scanning, triage, patching, plus an autonomous scanning harness you can /customize",
      "url": "https://github.com/anthropics/defending-code-reference-harness"
    },
    {
      "name": "anthropics/claude-code-action",
      "updated": "2026-07-11T04:31:13Z",
      "desc": null,
      "url": "https://github.com/anthropics/claude-code-action"
    },
    {
      "name": "anthropics/claude-code-security-review",
      "updated": "2026-07-11T04:24:58Z",
      "desc": "An AI-powered security review GitHub Action using Claude to analyze code changes for security vulnerabilities.",
      "url": "https://github.com/anthropics/claude-code-security-review"
    },
    {
      "name": "anthropics/healthcare",
      "updated": "2026-07-11T04:17:17Z",
      "desc": null,
      "url": "https://github.com/anthropics/healthcare"
    },
    {
      "name": "anthropics/claudes-c-compiler",
      "updated": "2026-07-11T01:52:20Z",
      "desc": "Claude Opus 4.6 wrote a dependency-free C compiler in Rust, with backends targeting x86 (64- and 32-bit), ARM, and RISC-V, capable of compiling a booting Linux kernel.",
      "url": "https://github.com/anthropics/claudes-c-compiler"
    },
    {
      "name": "anthropics/claude-ai-mcp",
      "updated": "2026-07-11T01:34:48Z",
      "desc": "Report issues related to MCP integration with Claude here.",
      "url": "https://github.com/anthropics/claude-ai-mcp"
    },
    {
      "name": "anthropics/anthropic-tools",
      "updated": "2026-07-11T01:26:10Z",
      "desc": null,
      "url": "https://github.com/anthropics/anthropic-tools"
    },
    {
      "name": "anthropics/anthropic-cli",
      "updated": "2026-07-11T01:24:48Z",
      "desc": "The CLI for the Claude API",
      "url": "https://github.com/anthropics/anthropic-cli"
    },
    {
      "name": "anthropics/claude-code-base-action",
      "updated": "2026-07-11T00:52:58Z",
      "desc": "This repo is a mirror of the contents of base-action in https://github.com/anthropics/claude-code-action.",
      "url": "https://github.com/anthropics/claude-code-base-action"
    },
    {
      "name": "anthropics/claude-agent-sdk-typescript",
      "updated": "2026-07-11T00:51:59Z",
      "desc": null,
      "url": "https://github.com/anthropics/claude-agent-sdk-typescript"
    },
    {
      "name": "anthropics/claude-desktop-buddy",
      "updated": "2026-07-11T00:13:37Z",
      "desc": "Reference and an example for the Bluetooth API for makers in Claude Cowork & Claude Code Desktop",
      "url": "https://github.com/anthropics/claude-desktop-buddy"
    },
    {
      "name": "anthropics/launch-your-agent",
      "updated": "2026-07-10T23:31:12Z",
      "desc": "Claude Code skills that take a founder from idea to a live Claude Managed Agent: interview, scope a v0, launch in their own account, grade it, iterate, and schedule it",
      "url": "https://github.com/anthropics/launch-your-agent"
    }
  ],
  "newSkillCommits": []
}

Instructions:
Check for new or updated Anthropic GitHub repos and ingest anything relevant into the second brain wiki at /workspace/extra/second-brain/.

The script has provided `data` with two fields:
- `updatedRepos`: repos in the anthropics org updated since last check
- `newSkillCommits`: new commits to anthropics/skills

For each item in updatedRepos and newSkillCommits:
1. Evaluate relevance — prioritize: skills, plugins, Claude Code updates, agent SDKs, new tools. Skip: internal tooling, Rust/infra libs (buffa, connect-rust), coursework unless it's about agents.
2. For relevant repos: fetch the README, extract what the tool/skill does, who it's for, and any notable features
3. Create or update wiki pages in /workspace/extra/second-brain/wiki/tools/ or a new wiki/repos/ folder as appropriate
4. Update wiki/index.md and wiki/log.md
5. Message James (telegram-mg-17796) with a concise summary of what was new and what was ingested. If nothing relevant, send a brief "checked GitHub, nothing new worth ingesting" message.</task>


This is a GitHub sweep task. I need to evaluate the repos, fetch READMEs for relevant ones, and ingest into the wiki. Let me look at the list and identify what's most relevant:

**High relevance (definitely worth ingesting):**
1. `anthropics/claude-agent-sdk-python` - null desc, but "claude-agent-sdk" is very relevant
2. `anthropics/claude-agent-sdk-typescript` - null desc, but same - very relevant
3. `anthropics/claude-plugins-official` - "Official, Anthropic-managed directory of high quality Claude Code Plugins" - very relevant
4. `anthropics/knowledge-work-plugins` - plugins for knowledge workers in Claude Cowork - relevant
5. `anthropics/defending-code-reference-harness` - threat modeling and autonomous scanning tools - relevant for James's coding agent work
6. `anthropics/launch-your-agent` - end-to-end Claude Managed Agent creation workflow - VERY relevant for James
7. `anthropics/claudes-c-compiler` - a C compiler written in Rust by Claude Opus, targeting multiple architectures - interesting showcase of Claude's capabilities
8. `anthropics/jacobian-lens` - interpretability research companion code - less directly applicable
9. `anthropics/html-effectiveness` - HTML examples - potentially useful
10. `anthropics/claude-for-legal` - legal workflow plugins - not directly relevant but shows the plugin ecosystem
11. `anthropics/financial-services` - financial services vertical
12. `anthropics/cwc-workshops` - likely Cowork workshops
13. `anthropics/evals` - evals framework

Looking at medium relevance items like the security review GitHub Action and the desktop buddy reference for Bluetooth API integration.

I should skip the internal infrastructure repos, hiring materials, educational content, and industry-specific case studies. The CLI tool for the Claude API is worth checking out though.

My priority should be fetching READMEs from the most directly applicable repos - starting with `launch-your-agent` since it's most relevant to James's founder-building-agents context, then the Agent SDKs for both Python and TypeScript.

I'll also grab the plugin directory, security harness, Cowork plugins, and the C compiler demo. Since these are just GitHub READMEs, I can fetch them efficiently using WebFetch to get the raw content.


ToolSearch

Question: select:WebFetch


Question: select:WebFetch


Good, WebFetch is available. But the note says "For GitHub URLs, prefer using the gh CLI via Bash instead." So let me use Bash with gh commands to fetch README content for the relevant repos.

Let me parallelize the README fetches for the most relevant repos. I'll prioritize:
1. `launch-your-agent` - most directly applicable
2. `claude-agent-sdk-python` - Agent SDK Python
3. `claude-agent-sdk-typescript` - Agent SDK TypeScript
4. `claude-plugins-official` - plugin directory
5. `defending-code-reference-harness` - security skills harness
6. `knowledge-work-plugins` - Cowork plugins
7. `claudes-c-compiler` - capability showcase

I'll send a quick acknowledgment first, then fetch all the READMEs in parallel.


GitHub sweep #27 — 30 repos updated. Fetching READMEs for the high-signal ones now (launch-your-agent, agent SDKs, plugins, defending-code harness, claudes-c-compiler). Back shortly.

Summary: GitHub sweep #27 — fetching READMEs


Error: text is required


Let me send the acknowledgment and then fetch READMEs in parallel. I'll use gh CLI via Bash for GitHub README fetches.


GitHub sweep #27 — 30 repos updated. Fetching READMEs for the high-signal ones now (launch-your-agent, agent SDKs, plugins, defending-code harness, claudes-c-compiler). Back shortly.


Message sent to telegram-mg-17796 (id: 1739)


Bash

gh api repos/anthropics/launch-your-agent/readme --jq '.content' | base64 -d 2>/dev/null | head -200

Fetch launch-your-agent README


/bin/bash: line 1: gh: command not found


gh api repos/anthropics/claude-agent-sdk-python/readme --jq '.content' | base64 -d 2>/dev/null | head -200

Fetch claude-agent-sdk-python README


gh api repos/anthropics/claude-agent-sdk-typescript/readme --jq '.content' | base64 -d 2>/dev/null | head -200

Fetch claude-agent-sdk-typescript README


gh api repos/anthropics/claude-plugins-official/readme --jq '.content' | base64 -d 2>/dev/null | head -150

Fetch claude-plugins-official README


gh api repos/anthropics/defending-code-reference-harness/readme --jq '.content' | base64 -d 2>/dev/null | head -150

Fetch defending-code-reference-harness README


gh api repos/anthropics/knowledge-work-plugins/readme --jq '.content' | base64 -d 2>/dev/null | head -150

Fetch knowledge-work-plugins README


gh api repos/anthropics/claudes-c-compiler/readme --jq '.content' | base64 -d 2>/dev/null | head -100

Fetch claudes-c-compiler README


No `gh` CLI available. I'll use WebFetch with raw.githubusercontent.com URLs to get the README content. Let me try fetching them via the raw GitHub URLs.


WebFetch

Prompt: Extract: what this repo does, who it's for, what skills/steps are included, and any notable features or workflow details. Keep it concise.


Prompt: Extract: what this SDK does, key features, installation, and any notable usage examples. Keep it concise.


Prompt: Extract: what this SDK does, key features, installation, and any notable usage examples. Keep it concise.


Prompt: Extract: what this repo is, what plugins are included, how to install/use them. Keep it concise.


Prompt: Extract: what skills are included, what the harness does, how to use it. Keep it concise.


Prompt: Extract: what plugins are included, what they do, how they're used in Claude Cowork. Keep it concise.


# Claude Agent SDK Overview

**What It Does:**
The Claude Agent SDK lets developers build autonomous AI agents powered by Claude. These agents can "understand codebases, edit files, run commands, and execute complex workflows."

**Key Features:**
- Codebase comprehension and analysis
- File editing capabilities
- Command execution
- Complex workflow automation

**Installation:**
```sh
npm install @anthropic-ai/claude-agent-sdk
```

**Notable Context:**
This represents a rebrand of the Claude Code SDK. Developers migrating from the previous version should consult the official migration guide for details on breaking changes.

**Community & Support:**
- Report issues via GitHub
- Join the Claude Developers Discord for peer support and collaboration

**Important Note:**
The SDK collects usage data and feedback. Review Anthropic's data usage policies and privacy safeguards before implementation.


Prompt: Extract: what this is, what was accomplished, supported targets, notable technical details. Keep it concise.


# launch-your-agent Overview

**What it does:**
This Claude Code skill guides technical founders through building managed agents. It follows a structured workflow: interviewing you about your needs, scoping a v0 version, launching it in your account, evaluating it against success criteria, iterating as needed, and optionally scheduling recurring deployments.

**Who it's for:**
Technical founders wanting to build internal workers, product features, or customer-facing agents on Claude Managed Agents.

**Key skills/steps:**
- **Main skill** (`launch-your-agent`): Four-phase process covering interview, staging & launch, grading & iteration, and autonomous scheduling
- **Companion skill** (`wrap-up`): Status check and next-steps planning for completed agents

**Notable features:**
- "A live managed agent in your Console (agent + environment + graded run, plus a scheduled deployment if your task recurs)" and accompanying documentation files
- Educational approach with explanations at each step (prioritizes clarity over token efficiency)
- Delivers a `my-agent/` folder containing build artifacts, API payloads, a resumable launch script, evaluation templates, and a v1/v2 roadmap
- Reference documentation includes CMA primitives inventory, interview-to-configuration mapping, and production examples

**Licensing:** Apache 2.0; reference implementation not actively maintained.


# Claude Code Plugins Directory Summary

**What it is:** A curated marketplace of plugins for Claude Code, containing both Anthropic-developed internal plugins and third-party external submissions.

**Plugins included:** The directory hosts two categories:
- Internal plugins maintained by Anthropic (found in `/plugins`)
- Community and partner-created plugins (in `/external_plugins`)

**Installation:** Users can install plugins through Claude Code's interface using the command `/plugin install {plugin-name}@claude-plugins-official` or by browsing the discover section.

**Key consideration:** As the site warns, "Make sure you trust a plugin before installing, updating, or using it. Anthropic does not control what MCP servers, files, or other software are included." Users should review each plugin's homepage for details about functionality and security.

**Important constraint:** Plugin names cannot be changed after publication—doing so breaks existing installations. If renaming is necessary, developers must add migration entries to handle the transition.


# Claude Agent SDK for Python

## What It Does
This SDK enables programmatic interaction with Claude Code through Python. It facilitates building AI agents that can execute tasks, access tools, and maintain bidirectional conversations with Claude.

## Key Features

**Core Capabilities:**
- Async query interface for Claude Code interaction
- "Full Claude Code toolset (Read, Write, Edit, Bash, and others)" with permission controls
- Custom in-process tools via MCP servers (no subprocess overhead)
- Interactive conversations through `ClaudeSDKClient`
- Hook system for intercepting and controlling agent behavior

**Notable Strengths:**
- "No subprocess management" and "Better performance" compared to external MCP servers
- Type-safe Python function definitions for custom tools
- Mixed support for both SDK and external MCP servers
- Built-in error handling with specific exception types

## Installation

```bash
pip install claude-agent-sdk
```

Requires Python 3.10+. The Claude Code CLI is automatically bundled—no separate installation needed.

## Quick Usage Example

```python
import anyio
from claude_agent_sdk import query

async def main():
    async for message in query(prompt="What is 2 + 2?"):
        print(message)

anyio.run(main)
```

## Notable Features for Advanced Use

The SDK distinguishes itself through in-process custom tools that eliminate "the need for separate processes" and custom hooks for deterministic workflow control, making it suitable for production applications requiring fine-grained agent behavior management.


# Knowledge Work Plugins Summary

## What's Included
Anthropic offers 11 open-source plugins spanning key business functions: productivity, sales, customer support, product management, marketing, legal, finance, data, enterprise search, bio-research, and plugin management tools.

## What They Do
Each plugin equips Claude with role-specific expertise. For example, the sales plugin helps with prospect research and call preparation, while the finance plugin handles journal entries and financial statements. Plugins bundle skills, external tool connectors, slash commands, and sub-agents tailored to specific workflows.

## How They Work in Cowork
Plugins activate automatically within Claude Cowork sessions. Users can trigger explicit actions via slash commands (like `/sales:call-prep`) or let Claude draw on domain knowledge automatically. The real value emerges when teams customize plugins with their own tools, terminology, and processes—transforming Claude from a generic assistant into "a cross-functional expert" aligned with company-specific workflows.

Users install from claude.com/plugins, and all plugins are file-based (markdown and JSON) with no coding required.


# Defending Code Reference Harness: Overview

## Included Skills
The repository provides interactive Claude Code skills for vulnerability discovery:
- `/quickstart`: Guided introduction
- `/threat-model`: Build security threat models
- `/vuln-scan`: Run static vulnerability scans
- `/triage`: Verify and rank findings
- `/patch`: Generate candidate fixes
- `/customize`: Port the pipeline to other languages/vulnerabilities

## What the Harness Does
The autonomous pipeline executes a seven-stage workflow for finding and fixing vulnerabilities:

1. **Build** - Compiles target into Docker image with ASAN (memory error detector)
2. **Recon** - Identifies distinct input-parsing subsystems to attack separately
3. **Find** - Parallel agents craft malformed inputs until crashes reproduce consistently
4. **Verify** - Separate grader agent reproduces crashes in isolated containers
5. **Dedupe** - Judge agent identifies new vs. duplicate bugs
6. **Report** - Generates exploitability analysis per unique vulnerability
7. **Patch** - Proposes fixes and validates they work

## How to Use It

**Day 1 (Interactive):** Run `/threat-model`, `/vuln-scan`, `/triage`, and `/patch` on your code—these only read/write files and need no sandbox.

**Day 2+:** Use `bin/vp-sandboxed run` to execute the autonomous pipeline within gVisor containers with restricted network egress.

**Customize:** Port to your tech stack via `/customize` by answering: what signals a bug, what does proof-of-concept look like, and how do you build/run targets?


# CCC — Claude's C Compiler

**What it is:** A complete C compiler built in Rust with no external compiler dependencies, implementing every component from scratch.

**Key accomplishment:** The entire codebase and documentation were "written by Claude Opus 4.6" with minimal human guidance beyond test case specification. This demonstrates AI's capability to generate functional, production-grade compiler infrastructure.

**Supported targets:**
- x86-64 (default)
- AArch64 (ARM)
- RISC-V 64
- i686 (32-bit x86)

**Notable technical details:**
- Produces ELF executables using a custom SSA-based intermediate representation
- Includes 15+ optimization passes, a built-in assembler, linker, and DWARF debug info generation
- Successfully compiles major real-world projects: PostgreSQL (all 237 tests), SQLite, CPython, FFmpeg, and the Linux kernel
- Over 150 additional projects build successfully
- Implements x86 80-bit extended precision and partial NEON support
- Works as a GCC-compatible drop-in replacement for build systems

**Caveats:** The authors emphasize the code "has not been validated for correctness" and recommend against production use without further vetting.


Excellent! I now have all the README content. Let me now decide which repos warrant wiki pages and what to write:

1. **launch-your-agent** - Very high signal. This is literally a skill for founders to go from idea → live managed agent. Directly applicable to James. Create a tool page.

2. **claude-agent-sdk-python** - This is the Python Agent SDK. Very important. We already have a page for the TypeScript one? Let me check. Actually we haven't. Create pages for both Python and TypeScript SDKs.
3. **claude-agent-sdk-typescript** - Same as above, TypeScript version. Note it's a rebrand of Claude Code SDK.

4. **claude-plugins-official** - This is the official plugin marketplace. Important to know about. Create a brief page or note.

5. **defending-code-reference-harness** - Security skills. Interesting but less directly relevant to James's current stack. Could note it briefly.

6. **knowledge-work-plugins** - 11 open-source plugins for Cowork. Relevant for James's Cowork exploration. Create a page or note.

7. **claudes-c-compiler** -  Impressive capability showcase where Claude Opus 4.6 wrote a full C compiler that boots Linux, but not actionable for James's current needs. I should prioritize creating the high-value pages first—the Agent SDKs, the Launch Your Agent Skill guide, and the Knowledge Work Plugins—then check the existing wiki structure to see what's already there before filling in the rest.


No files found


No existing pages for Agent SDK Python/TypeScript or Launch-your-agent. Let me create them. I'll also need to read Home.md and Wiki Ingest Log.md to update them.

Let me create all the pages and then update the index files. I'll parallelize the creation of wiki pages.

Here's my plan:
1. Create 4 wiki pages (parallelize)
2. Read Home.md and Wiki Ingest Log.md
3. Update both files
Now I'm writing out the wiki pages.


Write

/workspace/extra/second-brain/wiki/tools/Claude Agent SDK Python.md

# Claude Agent SDK — Python

**Type:** Official Anthropic SDK
**By:** Anthropic
**Status:** Active
**Source:** `anthropics/claude-agent-sdk-python` (updated 2026-07-11)
**Install:** `pip install claude-agent-sdk` (Python 3.10+)

## What it is

Python SDK for programmatically controlling Claude Code agents. Lets you build autonomous agents that read files, write code, run bash commands, and maintain multi-turn conversations — all without managing a subprocess or external MCP server.

Replaces the pattern of shelling out to `claude` with a proper Python async interface.

## Key features

- **Async query interface** — `async for message in query(prompt=...)` streams agent output
- **Full Claude Code toolset** — Read, Write, Edit, Bash, and all other CC tools, with permission controls
- **In-process custom tools** — define Python functions as tools via MCP; no subprocess overhead, better performance
- **Interactive client** — `ClaudeSDKClient` for multi-turn conversations
- **Hook system** — intercept and control agent behavior at each step (deterministic workflow control)

Claude Code CLI is bundled automatically — no separate install.

## Quick start

```python
import anyio
from claude_agent_sdk import query

async def main():
    async for message in query(prompt="What is 2 + 2?"):
        print(message)

anyio.run(main)
```

## When to use

- Orchestrating Claude Code as a worker from Python scripts or pipelines
- Building custom agents with domain-specific in-process tools
- Programmatic CI/CD or code-review flows driven by Python

## Related

- [[Claude Agent SDK TypeScript]] — same capability, TypeScript/Node.js
- [[Anthropic SDK Go]] — lower-level API SDK (not agent orchestration)
- [[Managed Agents]] — the platform Claude Managed Agents runs on
- [[Launch Your Agent Skill]] — guided skill for going from idea → live managed agent


/workspace/extra/second-brain/wiki/tools/Claude Agent SDK TypeScript.md

# Claude Agent SDK — TypeScript

**Type:** Official Anthropic SDK
**By:** Anthropic
**Status:** Active (rebrand of Claude Code SDK)
**Source:** `anthropics/claude-agent-sdk-typescript` (updated 2026-07-11)
**Install:** `npm install @anthropic-ai/claude-agent-sdk`

## What it is

TypeScript/Node.js SDK for building autonomous AI agents powered by Claude. Agents can understand codebases, edit files, run commands, and execute complex multi-step workflows.

This is a **rebrand of the Claude Code SDK** — if migrating from the old package, check the official migration guide for breaking changes.

## Key features

- Codebase comprehension and analysis
- File editing and creation
- Shell command execution
- Complex workflow automation
- Bidirectional conversation support

## When to use

- Building Node.js-based agent orchestration
- TypeScript-first codebases that want to drive Claude Code programmatically
- Web services or APIs that spin up Claude agents as workers

## Notes

- Collects usage data — review Anthropic's data usage policy before production deployment
- Community support: Claude Developers Discord

## Related

- [[Claude Agent SDK Python]] — same capability, Python
- [[Anthropic SDK Go]] — lower-level API SDK (not agent orchestration)
- [[Launch Your Agent Skill]] — guided skill for going from idea → live managed agent


/workspace/extra/second-brain/wiki/tools/Launch Your Agent Skill.md

# Launch Your Agent Skill

**Type:** Claude Code Skill
**By:** Anthropic
**Status:** Available (reference impl, not actively maintained)
**Source:** `anthropics/launch-your-agent` (updated 2026-07-11)
**License:** Apache 2.0

## What it is

A Claude Code skill that walks a technical founder from a blank-slate idea to a **live Claude Managed Agent** in one guided session. Covers the full lifecycle: interview, scope, launch, evaluate, iterate, and optionally schedule.

> "A live managed agent in your Console (agent + environment + graded run, plus a scheduled deployment if your task recurs)"

## Skills included

- **`/launch-your-agent`** — Four-phase main workflow:
  1. **Interview** — elicits the agent's purpose, inputs, and success criteria
  2. **Staging & launch** — scopes a v0, generates config, and launches in your Console account
  3. **Grading & iteration** — runs the agent, evaluates against success criteria, iterates
  4. **Scheduling** — optionally deploys as a recurring managed agent

- **`/wrap-up`** — Status check and next-steps planning for a completed agent build

## Deliverables

The skill produces a `my-agent/` folder with:
- Build artifacts and API payloads
- Resumable launch script
- Evaluation templates
- v1/v2 roadmap

Includes reference docs: CMA primitives inventory, interview-to-config mapping, production examples.

## Design notes

Prioritizes clarity and education over token efficiency — explains what it's doing at each step. Good for learning the managed-agent model; not optimized for low-cost repeated runs.

## Applicability to James's stack

Directly applicable to any project where James wants to go from idea → deployed scheduled agent. The four-phase interview → scope → launch → grade loop mirrors the autopilot pattern used in nanoclaw. The "grade it → iterate" stage is a concrete implementation of the [[Builder-Verifier Loop Pattern]].

## Related

- [[Claude Agent SDK Python]] / [[Claude Agent SDK TypeScript]] — programmatic alternative if you need code-level control
- [[Managed Agents]] — the underlying platform
- [[Builder-Verifier Loop Pattern]] — conceptual pattern the grading phase implements


File created successfully at: /workspace/extra/second-brain/wiki/tools/Launch Your Agent Skill.md (file state is current in your context — no need to Read it back)

# Launch Your Agent Skill

**Type:** Claude Code Skill
**By:** Anthropic
**Status:** Available (reference impl, not actively maintained)
**Source:** `anthropics/launch-your-agent` (updated 2026-07-11)
**License:** Apache 2.0

## What it is

A Claude Code skill that walks a technical founder from a blank-slate idea to a **live Claude Managed Agent** in one guided session. Covers the full lifecycle: interview, scope, launch, evaluate, iterate, and optionally schedule.

> "A live managed agent in your Console (agent + environment + graded run, plus a scheduled deployment if your task recurs)"

## Skills included

- **`/launch-your-agent`** — Four-phase main workflow:
  1. **Interview** — elicits the agent's purpose, inputs, and success criteria
  2. **Staging & launch** — scopes a v0, generates config, and launches in your Console account
  3. **Grading & iteration** — runs the agent, evaluates against success criteria, iterates
  4. **Scheduling** — optionally deploys as a recurring managed agent

- **`/wrap-up`** — Status check and next-steps planning for a completed agent build

## Deliverables

The skill produces a `my-agent/` folder with:
- Build artifacts and API payloads
- Resumable launch script
- Evaluation templates
- v1/v2 roadmap

Includes reference docs: CMA primitives inventory, interview-to-config mapping, production examples.

## Design notes

Prioritizes clarity and education over token efficiency — explains what it's doing at each step. Good for learning the managed-agent model; not optimized for low-cost repeated runs.

## Applicability to James's stack

Directly applicable to any project where James wants to go from idea → deployed scheduled agent. The four-phase interview → scope → launch → grade loop mirrors the autopilot pattern used in nanoclaw. The "grade it → iterate" stage is a concrete implementation of the [[Builder-Verifier Loop Pattern]].

## Related

- [[Claude Agent SDK Python]] / [[Claude Agent SDK TypeScript]] — programmatic alternative if you need code-level control
- [[Managed Agents]] — the underlying platform
- [[Builder-Verifier Loop Pattern]] — conceptual pattern the grading phase implements


# Knowledge Work Plugins

**Type:** Open-source Claude Cowork plugin collection
**By:** Anthropic
**Status:** Active
**Source:** `anthropics/knowledge-work-plugins` (updated 2026-07-11)
**Install:** claude.com/plugins (no coding required — markdown + JSON files)

## What it is

11 open-source plugins for Claude Cowork, each giving Claude role-specific expertise for a business domain. Plugins bundle skills, external tool connectors, slash commands, and sub-agents tailored to specific workflows.

## Plugins included

| Domain | Example capability |
|---|---|
| Productivity | Task and focus workflows |
| Sales | Prospect research, call prep (`/sales:call-prep`) |
| Customer support | Ticket triage and response |
| Product management | PRD drafting, roadmap review |
| Marketing | Campaign planning, copy |
| Legal | Contract review |
| Finance | Journal entries, financial statements |
| Data | Analysis and reporting |
| Enterprise search | Cross-system knowledge retrieval |
| Bio-research | Literature and protocol workflows |
| Plugin management | Managing other plugins |

## How they work

- Activate automatically within Claude Cowork sessions
- Trigger explicit actions via slash commands or let Claude draw on domain knowledge automatically
- Real value: **customize** with your own tools, terminology, and processes
- File-based (markdown + JSON) — no coding needed to adapt them

## Notes

All plugins are open-source — fork and customize for company-specific workflows. This is the pattern for turning Claude from a generic assistant into a domain expert aligned to your process.

## Applicability to James's stack

- **qip-qien** — The customer-support and product-management plugins could serve as structural references for the expert-draft pipeline's slash commands and sub-agent patterns.
- Customization-via-markdown pattern applies to any Cowork-based automation James builds.

## Related

- [[Cowork Dispatcher-Specialist Pattern]] — the architectural pattern these plugins implement
- [[Claude Blog - Marketing Ops Cowork Automation]] — how Anthropic's own team uses Cowork plugins


Hmm, the Write tool is failing for files that don't exist? That's odd — it says "File has not been read yet. Read it first before writing to it." But these are new files, they don't exist. For the `Launch Your Agent Skill.md` it worked because it's a new file, but the others failed. Let me check - maybe the issue is that these files DO exist? No, the Glob showed no files with those names...

Wait, I think I see the issue. The Write tool requires you to have read the file first ONLY if it already exists. For new files, it should work.

I'm noticing a pattern with the failures — the files with spaces in their names had mixed results. `Launch Your Agent Skill.md` succeeded even though it has spaces, but `Claude Agent SDK Python.md`, `Claude Agent SDK TypeScript.md`, and `Knowledge Work Plugins.md` all failed. Let me check if those files might already exist in the directory.


Bash

ls /workspace/extra/second-brain/wiki/tools/ | grep -E "Claude Agent|Knowledge Work|Launch"

Check which tool pages exist


Claude Agent SDK Demos.md
Claude Agent SDK Python.md
Claude Agent SDK TypeScript.md
Knowledge Work Plugins.md
Launch Your Agent Skill.md
Launch Your Agent.md


Ah, those files already existed! That's why the Write tool failed — it requires a read before writing to existing files. Let me read the existing ones and then update them.

Actually wait, the Write tool says: "If this is an existing file, you MUST use the Read tool first to read the file's contents." So these files already exist. Let me read them and then update them with my content.

But first — do I even need to update them? Let me check what's already in them. If they're already well-documented, I might just need to note the update date.
I'll pull up those existing pages to see what's currently there.


Read

/workspace/extra/second-brain/wiki/tools/Claude Agent SDK Python.md


1	# Claude Agent SDK (Python)
2
3	**Type:** Official Anthropic SDK
4	**Repo:** https://github.com/anthropics/claude-agent-sdk-python
5	**Install:** `pip install claude-agent-sdk`
6	**Docs:** https://platform.claude.com/docs/en/agent-sdk/python
7	**Prerequisites:** Python 3.10+
8	**Note:** Claude Code CLI is bundled in the wheel — no separate install required.
9
10	## Two usage modes
11
12	### 1. `query()` — Simple async queries
13
14	```python
15	from claude_agent_sdk import query
16
17	async for message in query(prompt="What is 2 + 2?"):
18	    print(message)
19	```
20
21	Returns an `AsyncIterator` of response messages. Good for fire-and-forget tasks.
22
23	### 2. `ClaudeSDKClient` — Bidirectional, interactive
24
25	Adds two capabilities `query()` doesn't have: **custom tools** and **hooks**.
26
27	```python
28	async with ClaudeSDKClient(options=options) as client:
29	    await client.query("Do something")
30	    async for msg in client.receive_response():
31	        print(msg)
32	```
33
34	## Key features
35
36	### In-process MCP servers (big deal)
37
38	Custom tools run as in-process MCP servers — same process, no subprocess, no IPC overhead:
39
40	```python
41	from claude_agent_sdk import tool, create_sdk_mcp_server
42
43	@tool("greet", "Greet a user", {"name": str})
44	async def greet_user(args):
45	    return {"content": [{"type": "text", "text": f"Hello, {args['name']}!"}]}
46
47	server = create_sdk_mcp_server(name="my-tools", version="1.0.0", tools=[greet_user])
48	options = ClaudeAgentOptions(mcp_servers={"tools": server}, allowed_tools=["mcp__tools__greet"])
49	```
50
51	Benefits vs. external MCP servers: no subprocess management, better performance, simpler deployment, easier debugging.
52
53	### Hooks — Python functions that intercept the agent loop
54
55	```python
56	async def check_bash_command(input_data, tool_use_id, context):
57	    if "foo.sh" in input_data["tool_input"].get("command", ""):
58	        return {"hookSpecificOutput": {"hookEventName": "PreToolUse", "permissionDecision": "deny", ...}}
59	    return {}
60
61	options = ClaudeAgentOptions(
62	    hooks={"PreToolUse": [HookMatcher(matcher="Bash", hooks=[check_bash_command])]}
63	)
64	```
65
66	### Tool permissions
67
68	- `allowed_tools` — auto-approve listed tools (doesn't remove others; they fall through to `permission_mode`)
69	- `disallowed_tools` — block specific tools entirely
70	- `permission_mode` — controls fallback behavior (`acceptEdits`, etc.)
71
72	## Options
73
74	```python
75	ClaudeAgentOptions(
76	    system_prompt="...",
77	    max_turns=1,
78	    cwd="/path/to/project",
79	    allowed_tools=["Read", "Write", "Bash"],
80	    disallowed_tools=["..."],
81	    permission_mode='acceptEdits',
82	    mcp_servers={...},
83	    hooks={...},
84	    cli_path="/custom/claude"  # if not using bundled CLI
85	)
86	```
87
88	## Error types
89
90	| Exception | Cause |
91	|---|---|
92	| `CLINotFoundError` | Claude Code not installed |
93	| `CLIConnectionError` | Connection issues |
94	| `ProcessError` | Process failed (has `.exit_code`) |
95	| `CLIJSONDecodeError` | JSON parsing issues |
96
97	## Session persistence (`SessionStore`)
98
99	Persist and resume agent sessions across backends. Adapters for S3, Redis, and Postgres. Pass a `SessionStore` instance in options to activate.
100
101	## Effort levels (`EffortLevel`)
102
103	Control thinking budget via `EffortLevel`: `"low"`, `"medium"`, `"high"`, `"max"`, `"xhigh"`. Useful for trading latency vs. depth on complex tasks.
104
105	## Deferred tool use decisions
106
107	Hooks can defer the approval/deny decision for tool use, enabling async human-in-the-loop flows. Feature-parity with TypeScript SDK (added v0.1.74).
108
109	## Current version
110
111	**0.2.87** — bundled Claude CLI v2.1.150.
112
113	## Migration from Claude Code SDK
114
115	- `ClaudeCodeOptions` → `ClaudeAgentOptions`
116	- Merged system prompt config
117	- New: programmatic subagents, session forking
118
119	## Related
120
121	- [[Claude Agent SDK TypeScript]] — `npm install @anthropic-ai/claude-agent-sdk` (Node.js equivalent)
122	- [[Claude Agent SDK Demos]] — 8 demo apps showing patterns; Python versions may be included
123	- [[Claude Cookbooks]] — Code recipes using the Claude API
124

/workspace/extra/second-brain/wiki/tools/Claude Agent SDK Python.md

# Claude Agent SDK (Python)

**Type:** Official Anthropic SDK
**Repo:** https://github.com/anthropics/claude-agent-sdk-python
**Install:** `pip install claude-agent-sdk`
**Docs:** https://platform.claude.com/docs/en/agent-sdk/python
**Prerequisites:** Python 3.10+
**Note:** Claude Code CLI is bundled in the wheel — no separate install required.

## Two usage modes

### 1. `query()` — Simple async queries

```python
from claude_agent_sdk import query

async for message in query(prompt="What is 2 + 2?"):
    print(message)
```

Returns an `AsyncIterator` of response messages. Good for fire-and-forget tasks.

### 2. `ClaudeSDKClient` — Bidirectional, interactive

Adds two capabilities `query()` doesn't have: **custom tools** and **hooks**.

```python
async with ClaudeSDKClient(options=options) as client:
    await client.query("Do something")
    async for msg in client.receive_response():
        print(msg)
```

## Key features

### In-process MCP servers (big deal)

Custom tools run as in-process MCP servers — same process, no subprocess, no IPC overhead:

```python
from claude_agent_sdk import tool, create_sdk_mcp_server

@tool("greet", "Greet a user", {"name": str})
async def greet_user(args):
    return {"content": [{"type": "text", "text": f"Hello, {args['name']}!"}]}

server = create_sdk_mcp_server(name="my-tools", version="1.0.0", tools=[greet_user])
options = ClaudeAgentOptions(mcp_servers={"tools": server}, allowed_tools=["mcp__tools__greet"])
```

Benefits vs. external MCP servers: no subprocess management, better performance, simpler deployment, easier debugging.

### Hooks — Python functions that intercept the agent loop

```python
async def check_bash_command(input_data, tool_use_id, context):
    if "foo.sh" in input_data["tool_input"].get("command", ""):
        return {"hookSpecificOutput": {"hookEventName": "PreToolUse", "permissionDecision": "deny", ...}}
    return {}

options = ClaudeAgentOptions(
    hooks={"PreToolUse": [HookMatcher(matcher="Bash", hooks=[check_bash_command])]}
)
```

### Tool permissions

- `allowed_tools` — auto-approve listed tools (doesn't remove others; they fall through to `permission_mode`)
- `disallowed_tools` — block specific tools entirely
- `permission_mode` — controls fallback behavior (`acceptEdits`, etc.)

## Options

```python
ClaudeAgentOptions(
    system_prompt="...",
    max_turns=1,
    cwd="/path/to/project",
    allowed_tools=["Read", "Write", "Bash"],
    disallowed_tools=["..."],
    permission_mode='acceptEdits',
    mcp_servers={...},
    hooks={...},
    cli_path="/custom/claude"  # if not using bundled CLI
)
```

## Error types

| Exception | Cause |
|---|---|
| `CLINotFoundError` | Claude Code not installed |
| `CLIConnectionError` | Connection issues |
| `ProcessError` | Process failed (has `.exit_code`) |
| `CLIJSONDecodeError` | JSON parsing issues |

## Session persistence (`SessionStore`)

Persist and resume agent sessions across backends. Adapters for S3, Redis, and Postgres. Pass a `SessionStore` instance in options to activate.

## Effort levels (`EffortLevel`)

Control thinking budget via `EffortLevel`: `"low"`, `"medium"`, `"high"`, `"max"`, `"xhigh"`. Useful for trading latency vs. depth on complex tasks.

## Deferred tool use decisions

Hooks can defer the approval/deny decision for tool use, enabling async human-in-the-loop flows. Feature-parity with TypeScript SDK (added v0.1.74).

## Current version

**0.2.87** — bundled Claude CLI v2.1.150.

## Migration from Claude Code SDK

- `ClaudeCodeOptions` → `ClaudeAgentOptions`
- Merged system prompt config
- New: programmatic subagents, session forking

## Related

- [[Claude Agent SDK TypeScript]] — `npm install @anthropic-ai/claude-agent-sdk` (Node.js equivalent)
- [[Claude Agent SDK Demos]] — 8 demo apps showing patterns; Python versions may be included
- [[Claude Cookbooks]] — Code recipes using the Claude API


/workspace/extra/second-brain/wiki/tools/Claude Agent SDK TypeScript.md


1	# Claude Agent SDK — TypeScript
2
3	**Type:** SDK / developer tool
4	**By:** Anthropic
5	**Repo:** https://github.com/anthropics/claude-agent-sdk-typescript
6	**Install:** `npm install @anthropic-ai/claude-agent-sdk`
7	**Requires:** Node.js 18+
8	**Support:** GitHub issues + Claude Developers Discord
9
10	## What it is
11	TypeScript SDK for building agents that can read codebases, modify files, run commands, and handle complex automated tasks. Renamed from the previous "Claude Code SDK" with significant changes.
12
13	## Key capabilities
14	- Understands and navigates code repositories
15	- Modifies files and executes shell commands
16	- Designed for sophisticated multi-step automation
17
18	## Data practices
19	Collects usage insights with limited retention; data is not used to train future models.
20
21	## Related
22	- [[Claude Agent SDK Demos]] — example apps using this SDK
23	- [[Claude Code]]
24	- [[Claude Quickstarts]]
25

/workspace/extra/second-brain/wiki/tools/Claude Agent SDK TypeScript.md

# Claude Agent SDK — TypeScript

**Type:** SDK / developer tool
**By:** Anthropic
**Repo:** https://github.com/anthropics/claude-agent-sdk-typescript
**Install:** `npm install @anthropic-ai/claude-agent-sdk`
**Requires:** Node.js 18+
**Support:** GitHub issues + Claude Developers Discord

## What it is
TypeScript SDK for building agents that can read codebases, modify files, run commands, and handle complex automated tasks. Renamed from the previous "Claude Code SDK" with significant changes.

## Key capabilities
- Understands and navigates code repositories
- Modifies files and executes shell commands
- Designed for sophisticated multi-step automation

## Data practices
Collects usage insights with limited retention; data is not used to train future models.

## Related
- [[Claude Agent SDK Demos]] — example apps using this SDK
- [[Claude Code]]
- [[Claude Quickstarts]]


1	# Knowledge Work Plugins
2
3	**Type:** Open-source plugin collection
4	**By:** Anthropic
5	**GitHub:** https://github.com/anthropics/knowledge-work-plugins
6	**Platform:** Claude Cowork + Claude Code
7
8	## What it is
9	18 open-source plugins built on the Claude Agent SDK targeting specific professional roles. File-based (markdown + JSON, no code infrastructure), modular, and integrates with 30+ external tools via MCP servers.
10
11	## Plugin catalog
12	| Plugin | Use case |
13	|--------|----------|
14	| Productivity | Task & calendar management |
15	| Sales | Prospect research, pipeline management |
16	| Customer Support | Ticket triage, escalation |
17	| Product Management | Spec writing, roadmap planning |
18	| Marketing | Content drafting, campaign planning |
19	| Legal | Contract review, compliance |
20	| Finance | Journal entries, financial statements |
21	| Data | Query writing, dashboard building |
22	| Enterprise Search | Cross-tool document discovery |
23	| Bio-Research | Life sciences tool integrations |
24	| Design | Design workflow assistance |
25	| Engineering | Software engineering workflows |
26	| Human Resources | HR tasks and people management |
27	| Operations | Ops and process management |
28	| Small Business | SMB-focused workflows |
29	| PDF Viewer | PDF document viewing/extraction |
30	| Partner Built | Partner-contributed plugins |
31	| Cowork Plugin Management | Plugin installation and management |
32
33	## Key features
34	- Integrates with Slack, Notion, Snowflake, Figma, and 25+ more via MCP
35	- Designed as customizable starting points — adapt to your org's tools and terminology
36	- Related to: [[Claude for Legal]] (a deeper legal-specific version)
37
38	## Related
39	- [[Claude Plugins Official]] — the directory these may be distributed through
40	- [[Claude for Legal]] — deeper legal plugin suite
41	- [[Claude Agent SDK Demos]] — SDK demos that power these plugins
42

# Knowledge Work Plugins

**Type:** Open-source plugin collection
**By:** Anthropic
**GitHub:** https://github.com/anthropics/knowledge-work-plugins
**Platform:** Claude Cowork + Claude Code

## What it is
18 open-source plugins built on the Claude Agent SDK targeting specific professional roles. File-based (markdown + JSON, no code infrastructure), modular, and integrates with 30+ external tools via MCP servers.

## Plugin catalog
| Plugin | Use case |
|--------|----------|
| Productivity | Task & calendar management |
| Sales | Prospect research, pipeline management |
| Customer Support | Ticket triage, escalation |
| Product Management | Spec writing, roadmap planning |
| Marketing | Content drafting, campaign planning |
| Legal | Contract review, compliance |
| Finance | Journal entries, financial statements |
| Data | Query writing, dashboard building |
| Enterprise Search | Cross-tool document discovery |
| Bio-Research | Life sciences tool integrations |
| Design | Design workflow assistance |
| Engineering | Software engineering workflows |
| Human Resources | HR tasks and people management |
| Operations | Ops and process management |
| Small Business | SMB-focused workflows |
| PDF Viewer | PDF document viewing/extraction |
| Partner Built | Partner-contributed plugins |
| Cowork Plugin Management | Plugin installation and management |

## Key features
- Integrates with Slack, Notion, Snowflake, Figma, and 25+ more via MCP
- Designed as customizable starting points — adapt to your org's tools and terminology
- Related to: [[Claude for Legal]] (a deeper legal-specific version)

## Related
- [[Claude Plugins Official]] — the directory these may be distributed through
- [[Claude for Legal]] — deeper legal plugin suite
- [[Claude Agent SDK Demos]] — SDK demos that power these plugins