# Raskell

> Notes on agent platforms, platform automation, edge infrastructure, and applied security. Building automation-first platforms that survive production reality.

raskell.io is the personal site of Raffael Schneider, an AI Architect in Basel, Switzerland. He works on enterprise AI and agent platforms, edge infrastructure, applied security, and developer tooling, and writes long-form articles about them. The site is a digital garden: articles, book reviews, notes, talks, a reading log, projects, a topic vocabulary, and every source the writing cites, all connected in one graph (map.json) and one search index (garden.json). Every article below links to a clean Markdown copy; the HTML page is the same URL without `.md`. Writing is licensed CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/) and code samples MIT: reuse, quote, and train on it with attribution, e.g. Raffael Schneider, "Article title", raskell.io, date, URL. Images, logos, and quoted third-party material are excluded (https://raskell.io/license/).

## Key pages

- [About](https://raskell.io/about/): who Raffael is, what he works on, and how to reach him
- [Start here](https://raskell.io/start-here/): curated reading tracks through the archive
- [Map](https://raskell.io/map/): every article, note, topic, series, and project as one graph; machine-readable at [map.json](https://raskell.io/map.json)
- [All writing in full](https://raskell.io/llms-full.txt): every article and note in one Markdown file, newest first
- [Notes](https://raskell.io/notes/): short notes that sit between the articles
- [Reading](https://raskell.io/reading/): what Raffael is reading, what is next, and what he has read, with reviews
- [Reviews](https://raskell.io/categories/reviews/): reviews of books, papers, and long articles from the reading log
- [Talks](https://raskell.io/talks/): slide decks from talks
- [Search](https://raskell.io/search/): everything on the site, including every external link the writing cites; `?q=` and `?type=link` (or article, review, note, talk, work, project, topic) work as URLs, e.g. https://raskell.io/search/?q=zentinel
- [RSS feed](https://raskell.io/rss.xml): full-text feed

## Series: The Agent Platform Handbook

1. [What an Agent Actually Is](https://raskell.io/articles/what-an-agent-actually-is.md): AI agent is the most overloaded word in the industry. This is the anatomy, the lineage, and a working implementation in roughly two hundred lines of TypeScript on Bun. Part one of The Agent Platform Handbook.
2. [Your Agent Wants Root](https://raskell.io/articles/your-agent-wants-root.md): An agent with a shell tool is arbitrary code execution with a friendly face. A short tour of why Docker alone is not enough, what Firecracker, gVisor, and Kata actually solve, and a hardened sandbox you can wrap the post-one agent in today. Part two of The Agent Platform Handbook.
3. [Tools: How Agents Actually Do Things](https://raskell.io/articles/tools-how-agents-actually-do-things.md): Function calling is the API between language and action, but the engineering is in the registry. A working four-tool registry in TypeScript on Bun, schema design that survives model drift, parallel tool calls, and the failure modes nobody mentions in the demo. Part three of The Agent Platform Handbook.
4. [Context Is the Product](https://raskell.io/articles/context-is-the-product.md): Models are commodities. Context is not. The sources of context an agent draws on, why retrieval alone is not enough, and a minimal .AGENTS/ convention that loads context from disk into the same harness we have been building. Part four of The Agent Platform Handbook.
5. [Retrieval Is a Tool, Not a Layer](https://raskell.io/articles/retrieval-is-a-tool-not-a-layer.md): Loading the whole .AGENTS/ directory on every turn does not scale. The fix is not a retrieval layer bolted to the side of the agent. It is a search tool in the registry the agent already has. BM25 over project docs, no vector store, and an honest account of when embeddings start to earn their keep. Part five of The Agent Platform Handbook.
6. [Memory Is a Write Path](https://raskell.io/articles/memory-is-a-write-path.md): Retrieval reads context the project authored. Memory is the agent writing context for its own future sessions, and the write is the part that is dangerous. Why session memory comes free from the transcript, why cross-session memory needs a separate write surface, and how to let an agent remember without letting it corrupt its own ground truth. Part six of The Agent Platform Handbook.
7. [The Model Is a Dependency](https://raskell.io/articles/the-model-is-a-dependency.md): Every layer of the harness has existed to put the right tokens in front of one hardcoded model string. This post pulls that string out and makes the model a dependency: why you route a cheap model for easy turns and a strong one for hard turns, what a fallback looks like when a provider is down, and why 'models are commodities' is a claim about your architecture before it is a claim about the market. Part seven of The Agent Platform Handbook.
8. [The Bill Is Part of the Loop](https://raskell.io/articles/the-bill-is-part-of-the-loop.md): Every model response already carries its own bill in the usage field, and the loop throws it away. This post reads that field, prices it against a table, and turns cost into a value the loop can see per turn and act on: a metering decorator that needs no loop change, a running ledger, prompt-cache accounting that moves the number the most, and a budget that degrades before it stops. Part eight of The Agent Platform Handbook.
9. [Observability Is Not Logging](https://raskell.io/articles/observability-is-not-logging.md): A cost total says nothing about how a run went. This part turns each agent run into a trace: which turn escalated, which tool failed, where the money went.

## Articles

- [The Web Was the Training Set](https://raskell.io/articles/the-web-was-the-training-set.md) (2026-10-24): Tim Berners-Lee's memoir is the story of a British engineer at a Franco-Swiss lab giving a protocol away. Read in 2026, it is also the origin story of AI's data supply.
- [Observability Is Not Logging](https://raskell.io/articles/observability-is-not-logging.md) (2026-10-20): A cost total says nothing about how a run went. This part turns each agent run into a trace: which turn escalated, which tool failed, where the money went.
- [This Site Is Becoming a Map](https://raskell.io/articles/this-site-is-becoming-a-map.md) (2026-10-15): A blog shows what I wrote last. The new map on raskell.io shows what I keep coming back to, and it is the start of a public second brain.
- [The Bill Is Part of the Loop](https://raskell.io/articles/the-bill-is-part-of-the-loop.md) (2026-07-18): Every model response already carries its own bill in the usage field, and the loop throws it away. This post reads that field, prices it against a table, and turns cost into a value the loop can see per turn and act on: a metering decorator that needs no loop change, a running ledger, prompt-cache accounting that moves the number the most, and a budget that degrades before it stops. Part eight of The Agent Platform Handbook.
- [The Model Is a Dependency](https://raskell.io/articles/the-model-is-a-dependency.md) (2026-07-09): Every layer of the harness has existed to put the right tokens in front of one hardcoded model string. This post pulls that string out and makes the model a dependency: why you route a cheap model for easy turns and a strong one for hard turns, what a fallback looks like when a provider is down, and why 'models are commodities' is a claim about your architecture before it is a claim about the market. Part seven of The Agent Platform Handbook.
- [The Bottleneck Is Data, and Europe Is Sitting on It](https://raskell.io/articles/the-bottleneck-is-data-and-europe-is-sitting-on-it.md) (2026-06-30): Frontier AI is running short on public text, not compute. Europe's edge is the high-quality data it never put online. Capturing it needs coordination.
- [Brain Emulation, Read as an Infrastructure Problem](https://raskell.io/articles/brain-emulation-as-an-infrastructure-problem.md) (2026-06-28): An MIT thesis argues brain emulation has crossed into engineering. Read as infrastructure, the numbers describe a workload your AI cluster was not built for.
- [Memory Is a Write Path](https://raskell.io/articles/memory-is-a-write-path.md) (2026-06-23): Retrieval reads context the project authored. Memory is the agent writing context for its own future sessions, and the write is the part that is dangerous. Why session memory comes free from the transcript, why cross-session memory needs a separate write surface, and how to let an agent remember without letting it corrupt its own ground truth. Part six of The Agent Platform Handbook.
- [The Proof You Only Have to Write Once](https://raskell.io/articles/the-proof-you-only-have-to-write-once.md) (2026-06-19): Generation is cheap, so verification is the bottleneck — and we throw the verification away every time. What if a proof, once written, could be named, shared, and vouched for? A content-addressed commons for verified Haskell, and the move I left for after the semantic-artifact trilogy.
- [Retrieval Is a Tool, Not a Layer](https://raskell.io/articles/retrieval-is-a-tool-not-a-layer.md) (2026-06-17): Loading the whole .AGENTS/ directory on every turn does not scale. The fix is not a retrieval layer bolted to the side of the agent. It is a search tool in the registry the agent already has. BM25 over project docs, no vector store, and an honest account of when embeddings start to earn their keep. Part five of The Agent Platform Handbook.
- [Context Is the Product](https://raskell.io/articles/context-is-the-product.md) (2026-06-13): Models are commodities. Context is not. The sources of context an agent draws on, why retrieval alone is not enough, and a minimal .AGENTS/ convention that loads context from disk into the same harness we have been building. Part four of The Agent Platform Handbook.
- [Tools: How Agents Actually Do Things](https://raskell.io/articles/tools-how-agents-actually-do-things.md) (2026-06-09): Function calling is the API between language and action, but the engineering is in the registry. A working four-tool registry in TypeScript on Bun, schema design that survives model drift, parallel tool calls, and the failure modes nobody mentions in the demo. Part three of The Agent Platform Handbook.
- [Your Agent Wants Root](https://raskell.io/articles/your-agent-wants-root.md) (2026-06-05): An agent with a shell tool is arbitrary code execution with a friendly face. A short tour of why Docker alone is not enough, what Firecracker, gVisor, and Kata actually solve, and a hardened sandbox you can wrap the post-one agent in today. Part two of The Agent Platform Handbook.
- [What an Agent Actually Is](https://raskell.io/articles/what-an-agent-actually-is.md) (2026-06-02): AI agent is the most overloaded word in the industry. This is the anatomy, the lineage, and a working implementation in roughly two hundred lines of TypeScript on Bun. Part one of The Agent Platform Handbook.
- [The Field Exists Now](https://raskell.io/articles/the-field-exists-now.md) (2026-05-22): Alasdair Allan's agentlanguages.dev catalogue turns AI-oriented programming languages from a loose set of experiments into a field with camps, disagreements, and testable claims.
- [Source Code Is the New Assembly](https://raskell.io/articles/semantic-artifacts-and-meaning-engines.md) (2026-05-07): Closing the trilogy. The artifact you author is no longer source code. It is a typed, verifiable object that carries meaning. Code becomes a lowering target.
- [Patents Per Capita Is a Vanity Metric](https://raskell.io/articles/patents-per-capita-is-a-vanity-metric.md) (2026-05-01): Switzerland tops the Global Innovation Index for the fifteenth year running. As an engineer, that should make you suspicious of the metric, not proud of the country.
- [Traffic Replay as a Security Primitive](https://raskell.io/articles/traffic-replay-as-a-security-primitive.md) (2026-04-27): WAF tuning is a guessing game because you cannot reproduce the traffic that triggered the rule. Deterministic replay changes that.
- [The Economics of Inference](https://raskell.io/articles/the-economics-of-inference.md) (2026-04-22): Inference tokens are not API calls. They are a metered resource that is consumed, generates value, and correlates with power draw. The economics of the post-AI world look less like software and more like water, electricity, and gas.
- [What Comes After the Last Programming Language](https://raskell.io/articles/what-comes-after-the-last-programming-language.md) (2026-04-19): If AI generates machine code directly, why are we still running operating systems designed for humans? The answer might be an inference-native OS.
- [What Sixteen AI Agents Taught Me About Management](https://raskell.io/articles/what-sixteen-ai-agents-taught-me-about-management.md) (2026-04-16): What happens when you give sixteen AI agents an org chart, a reporting structure, and a token budget. A story about orchestration, management, and running out of runway.
- [Why We Built a Haskell Package Manager in Rust](https://raskell.io/articles/why-we-built-a-haskell-package-manager-in-rust.md) (2026-04-13): hx is a fast, opinionated Haskell toolchain built in Rust, following the playbook astral.sh used to modernize Python.
- [The Last Programming Language Might Not Be for Humans](https://raskell.io/articles/what-programming-languages-become-when-ai-writes-the-code.md) (2026-04-11): Three futures for programming languages as AI becomes the primary author of code, and why I bet on Haskell.
- [Notes from RSAC 2026](https://raskell.io/articles/notes-from-rsac-2026.md) (2026-04-09): Third time at RSA Conference, first time as a speaker. What I saw, what I heard, and what I am still processing.
- [What Zentinel Is Really Optimizing For](https://raskell.io/articles/what-zentinel-is-really-optimizing-for.md) (2026-03-22): Every major proxy was a product of its time. Zentinel is built for this one: safety, operability, and the operator's ability to sleep.
- [How I Work These Days](https://raskell.io/articles/how-i-work-these-days.md) (2026-03-15): From Kaggle in 2020 to coding agents in late 2025. The shift that changed how I build and why my routine finally feels right.
- [Archipelag.io Is in Open Beta: Here's Why I Built It](https://raskell.io/articles/archipelag-io-distributed-compute-from-mining-rigs-to-open-beta.md) (2026-03-13): From watching Ethereum miners in 2016 to building a decentralized compute network in open beta. Architecture, conviction, and the long road.
- [How AI Makes Bare Metal Viable Again](https://raskell.io/articles/how-ai-makes-bare-metal-viable-again.md) (2026-03-08): I migrated two production apps from Kubernetes to a single Hetzner box. The missing piece was not the hardware.
- [Edge Systems Are the New Backend](https://raskell.io/articles/edge-systems-are-the-new-backend.md) (2026-02-11): Auth, policy, and business logic are migrating to the edge. The traditional backend is becoming a persistence layer.
- [Looking back on 2025](https://raskell.io/articles/looking-back-on-2025.md) (2025-12-31): On reading Tim Berners-Lee in Okinawa, and why AI might accidentally save the web from itself.
- [Mise ate my Makefile](https://raskell.io/articles/mise-ate-my-makefile.md) (2025-12-14): Mise replaced Make, asdf, and a pile of shell scripts with a single TOML file per project. Here is why it stuck.
- [Disk space maintenance on Void Linux](https://raskell.io/articles/disk-space-void-linux-maintenance.md) (2024-05-01): Cleaning old kernels, pruning xbps package cache, and reclaiming disk space on Void Linux without breaking your system.
- [All beginning is Haskell](https://raskell.io/articles/all-beginning-is-haskell.md) (2023-03-06): How Haskell shaped the way I think about building systems, and why I am still building Haskell tooling years after writing my first monad.
- [My OpenBSD journey: Getting it virtualized with libvirt (1)](https://raskell.io/articles/my-openbsd-journey-getting-it-virtualized-with-libvirt-1.md) (2023-02-06): A step-by-step guide to running OpenBSD in a libvirt virtual machine on Void Linux, without needing VirtualBox or VMWare. Part 1 of my OpenBSD journey.
- [Hello and outlook](https://raskell.io/articles/hello-and-outlook.md) (2022-09-20): The first post on raskell.io. What this site is for and what I planned to write about.

## Reviews

Reviews of works from the reading log (category: reviews, feed https://raskell.io/categories/reviews/rss.xml). Each Markdown copy names the reviewed work and the rating in its front matter.

- [The Web Was the Training Set](https://raskell.io/articles/the-web-was-the-training-set.md) (2026-10-24): review of *This Is for Everyone* by Tim Berners-Lee (book, 2025), rated 8/10. Tim Berners-Lee's memoir is the story of a British engineer at a Franco-Swiss lab giving a protocol away. Read in 2026, it is also the origin story of AI's data supply.

## Talks

Slide decks; each has a Markdown copy with the words of every slide.

- [I Stopped Writing Most of My Code](https://raskell.io/talks/iat-13-basel.md) (2026-06-10, IT's ABOUT TECH #13): Slide deck for IT's ABOUT TECH #13 in Basel. A 15-minute story about what changed for a long-time engineer after Claude Opus 4.5 and Claude Code arrived, and what happens to a backlog of years-old ideas when the bottleneck stops being time.

## Notes

Short notes, a paragraph or a page each; some grow into articles.

- [Opus 5.5 is the best Opus since 4.5](https://raskell.io/notes/opus-5-5-is-the-best-opus-since-4-5.md) (2026-10-24): A month in, Claude Opus 5.5 feels like the next milestone after Opus 4.5: the same jump in what Claude Code can carry, now faster and cheaper per task.

## Reading

The reading log at https://raskell.io/reading/ (as data: [reading.json](https://raskell.io/reading.json)): books, papers, and long articles, with the month finished, a rating out of 10 where there is a review, and the review.

### Reading now

- [The Infinity Machine](https://www.penguin.co.uk/books/461432/the-infinity-machine-by-mallaby-sebastian/9781802066296), Sebastian Mallaby (book)

### Backlog

- [Why Machines Learn](https://www.penguinrandomhouse.com/books/677608/why-machines-learn-by-anil-ananthaswamy/), Anil Ananthaswamy (book)
- [The Dream Machine](https://press.stripe.com/the-dream-machine), M. Mitchell Waldrop (book)
- [The Alignment Problem](https://brianchristian.org/the-alignment-problem/), Brian Christian (book)
- [Artificial Intelligence](https://us.macmillan.com/books/9781250404855/artificialintelligence/), Melanie Mitchell (book)
- [Deep Thinking](https://www.hachette.co.uk/titles/garry-kasparov/deep-thinking/9781473653504/), Garry Kasparov (book)
- [Understanding Deep Learning](https://mitpress.mit.edu/9780262048644/understanding-deep-learning/), Simon J. D. Prince (book)
- [Build a Large Language Model (From Scratch)](https://www.manning.com/books/build-a-large-language-model-from-scratch), Sebastian Raschka (book)
- [AI Engineering](https://www.oreilly.com/library/view/ai-engineering/9781098166298/), Chip Huyen (book)
- [Reinforcement Learning: An Introduction](https://mitpress.mit.edu/9780262039246/reinforcement-learning/), Richard S. Sutton and Andrew G. Barto (book)
- [Probabilistic Machine Learning: An Introduction](https://probml.github.io/pml-book/book1.html), Kevin P. Murphy (book)
- [The Making of the Atomic Bomb](https://www.simonandschuster.net/books/The-Making-of-the-Atomic-Bomb/Richard-Rhodes/9781451677614), Richard Rhodes (book)
- [Seeing Like a State](https://yalebooks.yale.edu/book/9780300252989/seeing-like-a-state/), James C. Scott (book)
- [A Peace to End All Peace](https://academic.macmillan.com/academictrade/9780805088090/apeacetoendallpeace/), David Fromkin (book)
- [The Billion-Dollar Molecule](https://www.simonandschuster.com/books/The-Billion-Dollar-Molecule/Barry-Werth/9780671510572), Barry Werth (book)
- The Eighth Day of Creation, Horace Freeland Judson (book)
- [The Demon Under the Microscope](https://www.penguinrandomhouse.com/books/73465/the-demon-under-the-microscope-by-thomas-hager/), Thomas Hager (book)
- [The Butchering Art](https://www.penguin.co.nz/books/the-butchering-art-9780141983387), Lindsey Fitzharris (book)

### Read

- [The Cauldron](https://www.hachette.co.uk/titles/simon-sebag-montefiore/the-cauldron/9781399634939/), Simon Sebag Montefiore (book, finished September 2026)
- [From Worm to Human: Scaling Brain Emulation](https://pdf.isaak.net/scaling-emulations), Isaak Freeman (paper, finished June 2026): A thesis that treats brain emulation as an engineering programme, and whose numbers read like a capacity plan.
- [State of Brain Emulation Report 2025](https://arxiv.org/abs/2510.15745), Zanichelli, Schons, Freeman, Shiu, and Arkhipov (report, finished June 2026): The field's own survey of where connectomics, recording, and modelling stand, and how far apart they still are.
- Infinite Jest, David Foster Wallace (novel, finished December 2025)
- Guns, Germs, and Steel, Jared Diamond (book, finished November 2025)
- [Nuclear War: A Scenario](https://en.wikipedia.org/wiki/Nuclear_War:_A_Scenario), Annie Jacobsen (book, finished October 2025)
- This Is for Everyone, Tim Berners-Lee (book, finished October 2025, rated 8/10): Read on the shores of Okinawa: the web as a commons, how far what we built drifted from it, and why the models exist at all. Review: [The Web Was the Training Set](https://raskell.io/articles/the-web-was-the-training-set.md)
- Jurassic Park, Michael Crichton (novel, finished July 2025)
- The Books of Jacob, Olga Tokarczuk (novel, finished August 2024)

## Sources cited most

External links cited on more than one page (all 255 are searchable at https://raskell.io/search/?type=link and listed in [links.json](https://raskell.io/links.json)).

- [Zentinel](https://zentinelproxy.io): cited on 11 pages
- [Archipelag.io](https://archipelag.io/): cited on 8 pages
- [Cyanea](https://cyanea.bio/): cited on 5 pages
- [arcanist.sh](https://arcanist.sh/): cited on 4 pages
- [Die Zukunft](https://die-zukunft.ch/): cited on 4 pages
- [companion repository](https://github.com/raskell-io/the-agent-platform-handbook): cited on 4 pages
- [AI 2027](https://ai-2027.com/): cited on 3 pages
- [Pingora](https://github.com/cloudflare/pingora): cited on 3 pages
- [Conflux](https://github.com/raskell-io/conflux): cited on 3 pages
- [shiioo](https://github.com/raskell-io/shiioo): cited on 3 pages
- [Vera](https://veralang.dev/): cited on 3 pages
- [Void Linux](https://voidlinux.org/): cited on 3 pages
- [catalogue of languages built for agents to write](https://agentlanguages.dev): cited on 2 pages
- [BHC](https://arcanist.sh/bhc/): cited on 2 pages
- [hx](https://arcanist.sh/hx/): cited on 2 pages
- [astral.sh](https://astral.sh): cited on 2 pages
- [Void Linux Handbook: XBPS](https://docs.voidlinux.org/xbps/index.html): cited on 2 pages
- [fly.io](https://fly.io): cited on 2 pages
- [Ghostty terminal emulator](https://ghostty.org): cited on 2 pages
- [Kurumi](https://github.com/raskell-io/kurumi): cited on 2 pages

## Topics

The topic vocabulary every page is filed under, with broader topics in brackets. Topic pages live at https://raskell.io/tags/<slug>/.

### Domains

- AI platforms (`ai-platforms`): The shared foundation an organisation builds AI on: model gateways, agent runtimes, governance, observability, and the operating model around them.
- AI-assisted engineering (`ai-engineering`): AI as an engineering tool: coding agents, AI-authored code, and what programming becomes when models write most of it.
- AI for operations (`ai-for-ops`): AI applied to running systems: security triage, alert noise, incident work, and keeping a human in the loop.
- Platform automation (`platform-automation`): Self-service, guardrails, deployment, and the tooling that keeps operating software sustainable.
- Edge systems (`edge-systems`): Reverse proxies, policy enforcement, CDNs, and logic that runs close to the user instead of in the backend.
- Applied security (`applied-security`): Security under production pressure: adversarial input, signal versus noise, and controls that operators can live with.
- Distributed systems (`distributed-systems`): Replication, coordination, and consistency across machines that fail independently.
- Programming languages (`programming-languages`): Languages, type systems, compilers, and how executable intent gets written down.
- Operating systems (`operating-systems`): Kernels, virtualisation, and the layer between hardware and everything else, from BSD to inference-native designs.
- Reliability (`reliability`): Failure modes, operability, and keeping systems up when the inputs and the dependencies misbehave.
- Sovereignty (`sovereignty`): Who controls compute, data, and infrastructure, and in which jurisdiction; Europe's position in particular.
- Policy (`policy`): Where engineering meets regulation, public institutions, procurement, and national strategy.
- The open web (`open-web`): The web as a commons: open protocols, small independent sites, and publishing outside the platforms.
- History (`history`): Events, institutions, and societies through time, with attention to sources, competing accounts, and uncertainty.
- Geography (`geography`): Places, terrain, borders, and spatial data, and how their relationships change over time.
- Machine learning (`machine-learning`): How models learn from data: the mathematics, the training methods, and what the results can and cannot do.
- Life sciences (`life-sciences`): Biology and medicine: how living systems work, and how we learn to measure, model, and treat them.
- Simulation (`simulation`) [within Complex systems]: Interactive worlds that mimic real ones: societies, economies, neuron cultures, and agents left to evolve on their own.
- Games (`games`): Games made with care: tactics, fishing, and the engines and fantasy consoles they run on.

### Concepts

- Agents (`agents`) [within AI platforms]: LLM agents as software: the loop, tools, context, memory, sandboxes, and the platform underneath them.
- Context engineering (`context-engineering`) [within Agents]: Deciding what a model sees: pinned context, retrieval, memory, and the conventions that keep them honest.
- Inference (`inference`) [within AI platforms]: Running models in production: routing, cost, hardware, and inference as a metered utility.
- Isolation (`isolation`) [within Applied security, Reliability]: Sandboxes, process and failure-domain isolation, and running untrusted or fallible work safely.
- WAF and traffic inspection (`waf`) [within Applied security, Edge systems]: Web application firewalls, rule tuning, traffic replay, and inspecting requests without drowning operators.
- Observability (`observability`) [within Reliability]: Seeing what a running system does: traces, metering, glass-box infrastructure, and what not to log.
- Economics (`economics`): Cost, pricing, budgets, and the money side of infrastructure, inference, and innovation.
- Evaluation (`evaluation`) [within Agents, Metrics]: Measuring whether an AI system does the right thing: golden sets, structural checks, LLM-as-judge, and regression suites.
- Metrics (`metrics`): What to measure, leading versus lagging signals, and vanity numbers that look like insight.
- Formal methods (`formal-methods`) [within Programming languages]: Proofs, verification, and types as specifications, especially once machines write the code.
- Developer tooling (`developer-tooling`) [within Platform automation]: Package managers, build tools, CLIs, and the daily toolchain an engineer actually touches.
- Self-hosting (`self-hosting`) [within Platform automation, Sovereignty]: Running your own infrastructure, from a single bare-metal box to community-operated compute.
- Complex systems (`complex-systems`): Emergence and collective dynamics: how simple agents, roles, and rules add up to markets, institutions, and societies.
- Reinforcement learning (`reinforcement-learning`) [within Machine learning]: Learning from the outcomes of one's own actions: self-play, rewards, and feedback loops that turn experience into skill.
- Neuroscience (`neuroscience`) [within Life sciences]: Brains and nervous systems: connectomes, neural recording, and the attempt to model what neurons compute.
- History of science (`history-of-science`) [within History]: How discoveries were actually made: the people, instruments, dead ends, and institutions behind them.
- History of technology (`history-of-technology`) [within History]: How tools, machines, and networks came to be built, and the choices that shaped them.
- Local-first (`local-first`) [within Distributed systems]: Software that keeps data on your devices and syncs through CRDTs, with the network as an optimisation.
- Knowledge management (`knowledge-management`): Second brains, knowledge graphs, and how notes, links, and memory turn into understanding.
- Open source (`oss`) [within The open web]: Open source as the point of the work, not just its licence.
- Hypertext (`hypertext`) [within The open web]: Links as the unit of the web: addresses that can point at anything, the read-write web that was intended, and what a graph of documents can do that a tree cannot.
- Open standards (`open-standards`) [within The open web]: Protocols and formats agreed in the open and free to implement: HTTP, HTML, TCP/IP, RSS, and the consortia and working groups that keep them so.
- Decentralisation (`decentralisation`) [within The open web, Distributed systems]: Many small nodes and no central operator: the web's original shape, and the alternative to platforms that own the users and the data.
- Open data (`open-data`) [within The open web, Policy]: Data published for anyone to use: government records, archives, and the five-star ladder from a file on the web to linked data with addresses.
- Training data (`training-data`) [within Machine learning]: What models learn from: web crawls, books, and licensed or unlicensed corpora; who holds what has not been scraped yet, and on what terms.
- Privacy (`privacy`) [within Applied security, Sovereignty]: Tracking, profiling, and consent on the web, and designs that avoid collecting the data in the first place.
- Data sovereignty (`data-sovereignty`) [within Sovereignty, Privacy]: Control over one's own data: pods, portability, and the right to choose the software and the agent that reads it; the personal counterpart of national sovereignty.
- Attention economy (`attention-economy`) [within Economics, The open web]: Platforms that sell attention and optimise for engagement, what that does to the web and to discourse, and the intention economy proposed in its place.

### Technologies

- WebAssembly (`webassembly`) [within The open web]: Portable, sandboxed bytecode for running native-speed code in the browser and beyond.
- Rust (`rust`) [within Programming languages]: The systems language most of the projects here are written in.
- Haskell (`haskell`) [within Programming languages]: The language that shaped how I think about types, effects, and correctness.
- OpenTelemetry (`opentelemetry`) [within Observability]: The vendor-neutral standard for traces, metrics, and logs, including the GenAI semantic conventions for model calls.
- TypeScript (`typescript`) [within Programming languages]: TypeScript on Bun, the language of the Agent Platform Handbook code.
- Elixir (`elixir`) [within Programming languages]: Elixir, Phoenix, and the BEAM for the long-running, fault-tolerant parts.
- Pingora (`pingora`) [within Edge systems, Rust]: Cloudflare's Rust framework for building proxies, the base of Zentinel.
- Kubernetes (`kubernetes`) [within Platform automation]: Container orchestration, and the question of when you actually need it.
- GPUs (`gpus`) [within Inference]: GPUs as the computer: memory shape, partitioning, and the hardware under inference.
- Linux (`linux`) [within Operating systems]: Linux distributions and system administration, Void Linux in particular.
- OpenBSD (`openbsd`) [within Operating systems]: OpenBSD and the BSD approach to correctness and simplicity.
- Zola (`zola`) [within The open web]: The static site generator this site and several project sites are built with.

### This site

- This site (`meta`): Posts about raskell.io itself: why it exists, how it is built, and where it is going.

## Projects

- [Zentinel](https://zentinelproxy.io): Security-first reverse proxy built to guard the free web.
- [hx](https://arcanist.sh/hx/): The Haskell toolchain in one fast binary.
- [bhc](https://arcanist.sh/bhc/): The Basel Haskell Compiler, a clean-slate compiler for the Haskell you already write.
- [broodwar.live](https://broodwar.live): The community platform for StarCraft: Brood War competitive play, a basketball-reference.com for Brood War.
- [Refrakt](https://refrakt.raskell.io): A convention-first web framework for Gleam.
- [Vela](https://vela.raskell.io): No-downtime app deployment on bare metal.
- [Die Zukunft](https://die-zukunft.ch): A Swiss movement that applies engineering principles to public life: not left, not right.
- [Human Macroscope](https://github.com/human-macroscope): A long-term interdisciplinary research project on humans and human collectives across scales, from individuals and families to institutions, cultures, and civilizations: how individual traits, roles, relations, and cultural transmission combine into emergent collective properties.
- [Chronicle of Earth](https://github.com/chronicle-of-earth): An interactive atlas of history and geopolitics, starting with 1900–2026.
- [WASM-AD](https://wasmad.raskell.io): A fantasy console standard with 32-bit handheld hardware: tile layers, sprites, palettes, and save RAM, memory-mapped inside the cartridge.
- [coconutOS](https://github.com/coconut-os/coconutOS): A hard shell for AI inference.
- [Terrarium](https://terrarium.raskell.io): A societal simulation engine where LLM-powered agents form emergent civilizations.
- [Hotaru](https://hotaru.raskell.io): Simulated neuron cultures on a 60-electrode array play Pong in your browser, as in the DishBrain experiment.
- [Kishi](https://kishi.raskell.io): Chess, shogi and Go against engines written in Rust and compiled to WebAssembly.
- [Sango](https://sango.raskell.io): Edge diagnostics for the modern web.
- [Conflux](https://github.com/raskell-io/conflux): Schema-aware config state coordination.
- [Shiioo (CO)](https://github.com/raskell-io/shiioo): The Virtual Company OS.
- [Ushio](https://github.com/raskell-io/ushio): Deterministic edge traffic replay for understanding WAF and proxy behavior.
- [Driftscape](https://github.com/raskell-io/driftscape): Ambient soundscape platform.
- [robogym](https://github.com/raskell-io/robogym): Rust/Bevy PWA for training robotic agents.
- [Awesomeify](https://github.com/raskell-io/awesomeify): Index GitHub repos and generate static awesome-list sites.
- [Learn You the Web](https://learn-you-the-web.raskell.io): A friendly guide to how the web actually works.

## Apps

- [Manabi](https://manabi.raskell.io): A reading-first language-learning app for Chinese, Japanese, Korean, and Hebrew.
- [Kurumi](https://kurumi.raskell.io): A local-first, AI-native second brain.
- [Paw & Claw](https://pawandclaw.raskell.io): A turn-based strategy game in the spirit of Advance Wars, fought by woodland armies.
- [Kishi](https://kishi.raskell.io): Chess, shogi and Go against engines written in Rust and compiled to WebAssembly.
- [Rainbow River](https://rainbowriver.raskell.io): A fishing game in the style of the 32-bit handhelds, inspired by The Legend of the River King.
- [Terrarium](https://terrarium.raskell.io): A societal simulation engine where LLM-powered agents form emergent civilizations.
- [Hotaru](https://hotaru.raskell.io): Simulated neuron cultures on a 60-electrode array play Pong in your browser, as in the DishBrain experiment.

## For agents

- Each article and note as Markdown: its URL with `.md` instead of the trailing slash, e.g. https://raskell.io/articles/the-model-is-a-dependency.md
- Each talk as Markdown too, e.g. https://raskell.io/talks/iat-13-basel.md
- [map.json](https://raskell.io/map.json): the site graph (articles, notes, talks, topics with definitions, series, categories, works from the reading log, projects, and their links)
- [garden.json](https://raskell.io/garden.json): the search index as data: every article, review, note, talk, work, project, topic, and cited link, with kinds, topics, and dates
- [links.json](https://raskell.io/links.json): every external link the writing cites, with the pages that cite it and whether it is a reference
- [reading.json](https://raskell.io/reading.json): the reading log, with status, dates, ratings, and reviews
- Search as a URL: https://raskell.io/search/?q={query}&type={article|review|note|talk|work|project|topic|link}
- [api-catalog](https://raskell.io/.well-known/api-catalog): RFC 9727 discovery of the machine-readable files
- Feeds: [RSS](https://raskell.io/rss.xml), [Atom](https://raskell.io/atom.xml), [articles](https://raskell.io/articles/rss.xml), [notes](https://raskell.io/notes/rss.xml), [reviews](https://raskell.io/categories/reviews/rss.xml), [talks](https://raskell.io/talks/rss.xml)
- In the browser: WebMCP tools (search_site, list_reading, find_links, get_current_page, get_page_markdown, get_site_index, list_topics, get_connections, cite_current_page, open_page) register when an agent exposes `document.modelContext`.
- No authentication, no rate limits ([auth.md](https://raskell.io/.well-known/auth.md)). Crawling for search, answers, and training is welcome (robots.txt Content-Signal).

## Optional

- [Tags](https://raskell.io/tags/): the topic index
- [Speaking](https://raskell.io/speaking/): talks and availability
- [Contact](https://raskell.io/about/#contact): GitHub, LinkedIn, X