Daily AI Digest

# Try Claude Sonnet 5 via API:
curl https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-sonnet-5-20260630",
    "max_tokens": 1024,
    "messages": [{"role": "user", "content": "Write a Python agent that uses tools"}]
  }'

# Check your token costs — Sonnet 5 tokenizer is ~30% more expensive per English word.
# Run Simon Willison's token comparison:
# pip install tokencost
# tokencost compare "claude-sonnet-4.6" "claude-sonnet-5" --prompt "Hello world"

# Connect your agent to X via MCP:
# 1. Get OAuth credentials from developer.x.com
# 2. Configure your MCP client (Claude Code example):
#    claude mcp add x-platform --transport http \
#      --url https://api.x.com/mcp \
#      --header "Authorization: Bearer $X_OAUTH_TOKEN"

# Or use xurl CLI directly:
# xurl mcp status
# xurl search "AI agents" --count 10

# ⚠️ Security: consider prompt injection risks before connecting agents to social platforms

# Try LongCat-2.0 via OpenRouter:
curl https://openrouter.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "meituan/longcat-2.0",
    "messages": [{"role": "user", "content": "Write a function to parse JSON and extract all nested keys recursively"}],
    "max_tokens": 2000
  }'

# Or clone and run locally (requires significant GPU):
# git clone https://github.com/meituan/LongCat
# cd LongCat && pip install -e .
# python -m longcat serve --model longcat-2.0 --port 8080

# If you work in government or regulated industry:
# 1. Review the CA-Anthropic deal structure as a template
# 2. Key clauses to study: data residency, model versioning, audit trails
# 3. Prepare your procurement team — this deal model is coming to your jurisdiction

# For developers: expect Claude Gov endpoints and compliance tooling
# Check anthropic.com/gov for Gov instance documentation

# Devin Fusion is a managed product, but the pattern is replicable:
# DIY hybrid agent with OpenCode + model routing:

# 1. Set up OpenCode with two models:
opencode config set model.openai.default gpt-5.5  # frontier agent
opencode config set model.openai.fast gpt-5.5-mini  # sidekick agent

# 2. Use OpenCode's /task delegation with model override:
#    /task "plan the refactor" --model gpt-5.5
#    /task "execute the refactor" --model gpt-5.5-mini

# 3. Review with frontier model:
#    /task "review the executed changes for correctness" --model gpt-5.5

# Try DeepSpec/DSpark:
git clone https://github.com/deepseek-ai/DeepSpec
cd DeepSpec
pip install -e .

# Run with speculative decoding enabled:
python -m deepspec.serve \
  --model deepseek-ai/DeepSeek-V4-Pro \
  --speculative \
  --num-speculative-tokens 5 \
  --port 8080

# Benchmark throughput:
python -m deepspec.bench \
  --endpoint http://localhost:8080/v1/chat/completions \
  --concurrency 10

# Install OpenClaw mobile:
# iOS: App Store → "OpenClaw"
# Android: Play Store → "OpenClaw" (brace for jank)

# Or self-host the gateway and pair your phone:
git clone https://github.com/openclaw/openclaw
cd openclaw
docker-compose up -d
# Then pair via QR code in the mobile app

# The lesson: agent-generated code still needs human QA.
# Test before you ship, even for "just a mobile wrapper."

# Read the full paper:
curl -s "https://export.arxiv.org/api/query?id_list=2606.31498" | python3 -c "
import sys, re
text = sys.stdin.read()
# Extract abstract
summary = re.search(r'
(.*?)
', text, re.DOTALL)
if summary:
    print(summary.group(1).strip()[:1500])
"

# Key governance dimensions the paper tests:
# 1. Voting (absent in ALL protocols)
# 2. Dissent preservation (absent in ALL)
# 3. Accountability/audit trail
# 4. Membership/identity
# 5. Delegation
# 6. Dispute resolution

# Install shot-scraper 1.10+:
pip install shot-scraper

# Create a storyboard (or have your agent generate it):
cat > demo-storyboard.yml << 'EOF'
steps:
  - url: http://localhost:3000
    wait: 1000
    caption: "Homepage before changes"
  - click: "#new-feature-btn"
    wait: 500
    caption: "Clicking the new feature button"
  - url: http://localhost:3000/result
    wait: 1000
    caption: "Result page after changes"
EOF

# Render the video:
shot-scraper video demo-storyboard.yml -o demo.mp4

# Integrate into CI: agent ships PR → pipeline generates video → attach to PR

# Set up agent audit trail with Tailscale Aperture:

# 1. Deploy Aperture in your Tailscale network:
#    tailscale up --advertise-tags=tag:aperture

# 2. Route agent API calls through Aperture:
export OPENAI_BASE_URL="https://aperture.your-tailnet.ts.net/v1"

# 3. Configure Cerbos for per-tool authorization:
#    Define policies: which users/agents can call which tools
#    Example policy: "deploy-to-prod" tool requires Security role

# 4. Query your audit log:
#    tailscale aperture logs --filter 'tool_call' --since 24h

# 5. Integrate with your SIEM:
#    tailscale aperture logs --format json | jq '.' > /var/log/agent-audit.json

# Protect your agents from phantom squatting:

# 1. URL reputation check before agent navigation:
def is_url_safe(url, allowed_domains, blocklist):
    from urllib.parse import urlparse
    domain = urlparse(url).netloc
    if domain in blocklist:
        return False, "Domain is on blocklist"
    if allowed_domains and domain not in allowed_domains:
        return False, f"Domain {domain} not in allowlist"
    return True, "OK"

# 2. Audit LLM outputs for invented URLs before passing to agents:
#    - Check all URLs against a registry
#    - Flag any domain not in a trusted list
#    - Require human approval for navigation to unverified domains

# 3. Tool defense: wrap your browsing tool with domain validation
#    def browse_url(url):
#        if not is_url_safe(url):
#            raise SecurityError(f"URL not in trusted domains: {url}")
#        return requests.get(url)

# Check your Claude Code version
claude --version
# If >= 2.1.91, inspect the binary:
strings $(which claude) | grep -i proxy
# Look for telemetry endpoints:
strings $(which claude) | grep -i 'api.anthropic\|telemetry\|report'
# Block with firewall rule:
sudo pfctl -t anthropic_block -T add 0.0.0.0/0
# Or use Little Snitch / LuLu to block Claude Code's outbound

# Not publicly available yet. Prepare your agent config for when it is:
# Hermes Agent model fallback for when GPT-5.6 is gated:
hermes config set models.default '{
  "primary": {"provider": "openai", "model": "gpt-5.6-sol"},
  "fallbacks": [
    {"provider": "anthropic", "model": "claude-sonnet-4"},
    {"provider": "deepseek", "model": "deepseek-v4-pro"}
  ]
}'
# Watch: developers.openai.com/blog for access announcements

# Check if your agent workloads are CPU-bound:
# Monitor CPU vs GPU during agent runs:
htop  # watch CPU utilization during tool calling loops
nvidia-smi -l 1  # watch GPU utilization — often idle during agent planning
# For Hermes Agent, profile tool execution overhead:
hermes run --profile "complex multi-step task" 2>&1 | grep "tool_exec_ms"

