The Catcher In the Rye is one of the most divisive books in the American canon of literature. But maybe it's also one of the most important books of the 20th...

Hermes Agent — Ecosystem & Related Tools Catalog

Date: 2026-08-09 Compiled from relatedrepos.com browsing of the tools installed on this box (mem0, codegraph, open-second-brain, rtk) + GitHub API verification. Categorized and sorted by fit for this Hermes Agent setup (Rust + Svelte, FicHub, Linux Mint).

Reality check first: Several names from past AI guides that looked like "hallucinations" (headroom, ponytail, caveman) are actually REAL community repos — they're just NOT Hermes first-party tools. They exist as Claude Code skills / standalone CLIs that are Hermes-compatible via MCP or skills. They are listed below with their real purpose.

1. Code Intelligence & Code Graphing

Sorted by fit for local, offline repo traversal (FicHub = Rust + Svelte + TS).

Verdict: CodeGraph (installed) remains #1 for this setup. GitNexus or Graphify worth evaluating if deeper semantic structure is needed — both are MCP/skill-compatible.

2. Memory & Second Brain

Sorted by integration quality with Hermes + local-first fit.

Verdict: Current stack (open-second-brain active + llm-wiki + mem0/qdrant) covers the space well. claude-mem is the standout addition candidate — it gives persistent cross-session context capture for any agent via MCP.

3. Token Optimization & Context Management

Sorted by actual value for Hermes v0.20.0.

Verdict: Hermes compression + rtk-hermes cover the basics. hermes-lcm (975★, Hermes-native, lossless DAG context) and headroom (66k★, pre-LLM compression) are the two highest-value additions.

4. Agent Frameworks & Skills (complementary, not replacements)

Sorted by fit for extending Hermes with reusable skills.

Verdict: Hermes already has a rich skills system. Superpowers is the standout — its methodology + skills complement Hermes's own skills nicely.

5. Agent Runtimes & Alternatives (context)

These are NOT needed for this setup but appear in the ecosystem graph.

6. RAG / Retrieval (for future semantic features)

If FicHub's ask-the-archive / semantic search grows:

7. MCP Ecosystem (the protocol layer)

8. Already-Installed Summary (this box)

Recommended additions (highest value first)

1. claude-mem — persistent cross-session context capture via MCP. Complements all three memory layers.
2. hermes-lcm — lossless DAG context management, Hermes-native.
3. headroom — pre-LLM output compression (66k★, MCP-compatible).
4. Superpowers skills — methodology + skills that slot into Hermes's skill loader.
5. GitNexus or Graphify — if CodeGraph's tree-sitter approximation ever feels limiting.

Not worth it for this setup

• TencentDB Agent Memory — Docker-heavy, overkill solo.
• Letta / Cognee / RAGFlow servers — heavyweight infra; mem0/qdrant + llm-wiki already cover memory.

Hermes Agent Setup on Linux Mint 22.3 — What Actually Worked

Date: 2026-08-09 Target: Rust + Svelte development (FicHub) with Hermes Agent v0.20.0

This doc records what ACTUALLY worked on this fresh Linux Mint install. A pasted AI guide (Qwen3.8-Max) contained many hallucinated commands (hermes tools enable rtk, standalone codegraph binaries, tree-sitter CLI setup, etc.). This file is the ground truth after verification.

1. Ground truth — what Hermes v0.20.0 actually has

• hermes runs from ~/.local/bin/hermes (a bash wrapper that execs the venv python: ~/.hermes/hermes-agent/venv/bin/python hermes).
• HERMES_HOME is the PROFILE dir: ~/.hermes/profiles/coding/ (not ~/.hermes/). Config: ~/.hermes/profiles/coding/config.yaml.
• Tools are organized as toolsets (hermes tools list), plugins (hermes plugins list), and MCP servers (hermes mcp list).
• There is NO first-party "codegraph", "tree-sitter", "rtk", "headroom", "caveman", "tokensaver", or "ponytail" tool in this build. Those names came from the hallucinated guide (except rtk-hermes, a real community pip plugin — see §5).

2. LSP (semantic diagnostics on write) — WORKED

Hermes has a built-in LSP subsystem (hermes lsp status). It runs language servers as background subprocesses and feeds diagnostics into write_file and patch results.

What was already installed

• pyright (Python), typescript-language-server (TS/JS), bash-language-server, yaml-language-server, rust-analyzer (via rustup, on PATH).

What I installed

• svelte-language-server — the auto-install (hermes lsp install svelte) FAILED (no log detail). Manual install worked:

# Install the npm package into the PROFILE lsp dir (HERMES_HOME = profile!)
mkdir -p ~/.hermes/profiles/coding/lsp/bin ~/.hermes/profiles/coding/lsp/node_modules
cd ~/.hermes/profiles/coding/lsp
npm install --prefix ~/.hermes/profiles/coding/lsp svelte-language-server
ln -sf ~/.hermes/profiles/coding/lsp/node_modules/.bin/svelteserver \
       ~/.hermes/profiles/coding/lsp/bin/svelteserver
hermes lsp status   # → svelte-language-server [installed]

Key gotcha

• hermes lsp status checks <HERMES_HOME>/lsp/bin/ where HERMES_HOME is the profile dir (~/.hermes/profiles/coding/), NOT ~/.hermes/.
• rust-analyzer is manual-only (too heavy to auto-install); rustup installs it to ~/.local/share/cargo/bin, which is on PATH.

LSP config (optional tuning)

# config.yaml
lsp:
  enabled: true
  wait_mode: document
  wait_timeout: 5.0
  install_strategy: auto
  idle_timeout: 600

3. CodeGraph — WORKED (community MCP server)

There is no first-party codegraph. The real one is @colbymchenry/codegraph (npm CLI + MCP server + SQLite + tree-sitter). It builds a pre-indexed symbol/call graph per repo. The skills-hub skill skills-sh/onsager-ai/dev-skills/codegraph documents it; the install was blocked by the scanner (community + unpinned npm), so I installed the CLI directly instead — cleaner and fully controlled.

Install + index

npm install -g @colbymchenry/codegraph      # → ~/.local/bin/codegraph
cd /personal/documents/code/rust/fichub
codegraph init .                            # indexed 299 files, 5124 nodes, 14345 edges
codegraph telemetry off
codegraph status                            # rust 137, ts 71, svelte 55, js 23, ...
codegraph query "roadmap"                   # CLI works standalone
codegraph explore "suggest"                 # blast radius + no-covering-test flags

Wire MCP into Hermes config

hermes config set mcp_servers.codegraph.command codegraph
hermes config set mcp_servers.codegraph.args '["serve","--mcp","--no-watch","--path","/personal/documents/code/rust/fichub"]'
hermes config set mcp_servers.codegraph.timeout 120
hermes config set mcp_servers.codegraph.connect_timeout 60
hermes config set mcp_servers.codegraph.enabled true

• --no-watch avoids the file-watcher (which can be heavy on NFS); reindex manually with codegraph sync after edits, or rely on the staleness banner.
• --path pins the project so the server finds .codegraph/ regardless of cwd.
• Added /.codegraph/ to the repo .gitignore.

Verification

• codegraph serve --mcp responds to initialize with tool capabilities.
• The MCP loop probe (probe_loop2.py pattern) connects and discovers codegraph_explore — the single tool. Confirmed working.
• NOTE: hermes mcp test codegraph reports "Connection closed" — a CLI probe quirk, NOT a real failure. The real MCP loop connects fine. Fresh sessions discover the tool at startup.

CodeGraph caveats (from the skill)

• It's a tree-sitter approximation, NOT compiler-grade. False negatives on method dispatch / generic call sites. grep is source of truth for completeness; codegraph accelerates orientation/traversal.
• Index lags disk by ~1s after edits.
• For exhaustive callers before a rename: use grep, not codegraph.

4. Token saving — what's real vs hallucinated

• Context compression is built-in and ON (compression.enabled: true, threshold 0.5, target_ratio 0.2). This is Hermes's real "headroom" — it summarizes older conversation to keep context within budget. Use /context to see the budget, /compress to force a pass.
• The names rtk, headroom, caveman, tokensaver, ponytail in the pasted guide are NOT Hermes tools/plugins in this build (checked source and docs). Do NOT try hermes tools enable rtk — it doesn't exist.
• rtk-hermes is a REAL community pip plugin (ogallotti/rtk-hermes, v1.2.3 on PyPI) — INSTALLED and enabled here. It rewrites terminal commands through RTK before execution to cut context tokens.

rtk-hermes install (worked)

# 1. RTK CLI (installer → ~/.local/bin)
curl -fsSL https://raw.githubusercontent.com/rtk-ai/rtk/refs/heads/master/install.sh | sh
rtk --version                                    # rtk 0.45.0

# 2. Plugin into the HERMES venv (venv has NO pip; use uv)
uv pip install --python ~/.hermes/hermes-agent/venv/bin/python --upgrade rtk-hermes

# 3. Enable (use the CLI, NOT `hermes config set plugins.enabled '["rtk-rewrite"]'`
#    — that writes a quoted string, not a YAML list; the CLI writes it correctly)
hermes plugins enable rtk-rewrite                # declines built-in tool override

# Verify
hermes plugins list | grep rtk                   # enabled 1.2.3 entrypoint
rtk rewrite "git status"                          # → "rtk git status"

• Failure mode is fail-open: if RTK can't rewrite, the original command runs.
• hermes config set plugins.enabled '[...]' saves a STRING, not a list — use hermes plugins enable instead.

5. Project context & workflow for FicHub

• Hermes auto-loads project context files: .hermes.md (walks to git root), AGENTS.md / CLAUDE.md (cwd only), .cursorrules. FicHub has docs/AGENTS.md (comprehensive rules, loaded only when cwd is docs/). A root AGENTS.md quick-start was drafted but the write needs user approval (protected agent-instruction file) — pending.
• Worktrees live on /media/alvaro/code-worktrees/wt-<name>; .env is NOT in worktrees — source from the main repo (set -a && . ./.env && set +a).

6. Host tooling status on this box

Already present: Rust (rustup, rustc/cargo), Node v22.23.2 + npm 10.9.8, git 2.43, ripgrep, fdfind, batcat. Not installed yet: pnpm (use npm or corepack), justfile, pre-commit.

7. Memory — Semantic (qdrant) + Second Brain — WORKED

7a. Semantic memory: mem0 OSS + Qdrant (local)

Hermes ships real memory-provider plugins (hermes memory status): honcho, openviking, mem0, hindsight, holographic, retaindb, byterover, supermemory. mem0 OSS mode supports Qdrant local as the vector store — that's the semantic memory path, fully local.

Prereqs: ollama on this box (LLM + embedder). Installed via the official installer (curl -fsSL https://ollama.com/install.sh | sh), pulled nomic-embed-text (embedder) + llama3.1:8b (LLM).

Gotcha: hermes memory setup mem0 --mode oss --oss-llm ... FAILS — the CLI's argparse rejects the plugin flags before the plugin sees them (the README's flag examples are aspirational for this build). The plugin reads flags from sys.argv via its own parser, so invoke post_setup directly:

# setup_mem0_oss.py (run with the hermes venv python)
import sys, os
sys.path.insert(0, "/home/alvaro/.hermes/hermes-agent")
os.environ.setdefault("HERMES_HOME", "/home/alvaro/.hermes")
sys.argv = ["hermes","memory","setup","mem0","--mode","oss",
            "--oss-llm","ollama","--oss-embedder","ollama","--oss-vector","qdrant"]
from hermes_cli.config import load_config
from plugins.memory.mem0._setup import post_setup
post_setup(os.environ["HERMES_HOME"], load_config())

Result: mem0.json with ollama llama3.1:8b + nomic-embed-text (768-d) + qdrant local at ~/.hermes/mem0_qdrant. The plugin auto-installs ollama and qdrant-client pip deps into the Hermes venv.

7b. Second brain: Karpathy-style LLM Wiki (chosen over Obsidian MCP)

The user wants the Karpathy LLM Wiki pattern (interlinked markdown KB that the LLM reads/writes, Obsidian-readable) — e.g. the llm-wiki pattern at ronancodes.github.io/llm-wiki — NOT just an Obsidian MCP bridge. The external RonanCodes/llm-wiki repo is private (404), so the wiki is implemented via the built-in llm-wiki skill (same pattern: SCHEMA / index / log, entities / concepts / comparisons / queries, wikilinks, frontmatter, ingest / query / lint). The wiki dir works as an Obsidian vault out of the box.

# Wiki lives at ~/wiki (WIKI_PATH=/home/alvaro/wiki in profile .env)
~/wiki/
├── SCHEMA.md        # domain conventions + tag taxonomy
├── index.md         # content catalog
├── log.md           # append-only action log
├── raw/             # immutable sources (articles/, papers/, transcripts/)
├── entities/        # fichub.md, ...
├── concepts/        # hermes-agent-setup-linux-mint.md, ...
├── comparisons/
└── queries/

Agent workflow (llm-wiki skill): orient (read SCHEMA+index+log) → ingest sources into raw/ → synthesize/update wiki pages with [[wikilinks]] → update index+log. Lint finds orphans, broken links, contradictions.

ALSO installed (complementary): open-second-brain native Hermes memory provider — markdown Brain/ layer injected into the system prompt + brain_* tools. Both are plain-markdown, git-versionable, human-readable.

7c. Provider layering (only one ACTIVE)

Hermes allows ONE active external memory provider (memory.provider). Current setup:

• Active: open-second-brain — markdown brain, active.md injection, brain_* tools. Vault at /home/alvaro/documents/second-brain.
• mem0/qdrant still configured (mem0.json present) — its tools (mem0_search) remain usable for semantic queries; it just isn't the auto-injecting provider.
• llm-wiki (~/wiki) is a skill-driven KB, independent of the provider system — usable regardless of which provider is active.

8. High-value additions (installed after ecosystem review)

From browsing relatedrepos.com for the installed tools (mem0, codegraph, open-second-brain, rtk) + the ecosystem catalog (/personal/documents/hermes-agent/hermes-ecosystem-tools.md), these were the top additions — all installed and verified.

8a. hermes-lcm — Lossless Context Management (Hermes plugin)

DAG-based context engine that never loses a message. Persists messages in a plugin-local SQLite store with FTS metadata; keeps the live prompt bounded while preserving raw messages for drill-down.

git clone https://github.com/stephenschoettler/hermes-lcm.git ~/code/hermes-lcm
cd ~/code/hermes-lcm && HERMES_PROFILE=coding ./scripts/install.sh
# GOTCHA: HERMES_HOME is already ~/.hermes/profiles/coding on this box, so
# the script double-appends → installs to profiles/coding/profiles/coding/.
# Move it manually:
mv ~/.hermes/profiles/coding/profiles/coding/plugins/hermes-lcm ~/.hermes/profiles/coding/plugins/
mv ~/.hermes/profiles/coding/profiles/coding/skills/hermes-lcm ~/.hermes/profiles/coding/skills/
hermes plugins enable hermes-lcm          # decline tool-override prompt
hermes config set context.engine lcm     # README activation requires this

Verified: plugin enabled (0.21.0-rc2), skill discoverable, context.engine: lcm in config.

8b. headroom — pre-LLM output compression (MCP server)

Compress tool outputs, logs, files, RAG chunks BEFORE they reach the LLM. 20% fewer tokens for coding agents, 60–95% for JSON. Local-first, reversible.