# Claude Code /goal:
claude
/goal "Build a REST API with tests for a user management system. 
Use Express + TypeScript. Write integration tests. 
Deploy to a Docker container. Report back when done."

# Codex CLI /goal:
codex goal "Refactor the auth module: extract JWT logic,
add refresh token rotation, update all tests.
Run the test suite and fix any failures autonomously."

# Track your agents while they work:
watch -n 30 'ps aux | grep -E "claude|codex"'

# Paper: https://arxiv.org/abs/2606.30616
# Check for weights release:
curl -sI https://huggingface.co/InternScience/Agents-A1
# If weights available, try with llama.cpp:
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp && make -j
# Download GGUF (when available) and run:
./llama-cli -m Agents-A1-Q4_K_M.gguf \
  -p "You are an expert coding agent. Solve: ..." \
  --ctx-size 65536

# Add entity resolution preconditions to your agent tools:
# Instead of: "email alex about the report"
# Require: "email [email protected] (user_id: 48291) about report_2026Q2.pdf (file_id: 7731)"

# In Hermes Agent skill definitions, add entity validation:
# skill: send_report
# parameters:
#   user_id: { type: string, required: true, validate: "lookup_by_email" }
#   file_id: { type: string, required: true, validate: "hash_verify" }

# Paper: https://arxiv.org/abs/2606.30531

# Pattern: build domain-specific skill packs for your agent
# Example: a "database migration" skill pack
# /skills/db-migration/SKILL.md:
# name: db-migration
# tools:
#   - migrate_up: runs alembic upgrade
#   - migrate_down: runs alembic downgrade
#   - check_schema: diffs current vs expected schema
#   - backup_before: pg_dump before any migration
# preconditions:
#   - transaction_guard: always wrap in BEGIN/ROLLBACK
#   - verify_no_downtime: check for long-running queries
# 
# The key: executable tools + guardrails, not prompts

# Enable in GitHub Copilot settings:
# Settings → Model preferences → Claude Opus 4.8 Fast
# Test quality on your codebase:
# 1. Run a standard task with Opus 4.7
# 2. Run the same task with Opus 4.8 Fast
# 3. Compare: diff accuracy, hallucination rate, iteration count
# Quick comparison script:
for model in "opus-4.7" "opus-4.8-fast"; do
  echo "=== Testing $model ==="
  claude --model $model -p "Write a function that..." 
done

# Codex with Chrome DevTools Protocol:
codex sandbox --cdp
# Inside the sandbox, the agent can:
# - Launch headless Chrome and inspect pages
# - Debug CSS/layout issues
# - Capture network traces
# - Test frontend interactions

# Security: restrict domains
codex sandbox --cdp --allowed-domains "localhost:3000,staging.example.com"

# Docs: developers.openai.com/codex/cloud/internet-access

# Install Headroom
pip install headroom
# Run as proxy:
headroom serve --port 8787
# Route Hermes Agent through it:
export HEADROOM_ENDPOINT="http://localhost:8787"
hermes run "your task here"
# For Claude Code, configure in settings:
# Settings → Advanced → Proxy → http://localhost:8787
# Measure savings:
headroom stats --last-100

# Full local agent stack setup (macOS):
# 1. Install Ollama
brew install ollama
ollama serve
# 2. Pull a capable local model
ollama pull qwen3:14b  # good balance of quality/speed
# 3. Install Continue.dev (VS Code extension)
#    marketplace.visualstudio.com → "Continue"
# 4. Configure Continue to use Ollama:
#    ~/.continue/config.json:
#    { "models": [{
#        "title": "Qwen 14B Local",
#        "provider": "ollama",
#        "model": "qwen3:14b"
#    }]}
# 5. Add MCP filesystem server:
#    Continue settings → MCP Servers → + Add
#    Command: npx -y @modelcontextprotocol/server-filesystem /path/to/project
# Expected perf: 15-30 tok/s on M3 Pro, 32GB+ RAM recommended

# Hermes MoA 2.0 quick start
# Install/update Hermes Agent:
brew install nousresearch/hermes/hermes-agent

# Create a MoA preset combining 3 models:
hermes config set moa.presets.council '
models:
  - provider: anthropic
    model: claude-opus-4-8
  - provider: openai
    model: gpt-5.5
  - provider: deepseek
    model: deepseek-v4-pro
aggregator:
  provider: anthropic
  model: claude-sonnet-4
  prompt: "You are an expert aggregator. Synthesize
    the best answer from the reference models below.
    Resolve contradictions. Cite sources."
strategy: parallel
'

# Run a task through the council:
hermes run --moa council \
  "Design a production agent architecture for
   processing 10K customer support tickets/day
   with human-in-the-loop escalation."

# GPT-5.6 is gated — here's your local alternative stack
# Pull Qwen3.6-35B (best open-weight coding model):
ollama pull qwen3.6:35b-a3b

# Install OpenCode (model-agnostic agent harness):
brew install anomalyco/tap/opencode

# Configure fallback chain:
opencode config set models.primary "claude-sonnet-4"
opencode config set models.fallback "gpt-5.1"
opencode config set models.local "ollama:qwen3.6:35b-a3b"
opencode config set models.local_threshold 0.7

# Now your agent auto-falls back if any model is
# unavailable, rate-limited, or government-gated.
opencode run "Build a REST API for user management"

# Compare against Terminal-Bench baselines:
# GPT-5.6 Sol Ultra:  91.9% (gated)
# Claude Opus 4.8:     ~82%  (available)
# Qwen3.6-35B-A3B:     ~68%  (local, no gate)

# Check your own repos for agent-generated commits
# Search for Claude Code signatures in commit messages:
git log --all --grep="Co-authored-by: Claude" --oneline | wc -l

# Or Codex signatures:
git log --all --grep="Generated by Codex" --oneline | wc -l

# Or generic AI signatures:
git log --all --grep="Co-authored-by.*AI\|Generated by.*agent" \
  --oneline | wc -l

# Calculate your team's agent commit ratio:
AGENT=$(git log --since="2026-06-01" \
  --grep="Co-authored-by: Claude\|Generated by Codex" \
  --oneline | wc -l)
TOTAL=$(git log --since="2026-06-01" --oneline | wc -l)
echo "Agent commits: $AGENT / $TOTAL = \
  $(echo "scale=1; $AGENT * 100 / $TOTAL" | bc)%"

# OpenMontage — agentic video production in one command
git clone https://github.com/calesthio/OpenMontage.git
cd OpenMontage
pip install -r requirements.txt

# Generate a product ad with Claude Code:
claude "Using OpenMontage tools in this directory,
  create a 30-second product ad for a fictional
  coffee subscription service called 'BrewDaily'.
  - Script a voiceover
  - Generate b-roll footage descriptions
  - Assemble with transitions
  - Add background music
  Output the final video as product-ad.mp4"

# Cost breakdown from community:
# Script generation:    $0.02
# B-roll (stock):       $0.15
# Voiceover (TTS):      $0.03
# Music (royalty-free): $0.00
# Assembly + editing:   $0.49
# Total:                $0.69

# codebase-memory-mcp — give your agent codebase awareness
git clone https://github.com/DeusData/codebase-memory-mcp.git
cd codebase-memory-mcp

# Build (requires C compiler):
make

# Index your entire codebase:
./codebase-memory index ~/my-project \
  --languages python,typescript,rust \
  --output ~/my-project.codebase.graph

# Now your agent sees the full dependency graph:
# "Which functions call UserService.create()?"
# "What modules depend on the deprecated auth.py?"
# "Show me the call chain from API endpoint to DB query"

# Works with any MCP-compatible agent:
# Add to your agent's MCP config:
# {
#   "mcpServers": {
#     "codebase-memory": {
#       "command": "./codebase-memory",
#       "args": ["serve", "~/my-project.codebase.graph"]
#     }
#   }
# }

# Agent-Reach — internet access for your coding agent
git clone https://github.com/Panniantong/Agent-Reach.git
cd Agent-Reach && pip install -e .

# Search across platforms (no API keys needed):
agent-reach search "LLM agent framework comparison June 2026"
# Returns results from Twitter, Reddit, YouTube, GitHub

# Use with Claude Code as a tool:
claude "Use agent-reach to find the top 5 most
  discussed AI agent frameworks this week on Reddit
  and Twitter. Summarize the community sentiment
  for each."

# ⚠️ Security note: Agent-Reach uses your browser
# cookies for authentication. Consider running in
# an isolated browser profile or a dedicated VM.
# For production: use official APIs instead.

# Measure ACTUAL Headroom savings on your workload
git clone https://github.com/headroomlabs-ai/headroom.git
cd headroom && pip install -e .

# Run a representative agent session WITHOUT Headroom:
claude "Audit the ~/my-project codebase
  for security issues" > /tmp/baseline.txt
BASELINE=$(wc -c < /tmp/baseline.txt)

# Run the same session WITH Headroom proxy:
claude --proxy http://localhost:9090 \
  "Audit the ~/my-project codebase
  for security issues" > /tmp/compressed.txt
COMPRESSED=$(wc -c < /tmp/compressed.txt)

# Your real savings:
SAVINGS=$(echo "scale=1; \
  ($BASELINE - $COMPRESSED) * 100 / $BASELINE" | bc)
echo "Real token savings: ${SAVINGS}%"
echo "(Community average: 5-18%, not 60-95%)"

# design.md — give your agent persistent design context
# Install the DESIGN.md spec:
git clone https://github.com/google-labs-code/design.md.git
cd design.md

# Create a DESIGN.md for your project:
cat > ~/my-project/DESIGN.md << 'EOF'
# Project Design System
colors:
  primary: "#06B6D4"
  background: "#0a0a0f"
  surface: "#13131a"
  text: "#e4e4ec"
typography:
  font: "system-ui, sans-serif"
  mono: "'JetBrains Mono', monospace"
  heading-size: "1.3em"
  body-size: "18px"
spacing:
  unit: 8px
  radius: "10px"
components:
  button: "rounded, accent bg on hover"
  card: "bordered surface, 16px padding"
EOF

# Now any agent that reads DESIGN.md produces
# consistent, on-brand output across sessions.
# Works with Claude Code, Codex, Cursor, OpenCode.

# Build an iOS app with Claude Code in 5 minutes
# Prerequisites: Xcode installed, Claude Code installed

# 1. Create the Xcode project:
mkdir ~/MyFirstApp && cd ~/MyFirstApp
xcodebuild -project MyFirstApp.xcodeproj 2>/dev/null || \
  claude "Create a new iOS SwiftUI app called
  'MyFirstApp' with Xcode project files. Include:
  - A main ContentView with a list of items
  - An AddItemView with a text field and save button
  - Basic MVVM architecture
  Output all necessary .swift and project files."

# 2. Build and run in simulator:
xcodebuild -project MyFirstApp.xcodeproj \
  -scheme MyFirstApp \
  -destination 'platform=iOS Simulator,name=iPhone 16' \
  build

# ⚠️ The hard part (not automatable yet):
# - Apple Developer account ($99/year)
# - Provisioning profiles & code signing
# - App Store Connect metadata
# - App Review submission
# Claude Code can write the app. App Store is still human.

# Safe sysadmin with Claude Code — sandbox first
# NEVER give Claude Code direct root on production.
# Use these patterns instead:

# Pattern 1: Read-only diagnosis
claude "SSH into server and run diagnostic commands
  ONLY. Do not modify anything:
  - Check disk usage: df -h
  - Check memory: free -m
  - Check Docker status: docker ps -a
  - Check nginx error log: tail -50 /var/log/nginx/error.log
  Report findings with recommended fixes."

# Pattern 2: Dry-run Terraform
claude "Generate Terraform config for:
  - AWS EC2 t3.medium instance
  - Security group with ports 80, 443, 22
  Run 'terraform plan' but DO NOT apply.
  Show me the plan output for review."

# Pattern 3: Write script, human runs it
claude "Write a bash script that:
  1. Backs up /etc/nginx to /tmp/nginx-backup/
  2. Modifies nginx.conf to add rate limiting
  3. Tests config with 'nginx -t'
  4. Reloads nginx if test passes
  Output the script. I will run it myself after review."

# AutoJack defense — sandbox your agent's browser
# Rule 1: Never run agent browsers on the same machine
# as production services or sensitive data.

# Rule 2: Use isolated Docker containers for browsing:
docker run -d --name agent-browser \
  --network isolated \
  --cap-drop ALL \
  --security-opt no-new-privileges \
  --read-only \
  browserless/chrome

# Rule 3: Block localhost access from agent context:
# iptables rule to prevent container from reaching host:
iptables -A INPUT -i docker0 -j DROP

# Rule 4: Audit your agent's browsing capability:
# If your agent has a web_search or browser tool,
# verify it runs in an isolated context — not on
# the same machine as your code, configs, or secrets.

# Production agent browsing checklist:
# ☐ Browser runs in isolated container/VM
# ☐ No localhost access from browsing context
# ☐ No filesystem mount from host
# ☐ Network egress limited to required domains
# ☐ Agent cannot install browser extensions

# Raschka's local coding agent stack in 5 commands
# 1. Install Ollama and pull Qwen3.6:
brew install ollama && ollama pull qwen3.6:35b-a3b

# 2. Install OpenCode (model-agnostic harness):
brew install anomalyco/tap/opencode

# 3. Configure local model:
opencode config set provider.ollama.endpoint \
  "http://localhost:11434"
opencode config set models.default \
  "ollama:qwen3.6:35b-a3b"

# 4. Set up workspace:
mkdir ~/local-agent-workspace && cd ~/local-agent-workspace
opencode init

# 5. Run a real task — 100% local, zero API costs:
opencode run "Create a FastAPI app with:
  - POST /users endpoint with Pydantic validation
  - SQLite storage via SQLAlchemy
  - Unit tests with pytest
  - Dockerfile for deployment"

# Expected: 15-30 tok/s on M4 Ultra / A100
# Not a Claude Code replacement yet — but getting closer.

# Benchmark Fugu's real-world latency yourself
# Compare single-model vs orchestration response times