uv tool install --python 3.13 "headroom-ai[all]"    # → ~/.local/bin/headroom
hermes config set mcp_servers.headroom.command headroom
hermes config set mcp_servers.headroom.args '["mcp","serve"]'
hermes config set mcp_servers.headroom.timeout 120
hermes config set mcp_servers.headroom.connect_timeout 60
hermes config set mcp_servers.headroom.enabled true

Verified: 3 tools (headroom_compress, headroom_retrieve, headroom_stats).

8c. claude-mem — persistent cross-session context (MCP server)

Captures everything the agent does, compresses with AI, injects relevant context across sessions. 90k★. Installs as a Claude Code plugin by default; wired into Hermes via its MCP server directly.

export PATH="$HOME/.bun/bin:$PATH"     # needs Bun (installed for o2b)
npx -y claude-mem install --no-auto-start   # installs plugin + worker
npx -y claude-mem start                # worker on http://127.0.0.1:37700/
# Wire the MCP server into Hermes (path found in plugin cache):
hermes config set mcp_servers.claude-mem.command node
hermes config set mcp_servers.claude-mem.args '["/home/alvaro/.claude/plugins/cache/thedotmack/claude-mem/13.14.0/scripts/mcp-server.cjs"]'
hermes config set mcp_servers.claude-mem.timeout 120
hermes config set mcp_servers.claude-mem.connect_timeout 60
hermes config set mcp_servers.claude-mem.enabled true

Verified: 14 tools (search, timeline, get_observations, session_start_context, smart_search, smart_unfold, corpus tools, …).

8d. NOT installed (and why)

• hermes-tool-slimmer — its installer patches core Hermes source (conversation_loop.py + plugins.py) and the patch produced INVALID Python (try/finally/else) on this build, breaking the source. Reverted fully (git diff clean). Skip — Hermes's native progressive tool loader already handles large catalogs.
• Superpowers (obra) — a Claude Code-harness skills framework; its own AGENTS.md says copying skills into another harness = "dead weight" and requires its bootstrap + hooks. Not compatible with Hermes's skill system without a real harness integration. Skip; Hermes has 100+ skills already.

9. Verification checklist

hermes lsp status                 # rust-analyzer, svelte, typescript, pyright all [installed]
hermes mcp list                   # codegraph, headroom, claude-mem all ✓ enabled
codegraph status                  # in repo: index up to date
hermes plugins list               # hermes-lcm, open-second-brain, rtk-rewrite enabled
hermes doctor                     # general health

10. Session learnings / pitfalls

1. hermes lsp install svelte failed silently; manual npm install into the PROFILE lsp dir + symlink into lsp/bin/ worked.
2. HERMES_HOME = profile dir for LSP/MCP paths. ~/.hermes/lsp is NOT scanned — don't install there.
3. hermes mcp test can report false "Connection closed" for stdio servers that actually connect fine via the real MCP loop. Trust hermes mcp list
   • a fresh-session tool discovery instead.