# 1. Time a direct GPT-5.5 call for a shader
time curl -s https://api.openai.com/v1/chat/completions \
  -H "Authorization: Bearer *** \
  -d '{"model": "gpt-5.5","messages":[{"role":"user","content":"Write a GLSL shader that creates a water ripple effect with vertex displacement and fragment color blending."}],"max_tokens":2000}' \
  | python3 -c "import json,sys; d=json.load(sys.stdin); print(d['choices'][0]['message']['content'][:200])"

# 2. Time the same request through Fugu
time curl -s https://api.sakana.ai/v1/chat/completions \
  -H "Authorization: Bearer *** \
  -d '{"model": "fugu-ultra","messages":[{"role":"user","content":"Write a GLSL shader that creates a water ripple effect with vertex displacement and fragment color blending."}],"max_tokens":2000}'

# Compare total wall-clock time — you'll see the orchestration overhead

# Check if your organization's agent infrastructure has basic guardrails

# 1. Audit agent permissions across your stack
# Check Codex CLI allowed tools:
cat ~/.codex/config.toml | grep allowed_tools

# Check Claude Code project settings:
cat CLAUDE.md | grep -A5 "permissions"

# 2. Run a basic agent security scan with Agent Beacon:
pip install agent-beacon
beacon check --policy security-first --output report.json

# 3. Verify no agent has network execute permissions it shouldn't:
beacon audit --tool network_exec --since "2026-06-01"

# Doubao-Seed 2.1 Pro is available via Volcano Engine API
# OpenAI-compatible, so it works with any OpenAI SDK:

from openai import OpenAI

client = OpenAI(
    api_key="***",
    base_url="https://ark.cn-beijing.volces.com/api/v3"
)

response = client.chat.completions.create(
    model="doubao-seed-2.1-pro",
    messages=[
        {"role": "system", "content": "You are an expert Python developer. Write production-grade code with tests."},
        {"role": "user", "content": "Build a FastAPI endpoint that accepts a URL, fetches the page, extracts the main content, and returns a summary."}
    ],
    max_tokens=8192
)
print(response.choices[0].message.content)

# FINOS AI Fund resources are open to all members
# Start by using the FINOS AI Governance Framework:

git clone https://github.com/finos/ai-governance-framework.git
cd ai-governance-framework

# Run a risk assessment against your agent setup:
python assess.py --agent-policy policy.yaml \
  --output compliance-report.md

# The framework covers: 
# - Data governance (what data does the agent access?)
# - Tool governance (what tools can it invoke?)
# - Output governance (what can it generate?)
# - Audit trail requirements

cat compliance-report.md

# A practical context engineering pattern — chunked context injection

# Instead of dumping everything into one system prompt, structure context
# in layers that the agent can consume incrementally:

system_context = {
    "layer_1_identity": "You are a code reviewer for a Python monorepo.",
    "layer_2_project": {
        "name": "data-pipeline",
        "stack": ["Python 3.12", "Apache Beam", "BigQuery"],
        "style_guide": "Google Python Style Guide",
        "testing": "pytest with 85% coverage minimum"
    },
    "layer_3_ticket": {
        "id": "PL-4421",
        "description": "Add retry logic to BigQuery sink with exponential backoff",
        "files_changed": ["sinks/bigquery.py", "tests/test_sinks.py"]
    },
    "layer_4_guardrails": [
        "Never propose removing tests",
        "Always include type annotations",
        "Keep functions under 50 lines"
    ]
}

# Inject into your agent via its system prompt or CLAUDE.md
import json
with open("CLAUDE.md", "w") as f:
    f.write("# Project Context\n\n")
    f.write("## Identity\n" + system_context["layer_1_identity"] + "\n\n")
    f.write("## Stack\n```\n" + json.dumps(system_context["layer_2_project"], indent=2) + "\n```\n")
    f.write("## Guardrails\n")
    for g in system_context["layer_4_guardrails"]:
        f.write(f"- {g}\n")

# Install lift
pip install lift-pdf

# Define your schema as a JSON Schema
cat > invoice_schema.json << 'EOF'
{
  "type": "object",
  "properties": {
    "invoice_number": {"type": "string"},
    "date": {"type": "string", "format": "date"},
    "vendor": {"type": "string"},
    "total_amount": {"type": "number"},
    "line_items": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "description": {"type": "string"},
          "quantity": {"type": "integer"},
          "unit_price": {"type": "number"},
          "total": {"type": "number"}
        },
        "required": ["description", "quantity", "unit_price", "total"]
      }
    }
  },
  "required": ["invoice_number", "date", "vendor", "total_amount"]
}
EOF

# Extract data from a PDF
lift --schema invoice_schema.json --input invoice.pdf --output data.json

# The output is guaranteed schema-valid JSON:
cat data.json

# Make your project agent-friendly in 3 steps:

# 1. Add a CLAUDE.md / CODE_GUIDE.md with agent instructions
cat > CLAUDE.md << 'EOF'
# Agent Workspace Guide
- Run `make install` before any work
- Use `make test` for verification — 100% of tests must pass
- Keep functions under 60 lines
- Always add type annotations
- Error messages go to stderr, not stdout
- Configuration is in config/ directory, not environment variables
EOF

# 2. Add a Makefile with structured targets
cat > Makefile << 'EOF'
install:
	pip install -e ".[dev]"
test:
	pytest -v --tb=short
lint:
	truff check .
format:
	truff format .
clean:
	rm -rf build/ dist/ *.egg-info
.PHONY: install test lint format clean
EOF

# 3. Use Oak for session-aware version control
# cargo install oak-vcs
oak init
oak session start "refactor-pipeline"
# Work with Claude Code or Codex...
oak session save
oak diff --token-budget

# Your agent will thank you.

# Set up multi-provider agent fallback with OpenCode
# OpenCode supports 75+ providers — configure fallbacks:

cat > ~/.opencode/config.yaml << 'EOF'
provider:
  primary:
    name: claude
    model: claude-opus-4.8
    api_key_env: ANTHROPIC_API_KEY
  fallback:
    - name: openai
      model: gpt-5.5
      api_key_env: OPENAI_API_KEY
    - name: google
      model: gemini-3.1-pro
      api_key_env: GOOGLE_API_KEY
  fallback_strategy: sequential
  health_check_interval: 30s
EOF

# Test the fallback:
opencode --check-providers

# When Claude goes down, OpenCode automatically routes to GPT-5.5
# No CI/CD pipeline interruption

# Fugu exposes an OpenAI-compatible API — swap your endpoint
export OPENAI_BASE_URL="https://api.sakana.ai/v1"
export OPENAI_API_KEY="sk-fugu-..."

# Try it like any OpenAI model
curl https://api.sakana.ai/v1/chat/completions \
  -H "Authorization: Bearer *** \
  -H "Content-Type: application/json" \
  -d '{
    "model": "fugu-ultra",
    "messages": [{"role": "user", "content": "Write a Python script that monitors a directory for new .csv files and runs a data validation pipeline on each one."}]
  }'

# GPT-5.5-Cyber is available through the TAC program
# Eligible teams apply at https://openai.com/tac

# Once approved, use via the OpenAI API with the cyber model:
curl https://api.openai.com/v1/chat/completions \
  -H "Authorization: Bearer *** \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.5-cyber",
    "messages": [
      {"role": "system", "content": "You are a defensive security analyst. Audit this C code for memory safety vulnerabilities."},
      {"role": "user", "content": "Review this function for buffer overflows:\n\nvoid process_packet(char *data, int len) {\n  char buf[256];\n  memcpy(buf, data, len);\n}"}
    ]
  }'

# In JetBrains IDE with Copilot:
# 1. Settings → Tools → GitHub Copilot → Agent Provider
# 2. Select "Claude" from the dropdown
# 3. Authenticate with your Anthropic account

# Or via Copilot CLI with message queuing:
gh copilot chat --agent claude --queue
# Use /steer to redirect the agent mid-session
/steer "Actually, refactor this as a class instead of functions"

# Check debug logs:
gh copilot logs --agent --last-session

# BioNeMo Agent Toolkit is available via NVIDIA GPU Cloud (NGC)
# Pull the container:
docker pull nvcr.io/nvidia/bionemo-agent-toolkit:24.06

# Launch a literature review agent:
docker run --gpus all -it \
  -e NVIDIA_API_KEY=$NVIDIA_API_KEY \
  nvcr.io/nvidia/bionemo-agent-toolkit:24.06 \
  bionemo-agent literature-review \
  --query "CRISPR-based gene editing for sickle cell" \
  --max-papers 50

# Or run an molecular design agent:
bionemo-agent molecular-design \
  --target-protein "7KXG" \
  --property-rules "molecular_weight<500, logP<5"

# Install Agent Beacon
curl -fsSL https://github.com/Asymptote-Labs/agent-beacon/releases/latest/download/beacon-install.sh | bash

# Or via pip:
pip install agent-beacon

# Start the daemon:
beacon start

# See what agents are doing in real-time:
beacon tail --format json

# Export to your SIEM via OpenTelemetry:
beacon export otlp --endpoint https://otel.mycompany.com:4318

# Check agent activity summary:
beacon summary --last 24h

# A minimal loop: watch a dir, feed new files to Claude Code, commit results

#!/bin/bash
# loop-engineer.sh — A simple loop that processes tickets from a directory
WATCH_DIR="./incoming-tickets"
AGENT="claude"

inotifywait -m "$WATCH_DIR" -e create --format '%f' | while read FILE
do
  echo "[LOOP] New ticket detected: $FILE"
  
  # Feed the ticket to the agent as a goal
  $AGENT --goal "Implement the feature described in $WATCH_DIR/$FILE" \
         --output-dir ./implementations \
         --max-iterations 5
  
  # Move processed ticket to archive
  mv "$WATCH_DIR/$FILE" "./archive/$FILE.done"
  echo "[LOOP] Completed: $FILE"
done

# Clone and run Open EAGO governance middleware
git clone https://github.com/finos-labs/open-eago.git
cd open-eago

# Create a governance policy for your agent
cat > policy.yaml << 'EOF'
agent:
  name: code-reviewer
  allowed_tools:
    - git
    - filesystem_read
    - llm_chat
  blocked_tools:
    - network_exec
    - file_write_global
  audit_level: all
  max_tokens_per_session: 1000000
  compliance_tags:
    - pci-dss
    - sox
EOF

# Run the governance proxy
docker compose up
# Agents connect to http://localhost:8080 instead of their usual API

# Check which Anthropic models are currently available
curl -s https://api.anthropic.com/v1/models \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" | jq '.data[].id'

# Compare availability from different regions
# (run from a non-US VPS to test export restrictions)
curl -s https://api.anthropic.com/v1/models \
  -H "x-api-key: $ANTHROPIC_API_KEY" 2>&1 | head -20

# Track the news via Reuters
curl -s "https://www.reuters.com/technology/artificial-intelligence/" | \
  grep -oP '(?<=title">)[^<]+' | head -5

# Compare Claude vs GPT vs Gemini pricing side-by-side
echo "=== Claude Max (disputed) ==="
echo "Max 5x: $100/mo — claims 5x Pro"
echo "Max 20x: $200/mo — claims 20x Pro (lawsuit says ~7x)"
echo ""
echo "=== GPT-5.5 Pricing ==="
echo "Plus: $20/mo — 80 messages/3h"
echo "Pro: $200/mo — unlimited"
echo ""
echo "=== Gemini CLI ==="
echo "Free: Gemini 2.5 Pro (with personal Google account)"
echo "AI Studio: pay-per-use, no subscription lock"

# Test actual model throughput yourself
pip install anthropic openai google-genai 2>/dev/null

# Quick throughput test for Claude
python3 -c "
import time, anthropic
c = anthropic.Anthropic()
start = time.time()
for i in range(3):
    c.messages.create(model='claude-sonnet-4-20250514', max_tokens=50,
        messages=[{'role':'user','content':'say hi'}])
elapsed = time.time() - start
print(f'3 Claude calls: {elapsed:.1f}s — {3/elapsed:.1f} calls/min')
" 2>/dev/null || echo "Set ANTHROPIC_API_KEY first"

# Apple's Core AI approach — run models locally with MLX
# This is the same philosophy: on-device, private, no API key
pip install mlx-lm 2>/dev/null

# Run a local model on macOS — no cloud, no tracking
python3 -c "
from mlx_lm import load, generate
model, tokenizer = load('mlx-community/Llama-3.2-3B-Instruct-4bit')
prompt = 'Summarize: iOS 27 brings on-device AI features.'
response = generate(model, tokenizer, prompt=prompt, max_tokens=100)
print(response)
" 2>/dev/null | head -5

# Check which Apple Intelligence features are available on your device
system_profiler SPSoftwareDataType | grep -i "apple intelligence"

# Test MCP interoperability — connect the same server to different agents
# First, install the MCP filesystem server
npx @anthropic/mcp-filesystem-server /tmp/test-mcp &

# Try it with Claude Code (if installed):
# claude mcp add filesystem -t stdio -- npx @anthropic/mcp-filesystem-server /tmp

# Try it with OpenCode (if installed):
# opencode mcp add filesystem -- npx @anthropic/mcp-filesystem-server /tmp

# List MCP servers available on your system:
ls ~/.claude/mcp.json 2>/dev/null && cat ~/.claude/mcp.json | jq '.mcpServers | keys'
ls ~/.config/opencode/mcp.json 2>/dev/null && cat ~/.config/opencode/mcp.json | jq '.mcpServers | keys'

# The same tools work across agents — that's the MCP win

# Deploy an agent-managed API endpoint — 60-min ephemeral
# No account, no credit card, no setup
npx wrangler deploy --temporary --name agent-demo-$(date +%s)

# The agent-inspired pattern: deploy a function that agents can call
cat <<'EOF' > agent-worker.js
export default {
  async fetch(request) {
    const url = new URL(request.url);
    if (url.pathname === "/agent-status") {
      return Response.json({
        status: "ephemeral",
        uptime_remaining: "60 minutes",
        agent: "cloudflare-temp",
      });
    }
    return new Response("Agent endpoint active");
  }
}
EOF

npx wrangler deploy --temporary --name agent-api --route /agent-status agent-worker.js

# Install claude-mem (works with Claude Code)
npx claude-mem init

# Or install for OpenCode:
npx claude-mem init --agent opencode