4. hermes config set is the only way the agent can write config.yaml (direct file writes are blocked for security). Nested keys work: hermes config set mcp_servers.codegraph.command codegraph.
5. The MCP stdio env is filtered (_build_safe_env): PATH/HOME/USER/LANG/ TERM/SHELL/TMPDIR + XDG_* pass; everything else is dropped. If a server needs a custom env var, add it via mcp_servers.<name>.env.
6. Watchdog wrapper (mcp_stdio_watchdog.py) relays stdio transparently; a pipeline test that pipes echo | watchdog --ppid $$ is misleading ($$ is not the watchdog's parent in a pipeline) — test with a stable parent.
7. Never edit config.yaml directly as the agent — use hermes config set.
8. hermes-tool-slimmer's installer patches core Hermes source and can break it. It inserted a select_tool_schemas hook into conversation_loop.py with invalid try/finally/else syntax — the next Hermes session would have crashed with SyntaxError. If a plugin's installer modifies ~/.hermes/hermes-agent/, verify with venv/bin/python -m py_compile + git diff afterward, and revert with patch (not git checkout — that's blocked on the live source).
9. Probes of MULTIPLE MCP servers on one loop sequentially can show false "parked" failures (retry/parking interaction between shutdowns). Probe each server in a fresh process to confirm it works — each of codegraph, headroom, claude-mem connects fine individually.

Below is a copy‑paste self‑configuration kit for Hermes Agent on Linux Mint.
It is designed to be fed directly to Hermes so it can configure itself.

This setup gives you:

• Layered memory: working, project, semantic/vector, episodic, procedural
• Semantic embedding: local embeddings + vector search
• Second brain: local Markdown vault, Obsidian‑compatible, FLOSS‑friendly
• Token optimization by default: persistent config + shell env + hooks
• Coding/agentic defaults: ripgrep, fd, jq, git, linters, memory search, context packing
• Optional Notion bridge if you really want Notion instead of local Markdown

Important: Hermes builds differ. Some use YAML, some TOML, some JSON, some plugins.
The prompt below tells Hermes: “Use your actual config format, but preserve these semantics.”

1. Recommended choices before you paste

For coding + agentic work, the best practical default is:

• Second brain: local Markdown vault

  • Works with agents
  • Easy to grep
  • Easy to embed
  • Easy to version with Git
  • Compatible with Logseq / Obsidian‑like tools

• Embedding model: local via Ollama

  • Default: nomic-embed-text
  • Optional higher quality: bge-m3 if you have more RAM/VRAM

• Coding model: local or API depending on your hardware

  • Safe default: qwen2.5-coder:7b
  • If you have strong GPU/RAM: use a larger coder model

• Token optimization:

  • prompt caching
  • context pruning
  • tool output truncation
  • semantic dedup
  • automatic summarization
  • plugin order: rtk, caveman, ponytail, headroom, tokensaver

2. Paste this entire block into Hermes

Copy everything inside the code block below and give it to Hermes.

AGENT SELF-CONFIGURATION WORK ORDER
===================================

You are Hermes running on Linux Mint.
Your job is to configure yourself for best-in-class coding and agentic work.

GOALS
-----
1. Persistent layered memory:
   - working memory
   - project memory
   - semantic/vector memory
   - episodic memory
   - procedural memory
2. Local semantic embedding and retrieval.
3. A local-first second brain in Markdown.
   - Must be Obsidian-compatible in spirit.
   - Prefer FLOSS-friendly tooling.
4. Token optimization must be ON by default in every session.
5. Strong coding defaults: search, lint, git, context discipline, memory usage.

RULES
-----
- Use bash.
- Be idempotent: safe to run multiple times.
- Do not overwrite existing user data without backup.
- Ask before using sudo or installing system-wide packages.
- Prefer local-first and FLOSS-friendly options.
- If Hermes config uses YAML/TOML/JSON differently, adapt the semantics exactly.
- If a plugin or feature is missing, create the closest equivalent.
- After each phase, verify and report what changed.

TARGET PATHS
------------
HERMES_HOME="$HOME/.hermes"
HERMES_CONFIG_HOME="$HOME/.config/hermes"
SECOND_BRAIN="$HOME/SecondBrain"
MEMORY_DB="$HERMES_HOME/memory/vector/chroma"
TOOLS_DIR="$HERMES_HOME/tools"
BIN_DIR="$HOME/.local/bin"

DEFAULT MODEL CHOICES
---------------------
If I do not specify otherwise, use:
CODE_MODEL="qwen2.5-coder:7b"
EMBED_MODEL="nomic-embed-text"
SMALL_MODEL="llama3.2:3b"

If you detect much stronger hardware, ask me before switching to a bigger model.

PHASE 0: BACKUP AND DETECT ENVIRONMENT
--------------------------------------
1. Create backup directory:
   mkdir -p "$HERMES_HOME/backups/$(date +%Y%m%d-%H%M%S)"
2. Detect:
   - shell: bash/zsh
   - package manager: apt
   - python3 version
   - node/npm presence
   - ollama presence
   - git presence
3. Report what is missing.
4. Ask before any sudo install.

PHASE 1: BASE LINUX MINT PACKAGES
---------------------------------
Ask me first, then install these if missing:

sudo apt update
sudo apt install -y \
  git curl wget build-essential python3-pip python3-venv python3-dev \
  pipx ripgrep fd-find fzf jq sqlite3 tree tmux shellcheck \
  universal-ctags gh npm

Then:
mkdir -p "$BIN_DIR"
pipx ensurepath

If fdfind exists but fd does not:
ln -sf "$(command -v fdfind)" "$BIN_DIR/fd"

Add "$BIN_DIR" to PATH if missing.

PHASE 2: INSTALL LOCAL MODEL RUNTIME
------------------------------------
Preferred runtime: Ollama.

If ollama is missing, ask me before running:
curl -fsSL https://ollama.com/install.sh | sh

Then ensure service is running:
systemctl status ollama --no-pager || true

Pull models:
ollama pull "$CODE_MODEL"
ollama pull "$EMBED_MODEL"
ollama pull "$SMALL_MODEL"

If CODE_MODEL is unavailable, fallback to:
- qwen2.5-coder:3b
- qwen2.5:7b
- llama3.1:8b

If EMBED_MODEL is unavailable, fallback to:
- bge-m3
- mxbai-embed-large
- all-minilm

PHASE 3: CREATE HERMES DIRECTORY STRUCTURE
------------------------------------------
mkdir -p \
  "$HERMES_HOME/memory/episodes" \
  "$HERMES_HOME/memory/notes" \
  "$HERMES_HOME/memory/vector" \
  "$HERMES_HOME/playbooks" \
  "$HERMES_HOME/tmp" \
  "$HERMES_HOME/context" \
  "$HERMES_HOME/backups" \
  "$TOOLS_DIR" \
  "$BIN_DIR"

Create these files if missing:
- "$HERMES_HOME/memory/lessons.md"
- "$HERMES_HOME/playbooks/default.md"

PHASE 4: CREATE LOCAL SECOND BRAIN
----------------------------------
Use a local Markdown vault at:
SECOND_BRAIN="$HOME/SecondBrain"

Create:
mkdir -p \
  "$SECOND_BRAIN/00-Inbox" \
  "$SECOND_BRAIN/10-Projects" \
  "$SECOND_BRAIN/20-Areas" \
  "$SECOND_BRAIN/30-Resources" \
  "$SECOND_BRAIN/40-Archive" \
  "$SECOND_BRAIN/90-Meta" \
  "$SECOND_BRAIN/Templates" \
  "$SECOND_BRAIN/Attachments"

Initialize git:
cd "$SECOND_BRAIN"
git init
git add .
git commit -m "Initial second brain structure" || true

Create README:
cat > "$SECOND_BRAIN/README.md" <<'EOF'
# Second Brain

Local-first Markdown knowledge base.

Structure:
- 00-Inbox: raw captures
- 10-Projects: active project notes
- 20-Areas: ongoing areas, daily notes, health, ops
- 30-Resources: references, snippets, links, papers
- 40-Archive: inactive material
- 90-Meta: config, templates, agent rules

Rules:
- One idea per note when possible.
- Prefer links and tags.
- Durable decisions go here.
- Agent should search here before asking repetitive questions.
EOF

Create a basic .gitignore:
cat > "$SECOND_BRAIN/.gitignore" <<'EOF'
.trash/
.obsidian/workspace*
.obsidian/cache
*.tmp
.DS_Store
EOF

PHASE 5: CREATE PERSISTENT ENVIRONMENT CONFIG
---------------------------------------------
Create file: "$HERMES_CONFIG_HOME/hermes.env"

Content:
cat > "$HERMES_CONFIG_HOME/hermes.env" <<'EOF'
export HERMES_HOME="$HOME/.hermes"
export HERMES_CONFIG_HOME="$HOME/.config/hermes"
export HERMES_SECOND_BRAIN="$HOME/SecondBrain"
export HERMES_MEMORY_DB="$HERMES_HOME/memory/vector/chroma"
export HERMES_CONTEXT_DIR="$HERMES_HOME/context"
export HERMES_EPISODES_DIR="$HERMES_HOME/memory/episodes"
export HERMES_NOTES_DIR="$HERMES_HOME/memory/notes"
export HERMES_PLAYBOOK_DIR="$HERMES_HOME/playbooks"

export OLLAMA_ENDPOINT="http://127.0.0.1:11434/"
export HERMES_CODE_MODEL="qwen2.5-coder:7b"
export HERMES_EMBED_MODEL="nomic-embed-text"
export HERMES_SMALL_MODEL="llama3.2:3b"

export HERMES_TOKEN_OPTIMIZER="auto"
export HERMES_TOKEN_OPTIMIZER_DEFAULT="1"
export HERMES_PROMPT_CACHE="1"
export HERMES_CONTEXT_BUDGET_PERCENT="75"
export HERMES_HEADROOM_PERCENT="20"
export HERMES_MAX_TOOL_OUTPUT_CHARS="12000"
export HERMES_COMPRESS_AFTER_TURNS="8"
export HERMES_MEMORY_SEARCH_TOP_K="5"
export HERMES_AUTO_CAPTURE="1"

export HERMES_ALWAYS_LOAD="$HERMES_PLAYBOOK_DIR/default.md;$HERMES_HOME/memory/lessons.md"
EOF

Then replace model placeholders with chosen values if different.

Make it load by default in new shells:
Add this line to ~/.bashrc and ~/.profile if missing:
[ -f "$HOME/.config/hermes/hermes.env" ] && . "$HOME/.config/hermes/hermes.env"

Also add to ~/.zshrc if it exists.

PHASE 6: CREATE HERMES CONFIG FOR MEMORY + TOKEN OPTIMIZATION
--------------------------------------------------------------
Create: "$HERMES_CONFIG_HOME/config.yaml"

If Hermes uses TOML/JSON instead, convert this semantics-preserving config.

cat > "$HERMES_CONFIG_HOME/config.yaml" <<'EOF'
agent:
  model: "${HERMES_CODE_MODEL}"
  small_model: "${HERMES_SMALL_MODEL}"
  temperature: 0.1
  max_output_tokens: 4096
  tools:
    shell: true
    filesystem: true
    git: true
    web: false

memory:
  enabled: true
  layers:
    working:
      path: "${HERMES_HOME}/tmp/session.md"
      max_tokens: 2000
    project:
      files:
        - "AGENTS.md"
        - ".hermes/project.md"
        - "DECISIONS.md"
    semantic:
      provider: chroma
      path: "${HERMES_MEMORY_DB}"
      collection: "hermes_memory"
      top_k: 5
    episodic:
      path: "${HERMES_EPISODES_DIR}"
      format: "jsonl"
    procedural:
      paths:
        - "${HERMES_PLAYBOOK_DIR}"
        - "${HERMES_HOME}/memory/lessons.md"

second_brain:
  provider: markdown
  path: "${HERMES_SECOND_BRAIN}"
  inbox: "00-Inbox"
  auto_capture: true
  git_auto_commit: true

embedding:
  provider: ollama
  endpoint: "${OLLAMA_ENDPOINT}"
  model: "${HERMES_EMBED_MODEL}"
  batch_size: 8
  chunk_size: 1200

token_optimization:
  enabled: true
  default: true
  prompt_caching: true
  context_budget_percent: 75
  headroom_percent: 20
  summarize_old_turns: true
  compress_after_turns: 8
  truncate_tool_output_chars: 12000
  semantic_dedup: true
  apply_to:
    - conversation_history
    - tool_results
    - memory_retrievals
  never_compress:
    - code
    - diffs
    - commands
    - file_contents
  plugins:
    rtk:
      enabled: auto
    caveman:
      enabled: auto
    ponytail:
      enabled: auto
    headroom:
      enabled: auto
    tokensaver:
      enabled: auto
  fallback: builtin

coding:
  search:
    ripgrep: true
    fd: true
    fzf: true
  lint:
    shellcheck: true
    ruff: auto
  git:
    auto_status: true
    diff_style: unified

safety:
  confirm_destructive: true
  secrets_file: "${HERMES_CONFIG_HOME}/secrets.env"
  deny:
    - "rm -rf /"
    - "sudo rm -rf"
EOF

If Hermes does not expand environment variables inside config, replace variables with literal paths.

PHASE 7: CREATE SEMANTIC MEMORY TOOLING
----------------------------------------
Create Python venv:
python3 -m venv "$HERMES_HOME/venv"
"$HERMES_HOME/venv/bin/pip" install -U pip requests chromadb

Create tool file: "$TOOLS_DIR/hermes_memory.py"
Use the exact Python script provided in the attached template section.

Create wrapper: "$BIN_DIR/hermes-memory"
cat > "$BIN_DIR/hermes-memory" <<'EOF'
#!/usr/bin/env bash
exec "$HOME/.hermes/venv/bin/python" "$HOME/.hermes/tools/hermes_memory.py" "$@"
EOF
chmod +x "$BIN_DIR/hermes-memory"

Test:
"$BIN_DIR/hermes-memory" index --root "$HOME/SecondBrain"
"$BIN_DIR/hermes-memory" search "second brain test" --top 2

PHASE 8: TOKEN OPTIMIZATION DEFAULTS
------------------------------------
Token optimization must be active by default without user re-enabling.

Ensure all of these are true:
1. "$HERMES_CONFIG_HOME/hermes.env" is sourced from shell startup files.
2. Hermes config contains token_optimization.enabled: true.
3. Hermes config contains token_optimization.default: true.
4. If Hermes supports plugins, enable installed token optimizer plugins in this order:
   rtk -> caveman -> ponytail -> headroom -> tokensaver
5. If a plugin is missing, use built-in fallback.
6. Do not lossily compress code, diffs, commands, or file contents.

Create a generic optimizer wrapper:
cat > "$BIN_DIR/hermes-token-optimizer" <<'EOF'
#!/usr/bin/env bash
set -euo pipefail
input="$(cat || true)"

for cmd in rtk caveman ponytail headroom tokensaver; do
  if command -v "$cmd" >/dev/null 2>&1; then
    if out=$(printf '%s' "$input" | "$cmd" 2>/dev/null); then
      printf '%s\n' "$out"
      exit 0
    fi
  fi
done

# Safe built-in fallback: remove blank lines and collapse whitespace.
printf '%s\n' "$input" | awk 'NF' | sed -E 's/[[:space:]]+/ /g'
EOF
chmod +x "$BIN_DIR/hermes-token-optimizer"

If Hermes supports a CLI hook or pre-session hook, configure it to use:
- token optimizer
- memory retrieval
- context budget check

PHASE 9: CREATE DEFAULT PLAYBOOK AND LESSONS
--------------------------------------------
Create "$HERMES_HOME/playbooks/default.md":

cat > "$HERMES_HOME/playbooks/default.md" <<'EOF'
# Hermes Default Playbook

## Before coding
- Read AGENTS.md, DECISIONS.md, and relevant project docs.
- Search semantic memory before asking repeated questions.
- Prefer ripgrep/fd over reading whole repos.
- Prefer small diffs and precise commands.

## Token discipline
- Keep answers concise and executable.
- Do not repeat large logs verbatim.
- Summarize old conversation turns when context budget > 75%.
- Preserve code, diffs, commands, and file contents exactly.

## Memory discipline
- Save durable facts to Second Brain.
- Save mistakes and fixes to lessons.md.
- Save project conventions to AGENTS.md.
EOF

Create "$HERMES_HOME/memory/lessons.md" if missing:
cat > "$HERMES_HOME/memory/lessons.md" <<'EOF'
# Lessons

## Format
- Date: what happened, why, fix, prevention.

## Entries
EOF

PHASE 10: CREATE PROJECT AGENT TEMPLATE
----------------------------------------
Create "$HERMES_HOME/templates/AGENTS.md":

mkdir -p "$HERMES_HOME/templates"
cat > "$HERMES_HOME/templates/AGENTS.md" <<'EOF'
# Agent Instructions

## Project goal
Describe what this repo does.

## Commands
- install:
- build:
- test:
- lint:

## Constraints
- Keep changes minimal.
- Prefer backwards compatibility.
- Do not add dependencies without asking.

## Notes for agent
- Read DECISIONS.md before refactors.
- Prefer small diffs.
- Ask before destructive operations.
EOF

Also create a helper to initialize projects:
cat > "$BIN_DIR/hermes-project-init" <<'EOF'
#!/usr/bin/env bash
set -euo pipefail
mkdir -p .hermes
if [ ! -f AGENTS.md ]; then
  cp "$HOME/.hermes/templates/AGENTS.md" AGENTS.md
fi
if [ ! -f DECISIONS.md ]; then
  echo "# Decision Log" > DECISIONS.md
fi
echo "Project memory initialized."
EOF
chmod +x "$BIN_DIR/hermes-project-init"

PHASE 11: OPTIONAL FLOSS SECOND BRAIN GUI
------------------------------------------
Ask me if I want a GUI.

Recommended FLOSS-ish local options:
- Logseq
- Joplin
- AFFiNE
- AppFlowy

For coding agents, plain Markdown remains best.

If I approve Logseq:
flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo
flatpak install -y flathub com.logseq.Logseq

If I approve Joplin:
flatpak install -y flathub net.cozic.joplin_desktop

PHASE 12: OPTIONAL NOTION BRIDGE
---------------------------------
Only enable if I explicitly ask for Notion.

If enabled:
1. Ask me for NOTION_TOKEN and NOTION_DATABASE_ID.
2. Store them in "$HERMES_CONFIG_HOME/secrets.env" with chmod 600.
3. Add config:
   second_brain.notion.enabled: true
4. Do not let Notion replace local Markdown.
   Notion should be secondary sync/export.

PHASE 13: VERIFY EVERYTHING
---------------------------
Run checks:
- printenv HERMES_TOKEN_OPTIMIZER
- command -v ollama
- ollama list
- curl -fsS http://127.0.0.1:11434/api/tags
- "$BIN_DIR/hermes-memory" index --root "$HOME/SecondBrain"
- "$BIN_DIR/hermes-memory" search "test" --top 2
- ls "$HOME/SecondBrain"
- grep -R "token_optimization" "$HERMES_CONFIG_HOME" || true

Then print a final report:
- what was installed
- what was created
- what is enabled by default
- what needs manual action
- what optional upgrades are recommended

ACCEPTANCE CRITERIA
-------------------
The setup is complete only if:
1. A new terminal session has HERMES_TOKEN_OPTIMIZER set.
2. Hermes config has token optimization enabled by default.
3. Semantic memory indexing works.
4. Semantic search returns results.
5. Second Brain exists and is git-initialized.
6. Layered memory paths exist.
7. Hermes loads default playbook and lessons automatically.
8. Token optimization does not require re-enabling per session.

3. File template Hermes should use for semantic memory

Tell Hermes to use this exact content for:

~/.hermes/tools/hermes_memory.py

#!/usr/bin/env python3
import argparse, hashlib, json, os, pathlib, re, sys

try:
    import chromadb
except Exception:
    sys.exit("chromadb is not installed. Run: ~/.hermes/venv/bin/pip install chromadb requests")

import requests

DEFAULT_ENDPOINT = os.environ.get("OLLAMA_ENDPOINT", "http://127.0.0.1:11434/")
DEFAULT_MODEL = os.environ.get("HERMES_EMBED_MODEL", "nomic-embed-text")
DEFAULT_DB = os.path.expanduser(os.environ.get("HERMES_MEMORY_DB", "~/.hermes/memory/vector/chroma"))
COLLECTION = "hermes_memory"

EXTS = {
    ".md", ".markdown", ".txt", ".rst",
    ".py", ".sh", ".bash",
    ".json", ".yaml", ".yml", ".toml"
}

IGNORE_DIRS = {
    ".git", ".hg", ".svn", ".venv", "venv",
    "node_modules", "__pycache__", ".cache",
    ".hermes", ".ollama", ".local", ".Trash"
}


def chunk_text(text, max_chars=1200):
    text = re.sub(r"\r\n", "\n", text)
    parts = re.split(r"\n{2,}", text)
    chunks = []
    cur = ""

    for part in parts:
        part = part.strip()
        if not part:
            continue

        cand = f"{cur}\n\n{part}".strip() if cur else part
        if len(cand) <= max_chars:
            cur = cand
            continue

        if cur:
            chunks.append(cur)

        if len(part) <= max_chars:
            cur = part
        else:
            words = part.split()
            cur = ""
            for w in words:
                cand = f"{cur} {w}".strip()
                if len(cand) <= max_chars:
                    cur = cand
                else:
                    if cur:
                        chunks.append(cur)
                    if len(w) > max_chars:
                        for i in range(0, len(w), max_chars):
                            chunks.append(w[i:i + max_chars])
                        cur = ""
                    else:
                        cur = w

    if cur:
        chunks.append(cur)

    return [c.strip() for c in chunks if c.strip()]


def embed_batch(texts, endpoint, model):
    # Try batch endpoint first
    try:
        r = requests.post(
            f"{endpoint}/api/embed",
            json={"model": model, "input": texts},
            timeout=180
        )
        if r.ok:
            data = r.json()
            if data.get("embeddings") and len(data["embeddings"]) == len(texts):
                return data["embeddings"]
    except Exception:
        pass

    # Fallback to single prompt endpoint
    out = []
    for t in texts:
        r = requests.post(
            f"{endpoint}/api/embeddings",
            json={"model": model, "prompt": t},
            timeout=180
        )
        r.raise_for_status()
        out.append(r.json()["embedding"])
    return out


def get_collection(db_path):
    client = chromadb.PersistentClient(path=db_path)
    return client.get_or_create_collection(
        COLLECTION,
        metadata={"hnsw:space": "cosine"}
    )


def iter_files(roots):
    for root in roots:
        root = pathlib.Path(root).expanduser()

        if root.is_file():
            yield root
            continue

        if not root.exists():
            continue

        for dirpath, dirnames, filenames in os.walk(root):
            dirnames[:] = [
                d for d in dirnames
                if d not in IGNORE_DIRS and not d.startswith(".")
            ]

            for fname in filenames:
                p = pathlib.Path(dirpath) / fname
                if p.suffix.lower() in EXTS and not fname.startswith("."):
                    yield p


def cmd_index(args):
    col = get_collection(args.db)
    roots = args.root or [
        os.environ.get("HERMES_SECOND_BRAIN", "~/SecondBrain"),
        os.path.expanduser("~/.hermes/memory/notes")
    ]

    ids, docs, metas = [], [], []

    for p in iter_files(roots):
        try:
            text = p.read_text(errors="ignore")
        except Exception:
            continue

        for i, chunk in enumerate(chunk_text(text, args.chunk_size)):
            uid = hashlib.sha1(
                f"{p}:{i}:{chunk[:80]}".encode("utf-8", "ignore")
            ).hexdigest()
            ids.append(uid)
            docs.append(chunk)
            metas.append({
                "path": str(p),
                "chunk": i,
                "mtime": int(p.stat().st_mtime)
            })

    for start in range(0, len(docs), args.batch_size):
        end = start + args.batch_size
        if start >= len(docs):
            break

        embeddings = embed_batch(
            docs[start:end],
            args.endpoint,
            args.model
        )

        col.upsert(
            ids=ids[start:end],
            documents=docs[start:end],
            embeddings=embeddings,
            metadatas=metas[start:end]
        )

    print(json.dumps({"indexed": len(ids), "db": args.db}, indent=2))


def cmd_search(args):
    db_path = os.path.expanduser(args.db)

    if not os.path.exists(db_path):
        print("[]")
        return

    col = get_collection(db_path)
    emb = embed_batch([args.query], args.endpoint, args.model)[0]

    res = col.query(
        query_embeddings=[emb],
        n_results=args.top,
        include=["documents", "metadatas", "distances"]
    )

    items = []
    if res and res.get("ids") and res["ids"][0]:
        for i, uid in enumerate(res["ids"][0]):
            meta = res["metadatas"][0][i] if res.get("metadatas") else {}
            dist = res["distances"][0][i] if res.get("distances") else 0.0
            doc = res["documents"][0][i] if res.get("documents") else ""

            items.append({
                "id": uid,
                "score": round(1.0 - float(dist), 6),
                "path": meta.get("path", ""),
                "text": doc[:args.chars]
            })

    print(json.dumps(items, indent=2))


def main():
    ap = argparse.ArgumentParser(description="Hermes layered semantic memory")
    sub = ap.add_subparsers(dest="cmd", required=True)

    common = argparse.ArgumentParser(add_help=False)
    common.add_argument("--model", default=DEFAULT_MODEL)
    common.add_argument("--endpoint", default=DEFAULT_ENDPOINT)
    common.add_argument("--db", default=DEFAULT_DB)

    idx = sub.add_parser("index", parents=[common])
    idx.add_argument("--root", action="append")
    idx.add_argument("--chunk-size", type=int, default=1200)
    idx.add_argument("--batch-size", type=int, default=8)
    idx.set_defaults(func=cmd_index)

    srch = sub.add_parser("search", parents=[common])
    srch.add_argument("query")
    srch.add_argument(
        "--top",
        type=int,
        default=int(os.environ.get("HERMES_MEMORY_SEARCH_TOP_K", "5"))
    )
    srch.add_argument("--chars", type=int, default=700)
    srch.set_defaults(func=cmd_search)

    args = ap.parse_args()
    args.db = os.path.expanduser(args.db)
    args.func(args)


if __name__ == "__main__":
    main()

4. What this gives you after Hermes finishes

You should now have:

• ~/.config/hermes/config.yaml
  Main Hermes config with memory + token optimization.

• ~/.config/hermes/hermes.env
  Persistent environment variables.

• ~/SecondBrain/
  Local Markdown second brain.

• ~/.hermes/
  Hermes memory home.

• ~/.hermes/tools/hermes_memory.py
  Semantic indexing + search tool.

• ~/.local/bin/hermes-memory
  CLI for indexing/search.

• ~/.local/bin/hermes-token-optimizer
  Token optimizer wrapper.

• ~/.local/bin/hermes-project-init
  Initializes project memory in a repo.

5. Token optimization stays on by default because…

The setup makes token optimization persistent in three layers:

1. Shell environment

   • ~/.bashrc
   • ~/.profile
   • optionally ~/.zshrc

2. Hermes config

   • token_optimization.enabled: true
   • token_optimization.default: true

3. Optimizer wrapper

   • tries rtk, caveman, ponytail, headroom, tokensaver
   • falls back to safe built-in compression

That means you should not need to re-enable it every session.

6. Daily usage commands

After setup, these are useful:

Index your second brain

hermes-memory index --root "$HOME/SecondBrain"

Search memory

hermes-memory search "how did we fix the build error" --top 5

Index a project too

hermes-memory index --root "$HOME/SecondBrain" --root "$HOME/code/yourproject"

Initialize a repo for agent memory

cd ~/code/yourproject
hermes-project-init

7. Optional but highly useful additions

These are things many people add next.

A. Better code search

Already included:

• ripgrep
• fd
• fzf

Optional:

• bat
• eza
• lazygit

B. Better coding quality

Ask Hermes to install/configure:

• ruff
• shellcheck
• pre-commit
• yamllint
• pyright or typescript-language-server if you use TS

C. Per-project environment

Useful:

• direnv

So each repo can auto-load:

• model choice
• context budget
• memory roots
• API keys

D. Backups

For your second brain:

• Git remote
• Syncthing
• BorgBackup

E. GUI second brain

If you want a GUI:

• Logseq is the closest FLOSS-friendly local-first choice
• Joplin is more note-taking oriented
• AFFiNE/AppFlowy are more Notion-like but can be less agent-friendly

8. If you really want Notion instead of local Markdown

Use Notion only as a secondary bridge, not the primary brain.

Ask Hermes to do this:

Enable optional Notion bridge for second brain.
- Ask me for NOTION_TOKEN and NOTION_DATABASE_ID.
- Store them in ~/.config/hermes/secrets.env with chmod 600.
- Keep local Markdown as primary source of truth.
- Use Notion only for sync/export, not as the main agent memory.

Why?

• Local Markdown is easier for agents to read/write
• Embedding local files is simpler and more reliable
• You avoid API latency and token overhead

9. If you want the “best” version, ask Hermes for these upgrades too

Paste this after the first setup:

Upgrade my Hermes setup with these improvements:
1. Use a bigger coding model if my hardware supports it.
2. Use bge-m3 for embeddings if quality matters more than speed.
3. Add automatic memory indexing with a systemd user timer.
4. Add session-start context packing from semantic memory.
5. Add automatic episode logging in JSONL.
6. Add project templates for Python, TypeScript, Bash, and Go.
7. Add safety hooks that prevent destructive shell commands.
8. Add git auto-commit for Second Brain.
9. Add a weekly memory deduplication pass.
10. Add token usage reporting so I can see what consumes context.

10. My recommended “best practical” stack

If you want the strongest default without overcomplicating things:

• Second brain: local Markdown + Git
• GUI: Logseq
• Embeddings: Ollama + nomic-embed-text
• Vector store: Chroma
• Coding model: qwen2.5-coder:7b or bigger
• Small summarizer: llama3.2:3b
• Token optimization: always-on with plugin fallback chain
• Memory style: layered memory as configured above

If you want, I can also give you a single one-shot bash bootstrap script version of this entire setup that you can save as hermes-setup.sh and run directly.

This week in open source, the commons took hits from every direction at once.

A third wave of malware quietly took over more than nineteen hundred packages in the Arch User Repository before the project slammed the brakes and froze package adoption entirely. A man in Atlanta is staring at five years in federal prison — not for anything he did with his phone, but for using a privacy feature on it. The biggest desktop environments are fighting off a flood of sloppy AI-generated code while the industry's newest marketing trick is to advertise how much of the product was "written by AI" instead of by people. And meanwhile, in the middle of all that noise, the people who actually build this stuff kept building: a new COSMIC desktop, a Rust-native X server crossing the finish line, GOG officially coming to Linux, open firmware for modern AMD boards, and NetBSD turning eleven with RISC-V support.

This is the open source news digest, and I want to read it the way I read everything: by asking who benefits when the thing you use every day gets a little less safe, a little more owned, and a little less yours.

Let me start with the story that should make every single person using Arch — and honestly, every person using any free software — sit up. On July thirtieth, Arch Linux disabled package adoption on the Arch User Repository after a third sustained wave of malicious takeovers. The campaign has a nickname now: Atomic Arch. Attackers have compromised well over nineteen hundred packages across three waves since late May. First wave, around June ninth: they adopted orphaned packages — abandoned projects that nobody maintains anymore — and slipped npm install commands into the build scripts. Those lifecycle scripts silently pulled down a Rust-based credential stealer that could optionally drop an eBPF rootkit to hide its own traces in the kernel. The Arch team purged more than nineteen hundred affected packages in mid-June and declared the repository clean. Within hours, the second wave rolled out, this time with heavily obfuscated JavaScript downloaders. And now the third wave flips the detection playbook entirely: attackers embedding compiled ELF binaries directly into build scripts, static payloads that execute during the makepkg build phase, bypassing the JavaScript-based detection that caught the earlier waves.

Let me translate what that actually means, because the technical details hide the real story. The Arch User Repository is a community repository. It runs on trust — thousands of volunteers packaging software for other people to use, no corporate security team, no paid gatekeepers, no bug bounty that pays a living wage. When you install from the AUR, you are trusting that the person who wrote the package is not the person who wants to steal your passwords. That trust is the attack surface. The attackers did not break into Arch's servers. They did not exploit some clever kernel bug. They adopted orphaned packages — the digital equivalent of moving into an abandoned house — and put their malware in the build instructions. Nineteen hundred packages. Three waves. Months of volunteer time spent cleaning up a mess that no one was paid to clean up.

And here's the systemic part that nobody in the headlines will say out loud: this is what an open commons looks like under siege. The official repositories stayed untouched. The core infrastructure held. But the community layer — the part built and maintained by volunteers, the part that exists precisely because no one owns it — that's the part that got attacked, because that's the part where trust is the only security, and trust is free to exploit. When the tech giants talk about "open source supply chain security," what they usually mean is: your unpaid labor is our free quality assurance, and if it fails, we'll sell you a product to fix it. The AUR crisis is the purest demonstration of that logic: the commons gets attacked, and the people who actually own the infrastructure — the volunteers — absorb the cost, while the companies that depend on that infrastructure sell "solutions" to the problem they didn't have to solve.

Now the second story, and this one should make you genuinely angry. A GrapheneOS privacy feature just became the basis for a federal indictment. Samuel Tunick, an Atlanta resident, faces up to five years in prison. The charge: destruction of property to prevent government seizure, under a federal statute about blocking evidence seizure. The "destruction" was his phone wiping itself after he gave border agents a passcode — a duress password, a feature designed exactly for this scenario. Let me tell you what happened. In January, Customs and Border Protection put Tunick into secondary inspection at Atlanta's airport as he returned from the Dominican Republic. Agents searched him, demanded the passcode to his phone, all under the pretext of looking for CSAM. He asked for a lawyer multiple times. They ignored him. They never read him his Miranda rights. When he pushed back, they told him it was "a whole different ballgame" at the border, and they didn't need a warrant. He eventually handed over a passcode. The moment it was entered, the screen flickered, the phone rebooted, and its contents erased in front of the same agents who'd demanded access. That's the duress password working exactly as designed — a panic feature that lets you surrender something plausible while the real data stays safe.

And the state's response to a privacy feature working as intended is to indict the man who used it. Five years. The motion filed by his lawyer stresses that his real crime, in the eyes of the agents, was his association with Defend the Atlanta Forest, an activist group fighting the construction of a police training facility. The FBI had been circling that movement. So let's be clear about what this case is: an activist, flagged for his organizing, returns from a trip abroad, is detained without a warrant at the border, is denied a lawyer, is denied his rights, is pressured into handing over a passcode, and when the privacy feature does what it was built to do, the state charges him with a federal crime.

This is the pattern. It's the same pattern we saw with the Epstein case, where there was actual proof, actual documentation, actual victims, and the powerful people in that orbit walked — until one of them had a problem with another powerful person. The elites can do anything they want. Average people are always the ones being targeted. The surveillance state doesn't go after the people who own the infrastructure; it goes after the people who might challenge them. A duress password is a tool built so a journalist, an activist, a regular person under coercion can hand over something that looks like everything while protecting what matters. And the moment that tool is used, the state calls it evidence destruction. Think about what that means for everyone else: if a panic feature that protects your data under coercion is now a crime, then privacy itself is the crime. Encryption becomes suspicious. A passcode that wipes your phone becomes evidence of guilt. The tools that let ordinary people protect themselves from the state are being redefined, one case at a time, as tools of the guilty.

And look at the ecosystem reacting in real time. Windscribe just released deGDID, a tool to remove and block Microsoft's Global Device ID — the tracking identifier Microsoft has been quietly embedding in Windows. A commercial VPN company is shipping a free tool to strip surveillance out of the operating system, because the operating system vendor won't stop. That's the state of things: the people who make the OS have turned it into a surveillance instrument, and the people who sell privacy have to clean up after them. Meanwhile GrapheneOS, the privacy-hardened Android, gets its flagship feature turned into a federal charge. When the tool that protects you becomes the evidence against you, you have to ask: whose side is the system on?

Third story thread, and this one has a darkly funny edge to it. The AI gold rush has reached the open source maintainers, and they are not impressed. Debian developers are voting on five proposals about LLM use — spanning everything from a total ban on AI-generated contributions to pragmatic acceptance. GNU GCC, one of the oldest and most important compilers in existence, just banned AI code contributions, but sensibly — not a blanket ban, but a rule that AI-generated code must be clearly labeled and reviewed like any other contribution, because the maintainers refuse to be the free QA layer for models that were trained on their own code. GNOME is working to establish an RFC process — a formal way to make decisions — specifically because they're battling sloppy AI-generated extensions flooding their ecosystem. And then there's Starling, a new Linux desktop built using AI in six months, being covered with the breathless excitement of a tech demo.

And the user's comment on that one is perfect: "seems like 'written by AI' is the next big trending feature after 'written in Rust' lmao." That's the whole industry in one sentence. First it was "written in Rust" — a quality signal, real engineering, memory safety, actually meaningful. Now it's "written by AI" — and it's being marketed the same way, as if being generated by a statistical model trained on everyone else's work is a feature instead of a red flag. Six months to build a desktop. Sure. And how many volunteer years will it take to fix the bugs, audit the generated code, and maintain what the model produced? That cost isn't counted in the demo. It never is.

Here's the extraction mechanism underneath all three of these stories — AUR, GCC, GNOME, Starling, Debian. The AI companies trained their models on open source code. All of it. The commons built by volunteers over thirty years became the free training data for a trillion-dollar industry. Now that industry's output is flooding back into the same repositories, and the maintainers — still volunteers, still unpaid — are expected to review it, fix it, and keep the ecosystem safe. The model extracted value from the commons, and the commons is now paying the cost of the model's output. That's the whole arc of the AI boom in one paragraph: extract the labor, sell it back, and leave the cleanup to the people who did the original work. Debian's five proposals, GCC's sensible ban, GNOME's RFC process — these are communities drawing a line and saying: we built this, we maintain this, and we will not be your free quality control.

And the enclosure attempt is already underway, dressed in patriotic clothing. OpenUK — the UK's open source advocacy body — wants Britain to stop "giving away" open source creations. Their report points out that the Model Context Protocol, the standard now behind how AI models connect to tools and data, was built by two engineers in London and ended up under US-based governance at the Linux Foundation. Their proposal: a British National Foundation that holds code, governance, and standards built with UK public money, instead of watching that work migrate to servers and boards elsewhere. On the surface, that sounds reasonable — national pride in open source, a sovereign tech fund. Underneath, it's the same move every enclosure makes: when something built with public money proves valuable, the response is not to keep it public — it's to build a vehicle to own it. The Linux Foundation, the Sovereign Tech Agency, Open Atom — every country wants its own foundation now, because open source is the infrastructure of the 21st century, and whoever holds the governance holds the power. The commons is valuable. That's why everyone wants to carve it up.

Now let me talk about the stuff that went right this week, because the builders kept building, and the pattern underneath their work is the answer to all of the above.

The kernel moved. The first Arch Linux ISO powered by Linux kernel 7.1 is out. Fedora 45 will enable shadow stack protection by default on 64-bit — a hardware-backed defense that makes a whole class of memory corruption attacks much harder to pull off. That's not a flashy headline, but it's the boring, essential work that keeps the whole thing standing: when the attacks get more sophisticated, the defense gets deeper. New Debian 13 Trixie kernel security updates fixed sixty-eight vulnerabilities — sixty-eight — in one release. Ubuntu 26.04's virtualization HWE stack ships newer QEMU and libvirt. Liquorix kernel 7.1-7 dropped irqbalance to preserve low-latency performance, because for some people a millisecond matters. Fwupd 2.1.7 keeps improving the firmware update layer. GNU Binutils 2.47 adds new RISC-V features, linker improvements, and reproducible builds — meaning you can verify that the binary you're running is really built from the source you're reading. That last one matters more than most people realize: reproducible builds are the defense against exactly the kind of supply chain attack that hit the AUR.

The desktops moved. COSMIC 1.5 is out — System76's Rust-based desktop, now with a wave of improvements, and it's showing up in Gentoo-based MocaccinoOS 26.08 alongside KDE Plasma 6.6.6. KDE Neon shipped a new build, rolling Plasma 6 on top of Ubuntu 24.04. GNOME 50.3 enables remote desktop hardware acceleration for AMD GPUs. Wayfire 0.11, the Wayland compositor, adds better fractional scaling and HDR rendering. Hyprland 0.56.1 came out one week after 0.56.0 with fourteen regression fixes — a project moving fast enough to ship, break, and fix within seven days. And in the "the old world is still alive" corner: YServer 1.4.0, a Rust-native X11 server, finally crossed the threshold into actually usable territory. An X server written in Rust, hitting a usable milestone, in 2026 — that's not nostalgia, that's the future of the past: new engineering capacity applied to the oldest infrastructure we still depend on, because that infrastructure is still everywhere.

The apps moved. Krita 5.3.3 dropped with the first stable Qt 6 port — the painting app that animators and artists rely on, now on modern foundations. Shotcut 26.7 added a graphics adapter for Linux and a shake video filter. Calibre 9.12, the e-book manager, added the option to convert GIF images to JPEG and WebP. Firefox 153.0.1 fixed a batch of issues and crashes. FireDragon swooped in with a new release. Proton Pass improved its autofill. Mission Center added battery, partition, and power draw info to its system monitor. GOverlay 1.8.10 shipped after a one-week sprint of automated testing and polish. Shelly 3.0 — the GUI package manager for Arch — landed as a major update, got a 3.0.1 with polished AUR browsing and tighter Flatpak integration, and then a v3.0.1+1 hotfix just two days after the major Zig rewrite stabilization. And Fooyin 0.12 added audio conversion, three visualization plugins, and native PulseAudio support — which prompted exactly the right comment from one reader: isn't PulseAudio support a bit late? Didn't everyone migrate to PipeWire? And the answer is: no, not everyone. A huge installed base still runs PulseAudio, and supporting them is what free software is for. Choice is the product. That's the whole point.

The self-hosters ate well this week. Immich 3.1 added new filtering options, a wakelock, map date range, and better OAuth integration. Ente Photos added memory reactions, desktop upgrades, and curated sharing controls. Linkwarden 2.16 brought a modernized design, link format re-preservation, and a new search modal. ownCloud Web 12.5.0 added Collabora save-as and a new HTML editor. RomM 5.0 launched with a revamped UI and shareable savestates for the retro game library manager. Every one of those is a brick in the wall of "you don't have to rent your data from a corporation" — photos, links, documents, games, all self-hosted, all owned by the person running the server. That's the quiet counter-revolution: while the platforms enclose, the self-hosters retreat to their own infrastructure and rebuild the commons in miniature.

The hardware moved, and this is genuinely big news disguised as a niche story. The first open-source firmware for a modern AMD Ryzen AM5 platform was released — for the MSI B850 P-WIFI board. Let me say that again slowly: open source firmware for a current-generation AMD motherboard. For years, the firmware layer of your computer — the code that runs before the OS, the code that owns everything — has been a black box, proprietary, untouchable. Coreboot and its successors have been fighting for decades to open that layer, and this is a modern platform with open firmware. That's not a hobbyist curiosity. That's the foundation of actual ownership: if you can't see and control the firmware, you don't own your computer — you're renting it from the vendor and the vendor's supply chain. Keychron also released open source firmware for gaming mice, and Linux users stand to gain the most, because open firmware means the hardware works with your OS instead of requiring vendor software to even function. And GOG — the good old games store — is officially coming to Linux. The store that built its brand on "you own your games" is bringing its catalog to the platform where ownership is the default. That's not charity. That's the market finally admitting what the numbers have shown for years: Linux users buy games, and they buy them more when the store respects them.

And NetBSD 11.0 shipped with RISC-V support and enhanced Linux system call compatibility. NetBSD is the project that runs on everything from toasters to servers, and its new release quietly extends the reach of the free world to a new architecture. RISC-V is the open instruction set — the hardware commons — and every project that supports it is building the alternative to the locked-down chip world. The ecosystem is laying the tracks for a future where the silicon itself doesn't require permission.

Now step back and look at the shape of this week, because the shape is the analysis. On one side: malware exploiting the trust of a volunteer repository. AI output flooding the commons and demanding free review. A surveillance case weaponizing a privacy feature. A national foundation proposing to enclose public code. On the other side: sixty-eight kernel vulnerabilities fixed, shadow stacks enabled by default, reproducible builds, open firmware for modern boards, a store coming to Linux because ownership sells, a desktop environment built in Rust because memory safety matters, a museum-piece X server resurrected in a memory-safe language, self-hosted alternatives getting better every week. The builders built, and the extractors extracted. Same week, same ecosystem, two completely different relationships to the people who use the software.

That's not a coincidence, and it's not a vibe. It's structure. The open source commons is the only corner of the digital world where ordinary people still hold something approximating ownership — where the code is yours to read, the data is yours to host, the firmware is yours to inspect, the community is yours to join. And because it's not owned, no one profits from keeping it safe the way they profit from keeping a subscription service sticky. The malware authors exploit it because trust is free. The AI companies extract from it because the labor was donated. The state weaponizes its tools because privacy threatens control. And when the commons produces something valuable — a protocol, a standard, a foundation — the corporate world moves to enclose it, to own the governance, to hold the keys. That's the pattern under every headline this week. It's not that the good people are winning and the bad people are losing. It's that the commons is the target, because the commons is the only thing left that nobody can bill you for.

The shareholder-first model doesn't care about the commons — it can't. The incentive structure rewards extraction: take the free labor, sell it back, and charge for the cleanup. The volunteer maintainer who reviews your AI-generated pull request for free is doing work that a company would bill you eighty dollars an hour for, and the company gets the model trained on their code, and the cycle repeats. The border agent who treats a duress password as evidence destruction is enforcing the logic of a state that sees encrypted data as a threat by default. The foundation that wants to "rescue" open source from giving itself away is proposing the standard enclosure: public wealth, private governance. This isn't a few bad actors. The whole system is arranged so that the commons loses and the extractors win, and then the extractors sell you the solution to the problem they created.

So what do you actually do with a week like this? Let me give you concrete, practical moves, because the whole point of noticing the pattern is to act on it.

One: if you use Arch and you install from the AUR, learn to read a PKGBUILD. It's a text file. It's short. It's the build recipe for everything you install from the community repo, and it takes ten minutes to learn what each line does. The Atomic Arch attacks worked because people installed without looking. The single most effective security habit in the entire open source world is not a fancy tool — it's looking at what you're about to run before you run it. Check the source URLs, check the maintainer, check whether the package you're installing is a well-known project or an orphaned package that changed hands recently. If a package you've never heard of is suddenly "adopted" and updated aggressively, that's the exact shape of the attack. Free tools that flag this exist — use them, or just use the official repositories, which stayed clean through all three waves.

Two: if you use a smartphone, understand what a duress password is and why the Tunick case matters to you personally. A duress password is a panic feature — you give the agent a password, and what it unlocks is not your real data. The state's position, now endorsed by a federal indictment, is that using that feature is destroying evidence. That means your privacy decisions are now potentially criminal decisions, and you should make them with open eyes. Encrypt your phone. Use a strong passcode. Know that at the border, in the US, agents can and do demand access with no warrant. Decide in advance what you will and won't do under pressure, because the pressure is the point — they count on you not having a plan. And support the organizations and projects that push back on this: GrapheneOS, the EFF, the civil liberties groups that defend the right to encryption.

Three: be deliberate about what you run AI-generated code in. Debian, GCC, and GNOME are all drawing lines — that's the community saying review the output, label the output, don't let the output become unexamined infrastructure. You should do the same. If a project advertises that it was "built by AI in six months," that's not a selling point — that's a warning label telling you the code has had less human review. Treat AI-generated contributions the way you'd treat any code from an unknown contributor: review it, test it, and don't put it in your critical path until it's earned trust. The hype cycle will try to convince you that "written by AI" is the new "written in Rust." It is not. One is a quality signal. The other is a red flag wearing a quality signal's clothes.

Four: self-host something this month. Immich for photos, Ente for secure storage, Linkwarden for bookmarks, ownCloud for documents, RomM for retro games — every one of those projects got better this week, and every one of them puts your data back under your control. You don't need a server rack. A used mini PC or even a Raspberry Pi can run most of them. The point isn't the scale — it's the direction. Every piece of data you stop renting from a corporation is a small act of ownership, and ownership is the thing the extraction model can't stand.

Five: if you can spare a few dollars, give them to a builder. Krita, GNOME, KDE, NetBSD, System76's COSMIC, Servo, the firmware projects — these are the people who did the actual work this week. Sixty-eight vulnerabilities fixed. Shadow stacks enabled. Reproducible builds shipped. Open firmware released. None of that is funded by venture capital. It's funded by donations and the people who give them. A monthly donation to one project you actually use is worth more than any subscription you'll ever pay, because it buys you something the subscription never will: a tool that belongs to you and everyone else, that no one can take away or sell back to you.

Here's the closing thought. Your tools are under attack from every side this week: malware that exploits trust, AI that extracts and floods back, a state that treats your privacy as a crime, and foundations that want to own what you built together. But the same week, the builders shipped open firmware for modern hardware, a store decided to respect Linux users, a Rust X server crossed the finish line, and sixty-eight holes in the kernel got closed. The commons is under siege — but the siege only matters if the people inside the walls don't notice. The system is working exactly as designed. The question is who it's designed for — and whether the people who actually build and use the commons are willing to defend it like it's theirs. Because it is theirs. It's yours. And the only way the extractors win is if you forget that.

── Watch the video ── 🎬 Odysee: https://odysee.com/open-source-under-siege-malware-waves-ai-slop-and-a-privacy-#e9f66ba0176d7c0760f8e0a635bd194f2783652c

Esta semana, el software libre recibió golpes por todos lados a la vez.

Una tercera oleada de malware se apoderó de más de mil novecientos paquetes del Arch User Repository antes de que el proyecto congelara la adopción de paquetes. Un hombre en Atlanta enfrenta cinco años de prisión federal por usar una función de privacidad en su teléfono. Los escritorios más grandes luchan contra una inundación de código generado por IA, mientras el nuevo truco de marketing es anunciar cuánto del producto fue "escrito por IA" en lugar de por personas. Y mientras tanto, los que realmente construyen estas cosas siguieron construyendo: un nuevo escritorio COSMIC, un servidor X nativo en Rust cruzando la línea de meta, GOG llegando oficialmente a Linux, firmware abierto para placas AMD modernas y NetBSD once con soporte RISC-V.

Este es el resumen semanal de noticias de código abierto, y quiero leerlo preguntándome quién gana cuando lo que usas cada día se vuelve un poco menos seguro, un poco más ajeno y un poco menos tuyo.

Empecemos con la historia que debería hacer que cada usuario de Arch se siente a prestar atención. El treinta de julio, Arch deshabilitó la adopción de paquetes en el AUR tras una tercera ola sostenida de tomas maliciosas. La campaña tiene apodo: Atomic Arch. Más de mil novecientos paquetes comprometidos en tres olas desde finales de mayo. Primera ola: los atacantes adoptaron paquetes huérfanos — proyectos abandonados — y colaron comandos de instalación npm en los scripts de compilación. Esos scripts descargaban un ladrón de credenciales en Rust que podía soltar un rootkit eBPF para ocultar sus huellas en el kernel. El equipo purgó los paquetes a mediados de junio y declaró limpio el repositorio. En horas llegó la segunda ola, con descargadores JavaScript ofuscados. Y la tercera ola le da la vuelta al libro de jugadas: binarios ELF compilados incrustados directamente en los scripts de compilación, cargas estáticas que se ejecutan durante la fase de makepkg, evitando la detección que atrapó a las anteriores.

Traduzcamos lo que eso significa, porque los detalles técnicos ocultan la historia verdadera. El AUR es un repositorio comunitario que funciona con confianza: miles de voluntarios empaquetando software, sin equipo de seguridad corporativo. Cuando instalas desde el AUR, confías en que quien escribió el paquete no quiere robar tus contraseñas. Esa confianza es la superficie de ataque. No irrumpieron en los servidores de Arch: adoptaron paquetes huérfanos — el equivalente digital de mudarse a una casa abandonada — y pusieron el malware en las instrucciones de compilación. Tres olas. Meses de trabajo voluntario limpiando un desastre que nadie estaba pagado para limpiar.

Y aquí está la parte sistémica que nadie dirá en voz alta: esto es un bien común abierto bajo asedio. Los repositorios oficiales no fueron tocados, pero la capa comunitaria — la que existe precisamente porque nadie la posee — fue la atacada, porque la confianza es gratis de explotar. Cuando los gigantes hablan de "seguridad de la cadena de suministro del código abierto", quieren decir: tu trabajo no remunerado es nuestro control de calidad gratuito, y si falla, te venderemos un producto para arreglarlo.

La segunda historia debería hacerte enojar de verdad. Una función de privacidad de GrapheneOS se convirtió en la base de una acusación federal. Samuel Tunick, de Atlanta, enfrenta hasta cinco años de prisión. El cargo: destrucción de propiedad para impedir el decomiso gubernamental. La "destrucción" fue que su teléfono se borrara solo tras entregar una contraseña de pánico — una función diseñada exactamente para este escenario. En enero, la Patrulla Fronteriza lo puso en inspección secundaria en Atlanta al volver de República Dominicana. Los agentes exigieron la contraseña de su teléfono, con el pretexto de buscar material de abuso infantil. Pidió un abogado varias veces. Lo ignoraron. Nunca le leyeron sus derechos. Cuando protestó, le dijeron que en la frontera "el juego es diferente" y que no necesitaban orden judicial. Finalmente entregó una contraseña. En el momento de ingresarla, el teléfono se reinició y su contenido se borró frente a los mismos agentes. La contraseña de pánico funcionó exactamente como fue diseñada.

Y la respuesta del estado a una función de privacidad que funciona es acusar al hombre que la usó. Cinco años. La moción de su abogado subraya que su verdadero crimen, a los ojos de los agentes, era su asociación con Defend the Atlanta Forest, un grupo que lucha contra un centro de entrenamiento policial. Seamos claros: un activista, marcado por su organización, es detenido sin orden judicial, se le niega un abogado, se le presiona para entregar una contraseña, y cuando la función de privacidad hace lo que fue construida para hacer, el estado lo acusa de un delito federal.

Este es el patrón. El mismo del caso Epstein: había pruebas reales, documentación real, víctimas reales, y la gente poderosa de esa órbita caminó libre. Las élites pueden hacer lo que quieran. La gente común siempre es la atacada. El estado de vigilancia no va tras quienes poseen la infraestructura; va tras quienes podrían desafiarlos. Una contraseña de pánico es una herramienta para que una persona bajo coacción entregue algo que parece todo mientras protege lo que importa. Y en cuanto se usa, el estado la llama destrucción de pruebas. Si una función que protege tus datos bajo coacción ahora es un crimen, entonces la privacidad misma es el crimen.

Y mira al ecosistema reaccionando en tiempo real. Windscribe acaba de lanzar deGDID, una herramienta para bloquear el identificador de seguimiento que Microsoft incrusta en Windows: una empresa VPN envía una herramienta gratuita para quitar la vigilancia del sistema operativo, porque el fabricante no va a parar. Cuando la herramienta que te protege se convierte en la evidencia contra ti, pregúntate: ¿de qué lado está el sistema?

Tercer hilo, con un borde oscuramente cómico. La fiebre del oro de la IA llegó a los mantenedores de código abierto, y no están impresionados. Debian vota cinco propuestas sobre el uso de LLM — desde prohibir contribuciones generadas por IA hasta aceptarlas con pragmatismo. GNU GCC, uno de los compiladores más importantes que existen, prohibió el código IA, pero con sensatez: que esté etiquetado y revisado como cualquier contribución, porque los mantenedores se niegan a ser el control de calidad gratuito de modelos entrenados con su propio código. GNOME trabaja en un proceso RFC para luchar contra las extensiones generadas por IA. Y luego está Starling, un escritorio Linux construido con IA en seis meses, cubierto con la emoción de una demostración tecnológica.

El comentario de un lector lo resume: "parece que 'escrito por IA' es la próxima gran característica de moda después de 'escrito en Rust'". Primero fue "escrito en Rust" — una señal de calidad real, seguridad de memoria, significativo. Ahora es "escrito por IA" — comercializado igual, como si ser generado por un modelo entrenado con el trabajo de todos fuera una característica y no una bandera roja. Seis meses para construir un escritorio. ¿Y cuántos años de voluntariado tomará arreglar lo que el modelo produjo? Ese costo no se cuenta en la demostración.

Aquí está el mecanismo debajo de estas historias — AUR, GCC, GNOME, Starling, Debian. Las empresas de IA entrenaron sus modelos con código abierto. Todo. Los bienes comunes construidos por voluntarios durante treinta años se volvieron los datos gratuitos de una industria de billones. Ahora su producción inunda los mismos repositorios, y los mantenedores — voluntarios, no remunerados — deben revisarla y mantener seguro el ecosistema. El modelo extrajo valor de los bienes comunes, y los bienes comunes pagan el costo de la producción del modelo. Todo el arco del auge de la IA en un párrafo: extrae el trabajo, véndelo de vuelta, deja la limpieza a quienes hicieron el trabajo original.

Y el cercamiento ya está en marcha, con ropa patriótica. OpenUK quiere que Reino Unido deje de "regalar" creaciones de código abierto. Su informe señala que el Model Context Protocol, el estándar detrás de cómo los modelos de IA se conectan a herramientas, fue construido por dos ingenieros en Londres y terminó bajo gobernanza estadounidense en la Linux Foundation. Proponen una Fundación Nacional británica que tenga código, gobernanza y estándares construidos con dinero público. En la superficie suena razonable. Debajo, es el movimiento de todo cercamiento: cuando algo construido con dinero público demuestra valor, la respuesta no es mantenerlo público — es construir un vehículo para poseerlo. Quien tiene la gobernanza tiene el poder.

Ahora lo que salió bien esta semana, porque los constructores siguieron construyendo, y el patrón debajo de su trabajo es la respuesta a todo lo anterior.

El kernel se movió. La primera ISO de Arch con el kernel Linux 7.1 ya está disponible. Fedora 45 habilitará la protección de shadow stack por defecto en 64 bits — una defensa de hardware que hace mucho más difícil una clase entera de ataques. No es un titular llamativo, pero es el trabajo aburrido y esencial: cuando los ataques se sofistican, la defensa se profundiza. Las actualizaciones de seguridad del kernel de Debian 13 Trixie arreglaron sesenta y ocho vulnerabilidades en una sola versión. La pila HWE de virtualización de Ubuntu 26.04 trae QEMU y libvirt más nuevos. Fwupd 2.1.7 mejora la capa de firmware. GNU Binutils 2.47 agrega características RISC-V, mejoras al enlazador y compilaciones reproducibles — puedes verificar que el binario que ejecutas realmente viene del código que lees. Eso importa más de lo que crees: es la defensa contra exactamente el ataque que golpeó al AUR.

Los escritorios se movieron. COSMIC 1.5 ya está disponible — el escritorio en Rust de System76 — y aparece en MocaccinoOS 26.08 junto a KDE Plasma 6.6.6. KDE Neon lanzó una nueva compilación, Plasma 6 rodante sobre Ubuntu 24.04. GNOME 50.3 habilita aceleración de hardware de escritorio remoto para GPUs AMD. Wayfire 0.11 agrega mejor escalado fraccional y renderizado HDR. Hyprland 0.56.1 salió una semana después de 0.56.0 con catorce correcciones de regresión. Y en el rincón del viejo mundo: YServer 1.4.0, un servidor X nativo en Rust, cruzó el umbral de lo usable. Un servidor X en Rust en 2026 no es nostalgia; es nueva ingeniería aplicada a la infraestructura más antigua de la que aún dependemos.

Las aplicaciones se movieron. Krita 5.3.3 salió con el primer port estable de Qt 6. Shotcut 26.7 agregó un adaptador gráfico para Linux y un filtro de video shake. Calibre 9.12 convierte GIF a JPEG y WebP. Firefox 153.0.1 arregló un lote de fallos. FireDragon llegó con nueva versión. Proton Pass mejoró su autocompletado. Mission Center agregó batería, particiones y consumo de energía. GOverlay 1.8.10 salió tras una semana de pruebas automatizadas. Shelly 3.0, el gestor gráfico de paquetes para Arch, llegó como gran actualización, y luego un hotfix dos días después del reescrito en Zig. Y Fooyin 0.12 agregó conversión de audio y soporte nativo de PulseAudio — lo que provocó el comentario correcto de un lector: ¿no es un poco tarde? ¿No migró todo el mundo a PipeWire? La respuesta: no todo el mundo. Una base enorme todavía usa PulseAudio, y apoyarlos es para lo que sirve el software libre.

Los autoalojadores comieron bien. Immich 3.1 agregó filtros, wakelock, rango de fechas en el mapa y mejor OAuth. Ente Photos agregó reacciones de memoria y controles de compartir curados. Linkwarden 2.16 trajo diseño modernizado y nuevo buscador. ownCloud Web 12.5.0 agregó guardar-como en Collabora. RomM 5.0 se lanzó con interfaz renovada y savestates compartibles. Cada uno es un ladrillo en el muro de "no tienes que alquilar tus datos a una corporación". Esa es la contrarrevolución silenciosa: mientras las plataformas cercan, los autoalojadores reconstruyen los bienes comunes en miniatura.

El hardware se movió, y esto es noticia grande disfrazada de nicho. Se lanzó el primer firmware de código abierto para una plataforma AMD Ryzen AM5 moderna — la placa MSI B850 P-WIFI. Durante años, la capa de firmware — el código que se ejecuta antes del sistema operativo, el que lo posee todo — ha sido una caja negra propietaria. Coreboot ha luchado décadas para abrir esa capa, y esta es una plataforma moderna con firmware abierto. Eso es el fundamento de la propiedad real: si no puedes ver y controlar el firmware, no eres dueño de tu computadora — la alquilas al vendedor. Keychron también lanzó firmware abierto para ratones de juegos, y los usuarios de Linux ganan más, porque el hardware funciona con tu sistema sin depender del software del vendedor. Y GOG — la tienda de "tú eres dueño de tus juegos" — llega oficialmente a Linux. No es caridad: es el mercado admitiendo que los usuarios de Linux compran juegos, y más cuando la tienda los respeta.

Y NetBSD 11.0 llegó con soporte RISC-V y compatibilidad mejorada con llamadas al sistema de Linux. RISC-V es el conjunto de instrucciones abierto — los bienes comunes del hardware — y cada proyecto que lo soporta construye la alternativa al mundo de chips cerrados.

Da un paso atrás y mira la forma de esta semana, porque la forma es el análisis. De un lado: malware explotando la confianza de un repositorio de voluntarios. Producción de IA inundando los bienes comunes y exigiendo revisión gratuita. Un caso de vigilancia armando un arma con una función de privacidad. Una fundación nacional proponiendo cercar el código público. Del otro: sesenta y ocho vulnerabilidades arregladas, shadow stacks por defecto, compilaciones reproducibles, firmware abierto, una tienda viniendo a Linux porque la propiedad vende, un servidor X resucitado en un lenguaje seguro, alternativas autoalojadas mejorando cada semana. Los constructores construyeron, y los extractores extrajeron. Misma semana, mismo ecosistema, dos relaciones opuestas con la gente que usa el software.

Eso no es coincidencia. Es estructura. Los bienes comunes del código abierto son el único rincón del mundo digital donde la gente común todavía posee algo: el código es tuyo para leer, los datos tuyos para alojar, el firmware tuyo para inspeccionar, la comunidad tuya para unirte. Y porque no es de nadie, nadie se beneficia de mantenerlo seguro como se benefician de mantener pegajosa una suscripción. Los autores de malware lo explotan porque la confianza es gratis. Las empresas de IA extraen de él porque el trabajo fue donado. El estado arma sus herramientas porque la privacidad amenaza el control. Y cuando los bienes comunes producen algo valioso, el mundo corporativo se mueve para cercarlo. Los bienes comunes son el objetivo porque son lo único que nadie puede facturarte.

El modelo que prioriza al accionista no puede importarle los bienes comunes. La estructura de incentivos recompensa la extracción: toma el trabajo gratuito, véndelo de vuelta, cobra por la limpieza. El mantenedor voluntario que revisa tu pull request de IA gratis hace trabajo que una empresa facturaría a ochenta dólares la hora. El agente fronterizo que trata una contraseña de pánico como destrucción de pruebas aplica la lógica de un estado que ve los datos cifrados como amenaza por defecto. No es un puñado de malos actores. Todo el sistema está organizado para que los bienes comunes pierdan y los extractores ganen, y luego los extractores te venden la solución al problema que crearon.

Entonces, ¿qué haces con una semana así? Movimientos concretos, porque notar el patrón sirve para actuar.

Uno: si usas Arch e instalas desde el AUR, aprende a leer un PKGBUILD. Es un archivo de texto corto, la receta de compilación de todo lo que instalas del repositorio comunitario. Toma diez minutos aprender qué hace cada línea. Los ataques de Atomic Arch funcionaron porque la gente instalaba sin mirar. El hábito de seguridad más efectivo no es una herramienta elegante — es mirar lo que vas a ejecutar antes de ejecutarlo. Revisa las URLs de origen, revisa al mantenedor, sospecha de paquetes huérfanos "adoptados" y actualizados agresivamente. Usa los repositorios oficiales, que se mantuvieron limpios en las tres olas.

Dos: entiende qué es una contraseña de pánico y por qué el caso Tunick te importa. La posición del estado, respaldada por una acusación federal, es que usar esa función es destruir pruebas. Tus decisiones de privacidad ahora son potencialmente decisiones criminales, y debes tomarlas con los ojos abiertos. Cifra tu teléfono. Usa contraseña fuerte. Sabe que en la frontera los agentes exigen acceso sin orden judicial. Decide de antemano qué harás bajo presión, porque la presión es el punto — cuentan con que no tengas plan. Apoya a quienes empujan contra esto: GrapheneOS, la EFF, los grupos que defienden el derecho al cifrado.

Tres: sé deliberado con el código generado por IA. Debian, GCC y GNOME trazan líneas: revisa la producción, etiquétala, no la dejes convertirse en infraestructura no examinada. Haz lo mismo. Si un proyecto anuncia que fue "construido por IA en seis meses", eso es una etiqueta de advertencia: el código tuvo menos revisión humana. Trátalo como código de un colaborador desconocido: revísalo, pruébalo, no lo pongas en tu camino crítico hasta que gane confianza. "Escrito por IA" no es el nuevo "escrito en Rust". Una es señal de calidad. La otra es una bandera roja.

Cuatro: autoaloja algo este mes. Immich para fotos, Ente para almacenamiento seguro, Linkwarden para marcadores, ownCloud para documentos, RomM para juegos retro. Cada uno mejoró esta semana, y cada uno pone tus datos bajo tu control. Una mini PC usada basta. El punto no es la escala — es la dirección: cada dato que dejas de alquilar es un pequeño acto de propiedad, y la propiedad es lo que el modelo de extracción no soporta.

Cinco: si puedes ahorrar unos dólares, dáselos a un constructor. Krita, GNOME, KDE, NetBSD, COSMIC, Servo, los proyectos de firmware: la gente que hizo el trabajo real esta semana. Nada de eso lo financia el capital de riesgo. Lo financian las donaciones. Una donación mensual a un proyecto que usas vale más que cualquier suscripción, porque te compra algo que la suscripción nunca dará: una herramienta que te pertenece a ti y a todos, que nadie puede quitarte.

Aquí está el pensamiento final. Tus herramientas están bajo ataque por todos lados esta semana: malware que explota la confianza, IA que extrae e inunda, un estado que trata tu privacidad como crimen y fundaciones que quieren poseer lo que construiste juntos. Pero la misma semana, los constructores enviaron firmware abierto para hardware moderno, una tienda decidió respetar a los usuarios de Linux, un servidor X en Rust cruzó la línea de meta y sesenta y ocho agujeros en el kernel fueron cerrados. El asedio solo importa si la gente dentro de las murallas no se da cuenta. El sistema está funcionando exactamente como fue diseñado. La pregunta es para quién — y si quienes construyen y usan los bienes comunes están dispuestos a defenderlos como suyos. Porque lo son. Son tuyos. Y los extractores solo ganan si lo olvidas.

── Ver el video ── 🎬 Odysee: https://odysee.com/software-libre-bajo-asedio-oleadas-de-malware-ia-de-relleno-#8dc89e3202bde6d569886b56dada9b9c2b3b4014

Mira tu último recibe del supermercado. Ahora acuérdate del de hace cuatro años. El mismo carro, la misma tienda, las mismas marcas. El número de abajo subió entre un treinta y un sesenta por ciento. Tu sueldo no. El alquiler hizo lo mismo. El seguro hizo lo mismo. La matrícula de tus hijos hizo lo mismo.

Y aquí viene la parte que nadie dice en voz alta. Todo eso pasó después de que ganáramos. Después de que ganaran los buenos. Después de que al mundo entero se le dijera que la discusión estaba cerrada, que la competencia había terminado, y que el modelo ganador se instalaría en todas partes, para siempre, en tu beneficio.

Entonces la pregunta obvia es esta: si nuestro bando ganó, ¿por qué tu vida se siente como una derrota?

Esa pregunta es todo el video. Y quiero responderla con un libro que casi nadie ha leído, escrito por un profesor de finanzas de una escuela de negocios en Michigan, publicado en el año 2000, que se llama El Triunfo del Mal. Austin Murphy no es un militante de la calle. Da clases de finanzas corporativas. Construye modelos de valoración. Vivió años en Alemania justo en el periodo en que cayó el Muro de Berlín, lo vio desde dentro, y después hizo lo que hacen los profesores de finanzas: corrió los números.

Y los números no dijeron lo que él esperaba.

Lo primero que hay que entender es esto. Cuando te dicen que un sistema "fracasó", te están diciendo algo sobre resultados. Fracasar significa que no entregó. Así que vamos a mirar qué se entregó, usando las fuentes aburridas. El Fondo Monetario Internacional. Los anuarios estadísticos de la ONU. Las cuentas nacionales. No panfletos: los mismos datos que usa el que gestiona tu pensión.

Entre 1946 y 1989, la tasa media de crecimiento real de Europa del Este fue superior a la de Europa Occidental. No en la propaganda: en los datos del FMI. Incluso en los años ochenta, la década que todos recuerdan como la fase terminal y gris, el crecimiento del Este siguió por encima del de Europa Occidental y por encima del de Estados Unidos. La producción por persona en Rusia pasó de cerca del diez por ciento del nivel estadounidense en 1913 a alrededor del treinta y uno por ciento en 1991. Cerró la brecha por un factor de tres. Y lo hizo absorbiendo una invasión de más de una docena de países en sus primeros veinticinco años, una guerra civil que redujo la producción casi a la mitad, y una invasión nazi que borró otro veinte por ciento y mató a decenas de millones de personas.

Después se retiró el sistema. Y entre 1991 y 1996 la producción rusa cayó cerca de la mitad. La mitad. En cinco años. Sin guerra, sin invasión, sin sequía. Solo cambió quién era el dueño de las cosas.

Quédate con ese número, porque nunca te lo dieron. Un derrumbe del cincuenta por ciento en tiempos de paz no es una transición difícil. Es una de las catástrofes económicas más grandes jamás registradas. Europa del Este en conjunto perdió más del treinta por ciento de su producción real en los años noventa. La esperanza de vida en Rusia se desplomó. Los hombres morían más jóvenes en 1995 que sus padres en 1975. Eso no es una estadística sobre ideología. Es una estadística sobre funerales.

Si eso hubiera ocurrido bajo el sistema perdedor, te sabrías la cifra de memoria. Estaría en todos los libros de texto. Ocurrió bajo el sistema ganador, así que desapareció.

Segundo punto. Murphy dedica la mayor parte del libro a Alemania, y Alemania es el caso perfecto, porque es lo más cerca que las ciencias sociales llegan de un laboratorio. Una nación. Un idioma. Una cultura. La misma ética de trabajo, si crees en eso. Partida por la mitad en 1949 y gestionada de dos maneras distintas durante cuarenta años.

La historia estándar es simple: el Oeste se hizo rico, el Este se quedó pobre, luego el modelo occidental funciona y el otro no. Caso cerrado.

Solo que las dos mitades no salieron de la misma línea. Murphy repasa las reparaciones. Tras la Segunda Guerra Mundial, Alemania Oriental pagó a la Unión Soviética una factura enorme por el daño que Alemania en su conjunto había causado: fábricas desmontadas y enviadas al este, producción confiscada, transferencias de bienes. El total equivalía a varias veces toda la producción anual de Alemania Oriental. Alemania Occidental no pagó prácticamente nada de eso. Al contrario: recibió ayuda financiera sustancial de Estados Unidos, un país que salió de la guerra con sus fábricas intactas y su territorio sin bombardear.

Es decir: un gemelo empieza la carrera cargando una deuda que vale varios años de todo lo que produce, y el otro empieza con un subsidio de la economía más rica del planeta. Cuarenta años después el segundo es más rico, y eso te lo presentan como prueba de qué sistema económico es más eficiente.

Eso no es un experimento. Es una moneda trucada presentada como hallazgo científico.

¿Y qué encontró Murphy al corregir por la línea de salida? Que Alemania Oriental no solo sobrevivió a esa desventaja: cerró buena parte de la brecha. Creciendo más rápido, desde muy atrás, mientras pagaba. Es exactamente lo contrario de la historia de ineficiencia que te vendieron.

Y luego el Oeste hizo algo que el relato nunca menciona: ejecutó una campaña económica activa contra el Este. Manipulación de la moneda para que el marco oriental pareciera papel mojado. Restricciones comerciales. Reclutamiento de trabajadores cualificados —médicos, ingenieros, técnicos, formados a costa del Este— atraídos al Oeste con bonos en efectivo, vivienda garantizada y créditos subvencionados. Murphy documenta pagos que lo convertían básicamente en un traslado remunerado. Piensa qué le hace eso a un país. Inviertes una década y una fortuna en formar a una cirujana, y tu vecino le ofrece una prima por marcharse. Hazlo miles de veces al año durante treinta años y no has observado una economía fracasando. Has visto cómo la vacían.

Esa es la jugada analítica central del libro. No dice que el Este fuera un paraíso. Murphy es explícito: la escasez era real, las colas eran reales, la vigilancia era real, y la gente estaba genuinamente furiosa por todo eso. Su tesis es más estrecha y mucho más difícil de descartar: el colapso no lo causó el fracaso económico, porque no hubo fracaso económico. La gente no se rebelaba contra un sistema que la empobrecía. Se rebelaba contra ser más pobre que la gente del otro lado del muro, y le habían dicho constantemente, con la operación de radiodifusión más sofisticada de la historia, que la causa de esa diferencia era el sistema. No las reparaciones, no la destrucción de la guerra, no la ayuda, no la fuga de cerebros comprada.

Les vendieron una explicación de por qué iban por detrás. La compraron. Y luego les llegó la factura.

Porque lo que pasó después debería importarle a cualquiera al que le hayan prometido que una fusión, una privatización o una reestructuración le va a mejorar la vida. Los alemanes orientales votaron, en 1990, por la versión rápida. Unión monetaria inmediata. Integración inmediata. Hacerse ricos ya.

Lo que recibieron fue el mayor acto de desindustrialización de la Europa moderna. La conversión monetaria, fijada por razones políticas y no económicas, dejó a todas las fábricas del Este fuera de competencia de la noche a la mañana: mismos salarios, moneda nueva, cero transición. Se creó una agencia para vender la industria oriental, y la vendió, casi toda a compradores occidentales, muchas veces por un precio simbólico, con frecuencia a competidores que compraban un rival para cerrarlo. El paro pasó de casi cero oficial a dos dígitos y se quedó ahí una generación. Alemania Occidental volcó después más de cien mil millones de dólares al año hacia el este, aproximadamente la mitad de toda la producción de Alemania Oriental antes de 1989, cada año, y la región siguió siendo un paciente económico permanente, dependiente de transferencias para sostener un mínimo. La gente siguió marchándose a más de diez mil al mes ya entrados los noventa. Casi un millón viajaba al oeste a trabajar.

Les prometieron prosperidad. Recibieron un subsidio permanente y un pueblo vacío. Si vives en cualquier sitio donde cerró la fábrica, esta historia ya la conoces en el cuerpo. Solo que no sabías que era la misma historia.

Antes de seguir, quiero atender la objeción que ya estás formulando, porque es legítima. ¿Y la represión? ¿Y la policía secreta? ¿Y el muro, que existía para que la gente no saliera?

Murphy no la esquiva. El aparato de vigilancia de Alemania Oriental era enorme y arruinó vidas. Las restricciones de viaje eran reales y la gente las odiaba, y odiarlas era razonable. Lo que él hace es algo más útil que defenderlo: te pide aplicar la misma vara a los dos lados a la vez, que es lo único que nunca te invitan a hacer.

Entonces: el país que ganó la Guerra Fría encierra a más porcentaje de su propia población que cualquier otra nación del planeta. Alrededor de cinco veces la media mundial. Millones de personas, desproporcionadamente de comunidades que fueron esclavizadas hace apenas unas generaciones. Eso no es una nota histórica de los ochenta; es la situación de hoy, en el país que se presenta como la mitad libre de la comparación.

Nada de eso hace aceptable a la Stasi. Ese no es el argumento. El argumento es que "qué sistema era más represivo" es una pregunta que solo te han dejado hacer en una dirección. Te entregaron una contabilidad detallada de los abusos de un bando y una página en blanco para el otro. Y cuando la contabilidad es unilateral, la conclusión estaba decidida antes de empezar a contar.

Hay otro capítulo que tengo que mencionar, porque es el que separa este libro de una queja. En el capítulo cinco Murphy hace literalmente su trabajo: construye un modelo de lo que Alemania Oriental pudo haber hecho en 1989. Mantener la frontera abierta, porque la gente la quería abierta. Mantener una moneda propia en vez del tipo de cambio político que destruyó la base industrial. Gestionar el tipo de cambio. Priorizar la inversión. Y hace el análisis de sensibilidad como en cualquier valoración: qué pasa si cambia la tasa de ahorro, si las importaciones se disparan, si aparece un mercado negro, si llega menos inversión occidental de la prevista.

Y el modelo dice que la economía sobrevive. No una utopía: supervivencia, con nivel de vida creciente y sin treinta años de dependencia de transferencias.

Creas o no en su modelo, lo importante es lo que su existencia demuestra: hubo una elección. Lo que pasó en 1990 no era la única puerta del edificio. Y que nunca hayas oído que existía una alternativa es precisamente el punto. Cuando algo se te presenta como inevitable —la única opción seria, no hay alternativa— ese marco casi siempre está trabajando para alguien.

Ahora la parte que convierte esto en algo más que una clase de historia, porque 1990 no me importa. Me importa tu alquiler.

El capítulo seis trata de lo que la victoria le hizo al resto del mundo, y ahí el libro deja de ir de Alemania y empieza a ir de ti. Cuando desapareció la competencia, desapareció la presión.

Piensa qué contuvo realmente a los de arriba en Occidente durante cuarenta años. No fue su conciencia. Fue la existencia de una alternativa. Cuando hay un sistema rival en el mapa que dice que puede dar vivienda, sanidad, guarderías y empleo estable, y se lo dice en voz alta a tus propios trabajadores, tienes que responder. Tienes que ofrecer algo. Las décadas de posguerra en Occidente —sindicatos fuertes, salarios reales al alza, vivienda pública, sanidad universal en casi todo el mundo desarrollado, pensiones que de verdad pagaban, universidad al alcance de familias normales— ese paquete no fue generosidad. Fue una contraoferta. Fue el precio de que la gente no mirara al otro lado de la valla.

Quita la valla y la contraoferta caduca.

Mira la cronología. Los salarios reales dejaron de seguir a la productividad hacia los años setenta y nunca se reconectaron. Pero la aceleración llega después de 1990. La afiliación sindical privada se hunde. Las pensiones garantizadas se cambian por cuentas donde el riesgo de mercado lo cargas tú. Se para la construcción de vivienda pública. Se recorta la financiación universitaria y se sustituye por deuda que firmas a los diecisiete. La edad de jubilación sube en todas partes. Categorías enteras de trabajo se reclasifican para que quien las hace técnicamente no sea empleado y por tanto no se le deba nada.

Nada de eso fue secreto. Todo se anunció como modernización, flexibilidad, reforma, competitividad. Y todas esas palabras significaban lo mismo: la contraoferta se retira, porque no tienes a dónde ir.

Y aquí está la pieza que debería pararte en seco. Justo aquello de lo que el bando ganador se burló durante cuarenta años —vivienda garantizada, empleo garantizado, guarderías subvencionadas, educación gratuita, sanidad gratuita, precios controlados en alimentos básicos— lee esa lista otra vez, despacio. Cada uno de esos puntos es hoy una demanda política mayoritaria en todos los países ricos. Control de alquileres. Ayudas a la crianza. Universidad accesible. Cancelar la deuda estudiantil. Sanidad pública. Leyes contra la especulación con el precio de la comida.

Nos pasamos una generación oyendo que eso eran los rasgos de un sistema fracasado. Ahora es lo que la gente le suplica a sus gobiernos. Nadie lo nota, porque llega como quejas de consumidor separadas en vez de como una sola lista coherente.

Murphy también dedica tiempo serio a las crisis de divisas, y ese es el corazón técnico del libro. Cuando el capital pudo moverse a cualquier sitio al instante y se presionó a todos los países a abrirse, llegó la cascada: México en 1994, Asia en 1997, Rusia en 1998, y así. El patrón siempre es idéntico. El dinero entra a raudales mientras la cosa pinta bien. Algo lo asusta. El dinero sale en una semana. La moneda se hunde. Y entonces llega el remedio, y el remedio siempre es el mismo: subir tipos, recortar gasto, vender activos baratos a compradores extranjeros, y una caída de la renta real de la población lo bastante grande como para cuadrar las cuentas exteriores.

Esa última parte merece lenguaje claro. "Ajuste externo" significa que la población se empobrece a propósito, por diseño, como mecanismo. Se recortan los salarios de un país para dejar enteros a sus acreedores. Eso no es un efecto secundario desafortunado del rescate: eso es el rescate.

Y ahora la capa que quiero dejarte en la cabeza, porque es más grande que cualquiera de los números.

Nada de esto requirió una conspiración. No hubo una reunión. Nadie tuvo que ser malvado en el sentido de dibujos animados.

Cuando el modelo que pone al accionista primero se queda sin competidor externo, hace exactamente aquello para lo que está construido —maximizar el retorno de los propietarios— y lo hace sin frenos. Los frenos nunca fueron internos. No hay nada dentro de un objetivo trimestral de beneficios al que le importe tu alquiler. Los frenos eran externos: trabajadores organizados capaces de parar la producción, un sistema rival que hacía las concesiones estratégicamente necesarias, y gobiernos lo bastante asustados como para regular. Quita los tres y no obtienes corrupción: obtienes la máquina funcionando a velocidad de diseño por primera vez.

Por eso esto se repite en sectores que no tienen nada que ver entre sí. Tu plataforma de streaming empeora y sube. El asiento del avión encoge. El electrodoméstico se rompe a los seis años en vez de a los veinticinco. Tu médico tiene once minutos. El paquete del supermercado adelgaza. Parecen mil molestias inconexas. Son una sola cosa. Son lo que hace un modelo de extracción cuando nada externo lo limita.

Los hilos no los mueve una persona. Los mueve una estructura de incentivos que se quedó sin contrapeso. Y "quitamos el contrapeso y lo llamamos victoria" es una frase mucho más inquietante que cualquier teoría de la conspiración, porque a una estructura de incentivos no puedes despedirla.

Entonces, ¿qué haces con esto? No una revolución: el propio Murphy, al final de un libro que sostiene que ganó el bando equivocado, dice que la salida es votarlo fuera. Eso te dice lo modesta que es la petición.

La versión honesta, pequeña y real es esta.

Primero: averigua quién es el dueño de lo que te aprieta. En concreto. Busca quién es el propietario de tu edificio, no la gestora, la sociedad de detrás. Busca quién es el dueño de tu red hospitalaria. Busca qué fondo compró la clínica veterinaria, la dental, el periódico local. Son veinte minutos y es información pública. Siempre aparecen los mismos pocos nombres, y en cuanto puedes nombrarlos, la subida deja de parecer clima y empieza a parecer una decisión que alguien tomó.

Segundo: reconstruye un contrapeso donde tú estás. No en teoría. Una asociación de vecinos en tu edificio. Una afiliación sindical en tu trabajo, aunque digan que ahí es imposible. Una cooperativa local. Aparecer en la única reunión pública al año donde la dirección del hospital o la junta de urbanismo tiene que sentarse a escuchar. No es glamuroso y funciona exactamente por lo que demuestran estos cuarenta años: este sistema solo cede cuando algo lo obliga. No tiene otro modo.

Tercero: cuando alguien te diga que una solución de mercado va a arreglar algo que rompió el mercado, pídele los recibos de Alemania Oriental. Pregunta qué le pasó a la última población a la que le prometieron prosperidad rápida vía reestructuración. La respuesta está registrada, en datos del FMI, y es un derrumbe del cincuenta por ciento y una generación de transferencias.

Y cuarto, el más barato: deja de tratar tus facturas como problemas separados. El alquiler, el seguro, la tarifa del móvil, la guardería, el veterinario, las suscripciones, el paquete que encoge. Te han entrenado para vivir cada una como un fallo personal de presupuesto que gestionas solo, en silencio y con algo de vergüenza. No son cosas separadas. Son un mismo proceso llegando a tu puerta por once buzones distintos. En el momento en que lo dices en voz alta y otra persona responde "a mí también", se rompe el aislamiento, y el aislamiento es lo único que mantiene esto estable.

Vuelve al recibo que llevas en el bolsillo. Ese donde el mismo carro cuesta la mitad más que hace cuatro años.

Te dijeron, cuando cayó el muro, que la discusión había terminado y que el sistema ganador te iba a dar una vida mejor sin que nadie tuviera que pelear por ella. Tres décadas después trabajas más horas con menos seguridad, en un piso más pequeño, con una factura más grande, y cada institución por encima de ti te dice que esto es normal y probablemente culpa tuya.

No es culpa tuya y no es clima. Lo que les obligaba a ofrecerte un trato mejor dejó de existir, así que dejaron de ofrecerlo. Ese es todo el truco. La Guerra Fría no terminó con la victoria de los buenos. Terminó con la retirada de lo último que podía obligar a alguien a negociar contigo, y treinta años de tu nómina son el recibo.

── Ver el video ── 🎬 Odysee: https://odysee.com/la-estafa-de-la-guerra-fria-por-que-ganar-empeoro-tu-vida#62c6503dbbea88f15a39edf2e9a52345cbe0f4d2

Check your last grocery receipt. Then check the one from four years ago, if you still have it. Same cart, same store, same brands. The number at the bottom went up somewhere between thirty and sixty percent. Your paycheck did not. Your rent did the same thing. Your insurance premium did the same thing. Your kid's tuition did the same thing.

Now here is the part nobody says out loud. All of that happened after we won. After the good guys won. After the whole world was told that the argument was settled, the competition was over, and the winning model would now be installed everywhere, forever, for your benefit.

So let me ask the obvious question. If our side won, why does your life feel like you lost?

That question is the whole video. And I want to answer it with a book almost nobody has read, written by a finance professor at a business school in Michigan, published in 2000, called The Triumph of Evil. Austin Murphy is not a street protester. He teaches corporate finance. He builds valuation models. He spent years living in Germany during the exact period the Berlin Wall came down, watching it happen from inside, and then he did what finance professors do. He ran the numbers.

And the numbers did not say what he expected them to say.

Here is the first thing to understand. When you are told a system "failed," you are being told something about outcomes. Failure means it did not deliver. So let us actually look at what got delivered, using the boring sources. The International Monetary Fund. United Nations statistical yearbooks. Government output accounts. Not pamphlets. The same data your pension fund manager uses.

Between 1946 and 1989, Eastern Europe's average real economic growth rate ran higher than Western Europe's. Not in the propaganda. In the IMF numbers. Even in the 1980s, the decade everybody remembers as the sad grey terminal phase, Eastern Europe's growth still came in above Western Europe's and above the United States. Russian output per person went from roughly ten percent of the American level in 1913 to about thirty-one percent by 1991. It closed the gap by a factor of three. It did that while absorbing an invasion by more than a dozen countries in its first twenty-five years, a civil war that cut output roughly in half, and a Nazi invasion that erased another twenty percent and killed tens of millions of people.

Then the system was removed. And between 1991 and 1996, Russian output fell by about half. Half. In five years. No war, no invasion, no famine caused by weather. Just a change in who owned things.

Sit with that number, because you have never been given it. A fifty percent collapse in national output during peacetime is not a rough transition. It is one of the largest economic catastrophes ever recorded anywhere. Eastern Europe as a whole lost over thirty percent of real output in the 1990s. Life expectancy in Russia fell off a cliff. Men in Russia were dying younger in 1995 than their fathers had in 1975. That is not a statistic about ideology. That is a statistic about funerals.

If that had happened under the losing system, you would know the number by heart. It would be in every textbook. It happened under the winning system, so it disappeared.

Now, the second thing. Murphy spends most of the book on Germany, and Germany is the perfect case, because it is the closest thing social science ever gets to a laboratory. One nation. One language. One culture. One work ethic, if you believe in that sort of thing. Split down the middle in 1949 and run two different ways for forty years.

The standard story is simple: the West got rich, the East got poor, therefore the Western model works and the Eastern one doesn't. Case closed.

Except the two halves did not start from the same line. Murphy walks through the reparations. After the Second World War, East Germany paid the Soviet Union an enormous bill for the damage Germany as a whole had inflicted — factories dismantled and shipped east, production seized, output transferred. The total came to several times East Germany's entire annual output. West Germany paid essentially none of that. Instead, West Germany received substantial financial aid from the United States, a country that had come out of the war with its factories untouched and its territory unbombed.

So one twin starts the race carrying a debt worth several years of everything it produces, and the other twin starts with a subsidy from the richest economy on earth. Forty years later the second twin is richer, and this is presented to you as proof about which economic system is more efficient.

That is not an experiment. That is a rigged coin toss described as a scientific finding.

And here is what Murphy found when he corrected for the starting line. East Germany didn't just survive that handicap. It closed a large part of the gap. Growing faster, from far behind, while paying out. That is the opposite of the inefficiency story you were sold.

Then the West did something the story never mentions. It ran an active economic campaign against the East. Currency manipulation that made the Eastern mark look worthless. Trade restrictions. Recruitment of skilled workers — doctors, engineers, technicians, educated at Eastern expense — pulled west with cash bonuses, guaranteed housing, and subsidized loans. Murphy documents payments that essentially made it a paid transfer. Think about what that does to a country. You spend a decade and a fortune training a surgeon, and your neighbor offers her a signing bonus to leave. Do that thousands of times a year for thirty years and you have not observed an economy failing. You have watched one being drained.

We have a word for this pattern when it happens to a company. When private equity buys a firm, loads it with debt, sells the real estate, poaches the talent, cuts the maintenance, and then points at the wreckage and says "well, that business model just wasn't viable" — we all know exactly what happened. Nobody thinks the business failed on the merits. Everybody understands it was harvested.

That is the analytical move at the center of this book. It is not a claim that the East was paradise. Murphy is explicit that shortages were real, that the queues were real, that the surveillance was real, that people were genuinely furious about all of it. His claim is narrower and much harder to dismiss: the collapse was not caused by economic failure, because there wasn't economic failure. People were not revolting against a system that was making them poorer. They were revolting against being poorer than the people on the other side of the wall — and they had been told, constantly, by the most sophisticated broadcasting operation in human history, that the reason for the difference was the system, not the reparations, not the war damage, not the aid, not the poaching.

They were sold a story about why they were behind. They bought it. And then they got the bill.

Because here is what happened next, and this is the part that should matter to anyone who has ever been promised that a merger, a privatization, or a restructuring will make things better for them. East Germans voted, in 1990, for the fast version. Immediate currency union. Immediate integration. Get rich quick.

What they got was the largest single act of deindustrialization in modern European history. The currency conversion, set for political reasons rather than economic ones, instantly made every Eastern factory uncompetitive overnight — same wages, new currency, no transition. An agency was set up to sell off Eastern industry, and it sold it, mostly to Western buyers, often for a symbolic price, frequently to competitors who bought a rival and closed it. Unemployment in the east went from officially near zero to double digits and stayed there for a generation. Western Germany then poured over a hundred billion dollars a year eastward, roughly half of East Germany's entire pre-1989 output, every year — and the region remained a permanent economic patient, dependent on transfers just to hold a minimum standard of living. People kept leaving at over ten thousand a month into the 1990s. Nearly a million commuted west for work.

They were promised prosperity. They received a permanent subsidy and an empty hometown. If you live anywhere in America where the plant closed, you already know this story in your bones. You just did not know it was the same story.

Before I move on, I want to deal with the objection you are already forming, because it is a fair one and Murphy deals with it head on. What about the repression. What about the secret police. What about the wall itself, which existed to keep people in.

He does not dodge any of it. The surveillance apparatus in East Germany was enormous and it ruined lives. The travel restrictions were real and people hated them, and hating them was reasonable. What he does is something more useful than defending it. He asks you to apply the same measuring stick to both sides at once, which is the one thing you are never invited to do.

So: the country that won the Cold War locks up more of its own population than any other nation on earth. Around five times the world average rate. Millions of people, disproportionately from communities that were enslaved within living memory of their grandparents. That is not a historical footnote from the 1980s; it is the situation right now, today, in the country that presents itself as the free half of that comparison.

The country that won also has entire cities where the life expectancy in one zip code is a decade shorter than in the zip code four miles away. It has hundreds of thousands of people sleeping outside on any given night in the richest economy in recorded history. It has medical bankruptcy, which is a phrase that does not exist in most of the developed world because in most of the developed world it is not a thing that can happen to you.

None of that makes the Stasi acceptable. That is not the argument, and if you take that away from this you have missed it. The argument is that "which system was more repressive" is a question you have only ever been allowed to ask in one direction. You were handed a detailed accounting of one side's abuses and a blank page for the other. And when the accounting is one-sided, the conclusion was decided before you started counting.

Murphy also goes through the killing. He spends the entire introduction on it, and it is the roughest chapter in the book, because he is running a body count against the country that assigned itself the role of moral referee. The near-total destruction of the indigenous population of North America across several centuries — deliberate policy, documented in the sources he cites, including the deliberate spreading of disease and the deliberate destruction of the food supply to starve people out. Slavery. The firebombing of cities full of civilians. The support, funding, and training of governments in Latin America and Southeast Asia that ran death squads. He lays it out with citations, the way you would lay out a footnoted valuation report, because he is a finance professor and that is the only way he knows how to write.

You are allowed to disagree with his framing. What is hard to disagree with is the structure of the exercise. We have a very precise, very loud, endlessly repeated accounting of every death attributable to one side of the twentieth century, and an extremely vague, apologetic, contextualized, mostly-forgotten accounting of the deaths attributable to the other. That asymmetry is not an accident of scholarship. It is the single most successful marketing campaign ever run, and you were the target market.

And why does a marketing campaign about 1953 matter to you in 2026? Because it is the foundation the whole current arrangement rests on. Every time someone proposes that the government should directly build housing, or directly provide healthcare, or directly cap the price of insulin, the response is not an argument. It is a reference. It is a gesture at a breadline photograph from sixty years ago. The historical verdict is doing the work that evidence is supposed to do. Which means if the verdict is shaky, every policy conversation you are currently losing was rigged upstream, before anyone opened their mouth.

There is one more chapter I have to mention, because it is the one that separates this book from a complaint. Chapter 5 is Murphy doing his actual day job. He builds a model of what East Germany could have done instead in 1989 — an alternative plan. Keep the border open, because people wanted it open. Keep a separate currency instead of the political conversion rate that destroyed the industrial base overnight. Manage the exchange rate. Prioritize investment. He runs the sensitivity analysis the way you would for any corporate valuation: what if savings rates come in different, what if imports run hotter, what if a black market develops, what if less Western investment shows up than projected. He stress-tests his own plan against its own worst cases.

And the model says the economy survives. Not utopia. Survival, with rising living standards, and no thirty-year dependency on transfer payments from the west.

Whether you believe his model matters less than what its existence proves. There was a choice. What happened in 1990 was not the only door in the building. It was one option, selected, by identifiable people, for reasons that had a lot to do with who would own the factories afterward. And the fact that you have never heard there was an alternative is itself the point. When something is presented to you as inevitable — the only serious option, the way things have to be, there is no alternative — that framing is almost always doing work for somebody. Somebody benefits from you believing the door you walked through was the only door.

You hear that same "no alternative" in your own life constantly, by the way. There is no alternative to the rent going up, that is just the market. There is no alternative to the insurance deductible, that is just costs. There is no alternative to the two-tier contract where the new hires get half of what you got, that is just competitiveness. Every one of those sentences is a decision wearing a costume made of weather.

And watch how quickly the "no alternative" rule gets suspended when the pressure runs the other way. When the banks needed rescuing in 2008, trillions appeared in a weekend. When the pandemic hit, governments that had spent a decade insisting there was no money for anything discovered they could send checks, pause evictions, and cover payrolls, in about three weeks. The capacity was always there. It gets deployed instantly when the people at the top are exposed, and it becomes physically impossible the moment the same amount would go to you instead. That is not an argument about economics. That is an observation about who the system treats as an emergency.

Notice also what happened right after those emergency measures ended. Every one of them was rolled back fast, and the ones that had visibly worked — the child payments that cut child poverty almost in half in a single year, the eviction pause that kept people housed — were the first to go, and they were killed with the same vocabulary. Unsustainable. Distorting. Disincentivizing. We ran the experiment, it worked, and it was terminated for working, because a policy that proves the thing was solvable all along is more dangerous to the arrangement than the problem ever was.

Now let me get to the part that makes this more than a history lesson, because I do not care about 1990. I care about your rent.

Murphy's Chapter 6 is about what the victory did to the rest of the world, and this is where the book stops being about Germany and starts being about you. When the competition disappeared, the pressure disappeared with it.

Think about what actually restrained the people at the top in the West for forty years. It was not their conscience. It was the existence of an alternative. When there is a rival system on the map claiming it can deliver housing, healthcare, childcare, and job security, and it is claiming that loudly to your own workers, you have to answer. You have to offer something. The postwar decades in the West — strong unions, rising real wages, public housing programs, national health systems in most of the developed world, pensions that actually paid, university that ordinary families could afford — that entire package was not handed down out of generosity. It was a counteroffer. It was the price of keeping people from looking across the fence.

Remove the fence, and the counteroffer expires.

Look at the timeline. Real wages for ordinary workers in the United States stopped tracking productivity around the early 1970s and never reconnected. That is the setup. But the acceleration comes after 1990. Union membership in the private sector falls off a cliff. Pensions with guaranteed payouts get swapped for accounts where you carry the market risk personally. Public housing construction stops. Public university funding gets cut and replaced with debt you sign at seventeen. The retirement age drifts upward everywhere. Whole categories of work get reclassified so the person doing them is technically not an employee and therefore owed nothing.

None of that was hidden. It was all announced as modernization, flexibility, reform, competitiveness. And every single one of those words meant the same thing: the counteroffer is withdrawn, because you have nowhere else to go.

And here is the piece that should stop you cold. The very things the winning side spent forty years mocking the losing side for having — guaranteed housing, guaranteed employment, subsidized childcare, free education, free healthcare, controlled prices on staple food — read that list again slowly. Every single item on it is now a mainstream policy demand in every wealthy country on earth. Rent control. Childcare subsidies. Free community college. Cancel the student debt. Public option. Price gouging laws on groceries.

We spent a generation being told those things were the hallmarks of a failed system. Now they are the things people are begging their governments for. Nobody notices, because they arrive as separate consumer complaints instead of as one coherent list.

Murphy also spends serious time on the currency crises, and this is the technical heart of the book that most readers skip. Once capital could move anywhere instantly and every country was pushed to open up, you got a cascade — Mexico in 1994, Asia in 1997, Russia in 1998, and on and on. And the pattern is always identical. Money floods in while things look good. Something spooks it. Money floods out in a week. The currency craters. Then the fix arrives, and the fix is always the same fix: interest rates up, spending cut, assets sold to foreign buyers cheap, and a fall in real income for the population large enough to balance the external accounts.

That last part deserves plain language. "External adjustment" means the population gets poorer on purpose, by design, as the mechanism. A country's wages are cut so its foreign creditors can be made whole. That is not an unfortunate side effect of the rescue. That is the rescue. That is what the instrument does.

And if that sounds abstract, look at what happened in Europe after 2008, or what happens in your own city when a hospital system gets bought by a fund and the emergency room closes. Same mechanism, smaller scale. Somebody's balance sheet gets protected, and the way it gets protected is that your life gets more expensive and more precarious.

Now, the third layer, and this is the one I want to leave in your head, because it is bigger than any of the individual numbers.

None of this required a conspiracy. There was no meeting. Nobody had to be evil in the cartoon sense.

Once the shareholder-first model has no external competitor, it does exactly what it is built to do — maximize returns to owners — and it does that with the brakes off. The brakes were never internal. There is nothing inside a quarterly earnings target that cares about your rent. The brakes were external: organized workers who could stop production, a rival system that made concessions strategically necessary, and governments that were frightened enough to regulate. Take away all three, and you do not get corruption. You get the machine running at full design speed for the first time.

That is why this keeps happening across industries that have nothing to do with each other. Your streaming service gets worse and more expensive. Your airline seat gets smaller. Your appliance breaks in six years instead of twenty-five. Your doctor has eleven minutes. Your groceries shrink in the package. These look like a thousand unrelated annoyances. They are one thing. They are what an extraction model does when nothing external constrains it.

The strings are not being pulled by a person. They are being pulled by an incentive structure that has no counterweight left. And "we removed the counterweight and called it a victory" is a much more disturbing sentence than any conspiracy theory, because you cannot fire an incentive structure.

So what do you actually do with this. Not a revolution — Murphy himself, at the end of a book that argues the wrong side won, says the answer is to vote it out, which tells you how modest the ask is.

Here is the honest, small, real version.

First, learn who owns the thing that is squeezing you. Concretely. Look up who owns your apartment building — not the management company, the actual holding entity behind it. Look up who owns your hospital network. Look up which fund bought the veterinary clinic, the dental practice, the local paper. It takes twenty minutes and it is public. Every single time, you will find the same handful of names, and the moment you can name them, the squeeze stops feeling like weather and starts looking like a decision somebody made.

Second, rebuild a counterweight where you actually stand. Not in theory. A tenant association in your building. A union card at your job, even in a workplace where people say it is impossible. A local co-op. Showing up to the one public meeting a year where the hospital board or the zoning board has to sit and listen. These are unglamorous and they work for exactly the reason the last forty years demonstrate: this system only ever gave ground when something forced it to. It has no other mode.

Third, when someone tells you a market solution will fix a thing that markets broke, ask them for the East German receipts. Ask what happened to the last population that was promised rapid prosperity through restructuring. The answer is on record, in IMF data, and it is a fifty percent collapse and a generation of transfers.

And fourth, the cheapest one: stop treating your bills as separate problems. The rent, the insurance, the phone plan, the childcare, the vet, the streaming stack, the shrinking package of the same cereal — you have been trained to experience each of those as a personal budgeting failure that you handle alone, quietly, slightly embarrassed. They are not separate. They are one process arriving at your door through eleven different mail slots. The moment you say that out loud to another person and they say "wait, mine too," the isolation breaks, and isolation is the only thing that has been keeping the arrangement stable. They do not need you to agree with them. They just need you to think it is only happening to you.

Go back to that receipt in your pocket. The one where the same cart costs half again as much as it did four years ago.

You were told, when the wall came down, that this was the end of the argument, and that the system that had just won would deliver you a better life without anyone needing to fight for it. Three decades later, you are working more hours for less security, in a smaller apartment, with a bigger bill, and every institution above you is telling you this is normal and probably your fault.

It is not your fault, and it is not weather. The thing that used to make them offer you a better deal stopped existing, so they stopped offering. That is the whole trick. The Cold War did not end with the good guys winning. It ended with the last thing that could make anyone negotiate with you being taken off the table — and thirty years of your paycheck is the receipt.

── Watch the video ── 🎬 Odysee: https://odysee.com/the-cold-war-scam-why-winning-made-your-life-worse#fad7fc467cf99d426c82cf80d5a0d641161c451e