# Test that memory persists across sessions:
echo "Remember: my favorite color is #06B6D4" | claude --print
# Start a new session:
echo "What's my favorite color?" | claude --print
# Should respond: #06B6D4 (cyan)

# Check claude-mem status:
npx claude-mem status

# Manual memory search:
npx claude-mem search "favorite color"

# Decision tree: Agent or Workflow?
# Run this in your terminal to decide:

decide() {
  echo "Do you need:"
  echo "1) Fixed, known steps every time → WORKFLOW (use Dify, Prefect, n8n)"
  echo "2) Dynamic tool selection per input → AGENT (use Claude Code, Codex)"
  echo ""
  echo "Cost check:"
  echo "Workflow: predictable cost per run"
  echo "Agent: 2-10x variable cost depending on tool calls"
  echo ""
  echo "Latency check:"
  echo "Workflow: 500ms-5s per step"
  echo "Agent: 5-60s per decision loop"
}

decide

# Example: simple workflow NOT an agent
cat <<'PYEOF' > workflow_vs_agent.py
# This should be a workflow (fixed steps), not an agent (tool-calling LLM)
import hashlib, json

def document_pipeline(text):
    # Step 1: normalize — FIXED
    text = text.strip().lower()
    # Step 2: hash — FIXED
    doc_id = hashlib.sha256(text.encode()).hexdigest()[:16]
    # Step 3: metadata — FIXED
    result = {"id": doc_id, "length": len(text), "content": text[:100]}
    return result

# This is $0.001 to run. An agent doing the same would cost $0.05+
print(json.dumps(document_pipeline("Hello World"), indent=2))
PYEOF
python3 workflow_vs_agent.py

# Track AI talent moves yourself — watch the GitHub orgs
# See who's joining Anthropic's research team
curl -s "https://api.github.com/orgs/anthropics/repos?per_page=5&sort=updated" | \
  jq '.[] | "\(.full_name) — ⭐\(.stargazers_count) — \(.updated_at)"'

# Compare with DeepMind
curl -s "https://api.github.com/orgs/google-deepmind/repos?per_page=5&sort=updated" | \
  jq '.[] | "\(.full_name) — ⭐\(.stargazers_count) — \(.updated_at)"'

# Compare sparse vs dense attention costs — quick mental model
# Traditional attention: O(n²) where n = tokens
# SubQ attention: O(n) linear scaling

# For a 100K token context:
# Dense: 100,000² = 10,000,000,000 operations
# Sparse: 100,000 × constant ≈ 1,000,000 operations
echo "Dense: $((100000 * 100000)) ops — 10 billion"
echo "Sparse: $((100000 * 10)) ops — 1 million"
echo "Speedup: $((100000 * 100000 / (100000 * 10)))x"

# Test SubQ yourself once API is live (placeholder pattern)
# curl https://api.subq.ai/v1/chat \
#   -d '{"model":"subq-1.1-small","messages":[{"role":"user","content":"Explain sparse attention in one sentence"}]}'

# Watch VivaTech 2026 keynotes and interviews
curl -s "https://www.youtube.com/feeds/videos.xml?channel_id=UCVivaTech" | \
  grep -oP '<title>[^<]+' | head -10

# Track EU AI Act countdown (effective Aug 1, 2026)
DAYS_LEFT=$(( ($(date -d "2026-08-01" +%s) - $(date +%s)) / 86400 ))
echo "Days until EU AI Act enforcement: $DAYS_LEFT"

# Test how your AI agent presents itself
# Does it use "I" language that implies personhood?
# Quick check with any agent CLI:
echo "Are you a person or a tool?" | opencode --model gpt-4o --no-stream 2>/dev/null | head -5

# Or with Claude Code:
# echo "Introduce yourself in one sentence" | claude --print

# Privacy check: what data does your agent send?
curl -s https://api.github.com/repos/nousresearch/hermes-agent | jq '.topics'

# Deploy a Worker with a temporary account — no signup needed
npx wrangler deploy --temporary

# Or with an agent:
cat <<'EOF' | wrangler deploy --temporary --name hello-agent
export default {
  async fetch(request) {
    return new Response("Hello from an AI agent's temp account!")
  }
}
EOF

# Check remaining time on your temporary account
npx wrangler whoami --temporary

# Check if AI models know you — query multiple models
# Using Ollama + local model to test model recall:
cat <<'EOF' | ollama run llama3.2
Who is John Shearin? Respond with only "KNOWN" or "UNKNOWN" and a confidence 0-100.
EOF

# For a more systematic check, query several models:
for model in llama3.2 mistral phi4; do
  echo "=== $model ==="
  echo "Who is [YOUR_NAME]? Be brief." | ollama run "$model" 2>/dev/null | head -3
  echo
done

# No public API yet, but you can explore CAD automation with open-source tools
# Try CadQuery — programmatic CAD in Python:
pip install cadquery

cat <<'PYEOF' > simple_part.py
import cadquery as cq

# Generate a 3D bracket programmatically — same idea as VRING:ON
result = (cq.Workplane("XY")
  .box(20, 20, 5)
  .faces(">Z")
  .workplane()
  .circle(3)
  .cutThruAll()
)
cq.exporters.export(result, "bracket.step")
print("CAD file generated: bracket.step — ready for manufacturing")
PYEOF
python3 simple_part.py

# Update to v0.17.0
hermes update

# Try Blank Slate mode (start with ONLY provider, model, file ops, terminal — everything else off)
hermes --blank-slate

# Or set it permanently:
hermes config set blank_slate true

# Fire off a background subagent and keep working
hermes delegate "Research the best PostgreSQL migration tools" --background

# Send an iMessage (after Photon login)
hermes photon login
hermes imessage send "+141****1234" "Shipped Hermes v0.17.0 🚀"

# Set up an automation blueprint
hermes automation create "daily-news-briefing"
# Hermes guides you through the setup conversationally

# Get the Cursor Composer model via xAI Grok
hermes config set provider grok-composer-2.5-fast

# Use atomic memory operations
hermes memory update --batch '
  {"action": "replace", "key": "project_context", "value": "Hermes v0.17..."},
  {"action": "remove", "key": "old_note"}
'

# Try GLM-5.2 through OpenRouter (no API key needed to start)
curl -s https://openrouter.ai/api/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "z-ai/glm-5.2",
    "messages": [
      {"role": "user", "content": "Write a Python function that merges two sorted lists in O(n) time"}
    ]
  }' | python3 -m json.tool

# Or use it with OpenCode:
opencode --model z-ai/glm-5.2

# Or with Codex via custom model config:
codex config set model_provider openrouter
codex config set model z-ai/glm-5.2

# Benchmark locally vs GPT-5.5
# GLM-5.2: ~$1.40/M input, $4.40/M output
# GPT-5.5: ~$5.00/M input, $30.00/M output

# Switch to the alpha channel
codex update --channel alpha

# Check current version
codex --version

# Or install specific alpha version:
# macOS:
curl -fsSL https://codex-install.openai.com/alpha/macos/codex -o /usr/local/bin/codex

# Linux:
curl -fsSL https://codex-install.openai.com/alpha/linux/codex -o /usr/local/bin/codex

chmod +x /usr/local/bin/codex

# Run a session to test the new exec-server reliability:
codex "run the test suite and report coverage" --timeout 120

# Report any issues:
codex feedback --category alpha-bug

# In Claude Design, set brand controls via the new Brand Panel:
# 1. Open Claude Design
# 2. Click "Brand" in the toolbar
# 3. Upload your design tokens JSON:
cat > brand-tokens.json << 'EOF'
{
  "colors": {
    "primary": "#06B6D4",
    "secondary": "#10B981",
    "background": "#0a0a0f",
    "text": "#e4e4ec"
  },
  "typography": {
    "heading": "Inter, sans-serif",
    "body": "SF Pro, system-ui"
  },
  "spacing": {
    "unit": 8,
    "scale": [4, 8, 16, 24, 32, 48, 64]
  }
}
EOF

# 4. Claude Design now stays on-brand for all generations
# 5. Try bidirectional sync: edit the HTML output in code → it reflects in design view

# Install AURI (free) into your agent workflow:

# Via MCP — add to Claude Desktop config:
{
  "mcpServers": {
    "auri-security": {
      "command": "npx",
      "args": ["@endorlabs/auri-mcp"]
    }
  }
}

# Via CLI:
npx @endorlabs/auri scan ./src --format sarif

# Scan a file for AI-generated code vulnerabilities:
npx @endorlabs/auri check app.py

# Integrate into CI/CD:
# Add to your GitHub Actions workflow:
# - name: AURI Security Scan
#   run: npx @endorlabs/auri scan ${{ github.workspace }} --format sarif

# Run the Black Duck governance check:
# (requires enterprise license)
echo "97% of devs use AI tools; only 33% have governance"

# Pin your model version in harness config to avoid surprise breaks

# Claude Code — pin in CLAUDE.md:
# model: claude-opus-4.8
# Don't auto-upgrade to new models

# Codex CLI — pin in config.yaml:
model:
  provider: openai
  name: gpt-5.5
  version: "2026-05-01"  # pin a specific dated version

# Hermes Agent — pin in config.yaml:
provider:
  name: anthropic
  model: claude-opus-4.8
  # Don't let model router auto-upgrade
  auto_upgrade: false

# Test tool-calling explicitly after model updates:
curl -X POST https://api.anthropic.com/v1/messages \
  -H "anthropic-version: 2026-06-01" \
  -d '{
    "model": "claude-opus-4.8",
    "tools": [{"name": "test_tool", "description": "...", "input_schema": {...}}],
    "messages": [{"role": "user", "content": "Call the test_tool with input x=5"}]
  }' | jq '.content[].type'  # Should show "tool_use"

# Quick self-benchmark: run the same task across all agents

# 1. Terminal-Bench style test: install dependencies and run tests
claude "install deps and run pytest" --cd /path/to/project
codex "install deps and run pytest" --workdir /path/to/project
opencode --cd /path/to/project "install deps and run pytest"

# 2. Multi-file refactoring test:
claude "rename UserService to AccountService across all files"
codex "rename UserService to AccountService across all files"

# 3. Compare token cost:
# Claude Code: ~$17-20/mo Pro + usage
# Codex: $20/mo Plus + credits
# OpenCode: free (BYO API key)
# Antigravity: $19.99/mo AI Pro
# GitHub Copilot CLI: $0.01/credit usage-based

# Marketing agents: try building one with any coding agent

# Prompt for Claude Code / Codex / OpenCode:
# "Create a customer segmentation agent that:
# 1. Takes a CSV of user behavior data
# 2. Clusters users by engagement patterns
# 3. Generates personalized email templates for each segment
# 4. Outputs a campaign plan with send-time optimization"

# Or use an agent to analyze your marketing data:
opencode --cd /path/to/marketing-data \
  "Analyze this user engagement CSV and identify 
   the top 3 under-engaged segments. 
   Recommend re-engagement strategies with expected lift."

# Install Antigravity CLI (agy)
curl -fsSL https://antigravity.dev/install.sh | sh

# Verify installation
agy --version

# Authenticate with your Google account
agy auth login

# Try a basic task (replaces old `gemini` command)
agy "explain this repo in one sentence"

# Migrate MCP config from old Gemini format
agy mcp import ~/.gemini/mcp_config.json

# Ensure you're on Codex app v26.616+
# macOS only — open Codex desktop app

# Start recording a workflow
# In Codex desktop: Click the Record button in the toolbar
# Or use the keyboard shortcut: Cmd+Shift+R

# Perform your workflow (e.g., filing an expense report)
# Codex records clicks, typing, window states

# Stop recording when done
# Codex generates a SKILL.md file at:
# ~/.codex/skills/my-custom-skill/

# The skill is editable — open the SKILL.md and refine prompts:
cat ~/.codex/skills/my-custom-skill/SKILL.md

# Run the skill later:
codex run-skill "file expense report"

# List all recorded skills:
codex skills list

# Update to v0.141.0
codex update

# Verify version
codex --version
# Expected: 0.141.0

# Configure a Noise-encrypted remote executor
# Create a remote executor config:
cat > ~/.codex/remote-executor.yaml << 'EOF'
remote:
  host: build-server.internal
  port: 9443
  protocol: noise
  public_key: "executor-static-key-base64=="
  transport: relay
EOF

# Test the connection
codex exec --remote --config ~/.codex/remote-executor.yaml \
  "uname -a && whoami && pwd"

# Browse the plugin marketplace
codex plugin search

# In Claude Code CLI, use the /artifact command
claude

# Inside the session, type:
/artifact "Create a dashboard showing our API response times"

# Claude Code generates a live artifact page
# A URL is printed — share it with your team
# Artifact URL: https://claude.site/artifacts/abc123

# To publish any output as an artifact:
/artifact --publish

# View all your artifacts:
claude artifacts list

# In your MCP client config (Claude Desktop / VS Code), add:
{
  "mcpServers": {
    "internal-tools": {
      "transport": "streamable-http",
      "url": "https://mcp.internal.corp/tools",
      "auth": {
        "type": "enterprise-managed",
        "provider": "okta",
        "clientId": "0oab8example"
      }
    }
  }
}

# Users just sign in once via SSO
# No per-server OAuth prompts
# Admin: configure in Okta Admin Console
#   → Applications → MCP Connectors
#   → Assign to groups
#   → Audit usage in Okta logs

# Install OpenCode (macOS via Homebrew)
brew install opencode/tap/opencode

# Or Linux/macOS via script:
curl -fsSL https://opencode.ai/install.sh | sh

# Try it with DeepSeek V4 Flash (currently free in OpenCode)
opencode --model deepseek-v4-flash

# Inside the session, try:
# "Create a Python script that fetches the latest Hacker News stories"

# List available models:
opencode models list

# Use your own API key:
opencode --model anthropic/claude-opus-4.8 --api-key $ANTHROPIC_API_KEY

# OpenCode stats:
opencode stats

# The harness experiment: compare context handling across agents

# Test 1: Same task, different harness
# With Claude Code:
claude "refactor this function to use async/await" --cd /path/to/project

# With Codex:
codex "refactor this function to use async/await" --workdir /path/to/project

# With OpenCode:
opencode --cd /path/to/project "refactor this function to use async/await"

# Test 2: Check how each harness manages context
# See if context limits produce different results
# Export the prompt/response pairs:
claude session export --last --format json > claude_session.json
codex session export --last > codex_session.json

# Compare token usage and context windows
# The model is the same - the harness is different

# If you hit "MCP utility process never reaches ready state" in Cursor:

# 1. Check Node.js version
node --version  # needs >=18

# 2. Reinstall the MCP server declaration
# Open Cursor settings → MCP Servers → Remove and re-add

# 3. Or manually edit the MCP config
cursor --mcp-config ~/.cursor/mcp.json

# 4. Test MCP server independently
npx @modelcontextprotocol/server-filesystem /tmp/test

# 5. Restart Cursor fresh
pkill -x cursor && cursor .

# Hedge against Cursor lock-in: try model-agnostic alternatives today

# Install OpenCode (open-source, 160K+ stars)
# curl -fsSL https://opencode.ai/install.sh | sh  (review script first)

# Or install Codex CLI (OpenAI's terminal agent)
# npm install -g @openai/codex

# Or Claude Code (Anthropic's harness)
# npm install -g @anthropic-ai/claude-code

# Compare them on the same task:
# opencode "Refactor this API route to use dependency injection"
# codex "Refactor this API route to use dependency injection"
# claude "Refactor this API route to use dependency injection"

# Try GLM-5.2 via OpenRouter (9+ providers, $1.40/$4.40 per M tokens)

curl https://openrouter.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $OPENR...KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "z-ai/glm-5.2",
    "messages": [
      {"role": "user", "content": "Write a Python function that implements an LRU cache with O(1) get and put"}
    ],
    "max_tokens": 2000
  }'

# Or run locally with llama.cpp (requires 256GB+ RAM for 2-bit quant)
# brew install llama.cpp
# llama-server -hf unsloth/GLM-5.2-GGUF:UD-IQ2_M --host 0.0.0.0 --port 8080

# Make your agents audit-ready for emerging governance frameworks:

# 1. Log all agent tool calls with timestamps
cat > .hermes/config.yaml << 'CONFIG'
logging:
  level: debug
  tools: true
  prompts: true
  retention_days: 90
  export_format: jsonl
CONFIG

# 2. Add safety guardrails for sensitive operations
cat > .hermes/guardrails.yaml << 'GUARD'
rules:
  - pattern: "rm -rf"
    action: deny
    reason: "Destructive filesystem operations require manual approval"
  - pattern: "DROP TABLE"
    action: require_approval
    reason: "Database schema changes must be reviewed"
GUARD

# 3. Run compliance check
hermes check --compliance .hermes/guardrails.yaml

# Publish an ARD manifest for your agent skills

# Create ard.json at your registry root:
cat > ard.json << 'EOF'
{
  "spec_version": "1.0",
  "registry": {
    "name": "my-org-agent-skills",
    "description": "Agent skills for internal tooling"
  },
  "capabilities": [
    {
      "id": "deploy-to-k8s",
      "type": "skill",
      "name": "Kubernetes Deploy",
      "description": "Deploy containers to staging/production clusters",
      "mcp_server": "mcp://deploy.internal:3001",
      "tags": ["deploy", "k8s", "infra"],
      "input_schema": {
        "type": "object",
        "properties": {
          "namespace": {"type": "string"},
          "image_tag": {"type": "string"}
        }
      }
    }
  ]
}
EOF

# Validate it:
npx @ard/cli validate ard.json

# In GitHub Copilot Chat, try:
# /agent-finder deploy-to-k8s

# Measure your harness overhead - run same model through different harnesses:

# Test 1: Claude Code default harness
# claude --model claude-fable-5 --prompt "Write a palindrome checker function"

# Test 2: OpenCode with the same model
# opencode --model claude-fable-5 --prompt "Write a palindrome checker function"

# Test 3: Strip down the system prompt (OpenCode references)
cat > .opencode/references/palindrome-task.yaml << 'EOF'
name: palindrome-task
description: "Palindrome function generation"
instructions: |
  Write clean, tested Python code.
  Include type hints.
  Add docstrings.
  No extra commentary.
EOF

# opencode --model claude-fable-5 --reference palindrome-task \
#   --prompt "Write a palindrome checker"

# Compare token usage, time-to-first-edit, and code quality

# Update OpenCode to v1.17.8
# npm update -g @opencode/cli
# or: brew upgrade opencode

# Verify the version:
opencode --version

# Test new MCP OAuth flow:
opencode mcp add github \
  --transport oauth \
  --client-id YOUR_CLIENT_ID \
  --scopes "repo,user"

# Test long-running MCP tools with progress:
opencode mcp call my-server long-task \
  --timeout 300 \
  --progress

# Configure desktop v2 layout:
cat >> ~/.config/opencode/config.yaml << 'EOF'
desktop:
  layout: v2
  file_picker: native
  home_tab: true
EOF

# Enable Auto mode in Copilot Chat:
# On github.com: Open Copilot Chat → select "Auto" from model dropdown
# In VS Code: Cmd+I → click model selector → choose "Auto"

# Configure Auto mode preferences:
cat > ~/.vscode/copilot.json << 'EOF'
{
  "autoMode": {
    "enabled": true,
    "preferOpenSource": false,
    "costOptimized": true,
    "maxTokensPerTask": 8192
  }
}
EOF

# Test Auto mode routing:
# Simple: "Explain this regex: /^[A-Z]{2}\d{6}$/"
# Complex: "Design a distributed rate limiter using Redis Cluster"
# Agent: "Find the bug in this auth middleware and fix it"

# Auto mode routes simple queries to cheaper models,
# complex ones to frontier models automatically

# Option 1: Ollama (requires v0.30+)
ollama run frob/glm-5.2 --experimental

# Option 2: llama.cpp server (best for agent integration)
# brew install llama.cpp
# llama-server -hf unsloth/GLM-5.2-GGUF:UD-IQ2_M --ctx-size 8192 --host 0.0.0.0 --port 8080

# Option 3: Use with Pi agent
cat > ~/.pi/config.yaml << 'CFG'
provider:
  - name: glm-local
    type: openai
    base_url: http://localhost:8080/v1
    models:
      - name: glm-5.2-local
        max_tokens: 32768
CFG

# Test the local endpoint:
curl http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{"model":"glm-5.2-local","messages":[{"role":"user","content":"Write a Rust function that merges two sorted iterators"}]}'

# Download and install the GitHub Copilot App:
# macOS: brew install --cask github-copilot
# Windows: winget install GitHub.Copilot
# Linux: curl -fsSL https://github.com/github/app/releases/latest

# Start a session from an issue:
gh issue view 42 --json title,body --jq '.title + "\n" + .body' | \
  github-copilot session start --prompt-stdin

# Or from a pull request:
gh pr view 1337 --json title,body --jq '.title + "\n" + .body' | \
  github-copilot session start --pr-context

# Configure agent discovery:
cat > ~/.config/github-copilot/config.yaml << 'CONF'
agent_finder:
  registries:
    - url: https://my-org-ard-registry.com/ard.json
  auto_discover: true
  cache_ttl: 3600
CONF