infrastructure, not apps

by Ray Svitla

the problem with most AI products isn’t that they’re bad. it’s that they’re apps.

they want to be your interface, your workflow, your everything. use our chat window. store your data on our servers. trust our API limits. when the service goes down, your workflow stops. when they pivot, your workflow breaks. when they get acquired, your workflow belongs to someone else.

this is the wrong layer to build on.

the unix philosophy, applied to agents

the best tools don’t try to be everything. they do one thing well and compose with other tools.

grep doesn’t have a GUI. it doesn’t store your data. it doesn’t need an account. it reads stdin, writes stdout, and gets out of the way. you pipe it into other tools. you wrap it in scripts. you build on it.

this is what personal AI infrastructure should look like.

today’s signals prove the pattern is emerging:

OpenSandbox: safe execution as a service

Alibaba shipped a multi-language sandbox platform. Python, TypeScript, Go. Docker, Kubernetes. one unified API for “run this code safely.”

it’s not an app. it’s plumbing.

every agent that writes code needs isolation. OpenAI’s codex has sandboxing. Claude Code has it. but until now, if you wanted to build your own agent stack, you had to roll your own. OpenSandbox changes that.

the paradigm: safe execution isn’t a feature. it’s infrastructure.

WiFi DensePose: sensing without surveillance

someone turned WiFi routers into motion sensors. radio waves bounce off your body, phase shifts decode into pose estimation + vital signs + presence detection. no cameras. no pixels.

why does this matter for personal AI?

if your home is your AI OS, it needs sensors. but cameras feel invasive. Ring doorbells, Alexa with screens, smart home cameras — they all trigger the same instinct: I’m being watched.

WiFi DensePose is ambient sensing without surveillance aesthetics. your router already exists. the radio waves already bounce. the data stays local.

privacy by design, not by policy.

MobileAgent: your phone, automated

Alibaba’s mobile GUI agent navigates apps, taps buttons, reads screens. Android, iOS. it doesn’t need APIs. it uses the UI. the way you do.

the shift: most agent demos run on desktop. developers showing off coding workflows. but your phone is where you live. messages, calendar, tickets, food orders, banking. if AI can’t touch your phone, it can’t touch your actual workflow.

MobileAgent is infrastructure for agents that live where you live.

learn-claude-code: demystifying the stack

someone built a nano Claude Code from scratch. in bash. the repo walks through: prompt loop, tool calling, file editing, error handling. no abstractions. just the raw mechanics.

why does this matter?

most people use agents. few understand them. when the tool breaks, they’re stuck. when the vendor changes pricing, they have no leverage. when a new paradigm ships, they wait for someone else to build it.

understanding the stack changes the equation. you’re not a user anymore. you’re a builder.

the Feynman technique: if you can’t build it from scratch, you don’t really know it.

markitdown: documents as data

Microsoft shipped a universal document converter. PDF, DOCX, PPTX, images → Markdown. open source. one command.

the workflow problem: your agent needs to read documents. but PDFs are binary blobs. DOCX is XML nightmares. every format has its own quirks.

markitdown normalizes them all. one format: Markdown. git-diffable. agent-readable. human-editable.

if your life is a repo, your documents need to speak the same language.

OpenCowork: self-hosted coordination

open source alternative to Claude Cowork. multi-agent workflows, Windows & macOS, self-hosted.

the insurance policy: if cowork becomes the standard for multi-agent coordination, we need an open version. vendor lock-in at the OS layer is existential risk.

your agent OS should be yours. not rented.

the pattern: build on substrate, not services

every signal today follows the same logic:

→ don’t build apps. build infrastructure.
→ don’t rent compute. run it locally.
→ don’t trust black boxes. understand the stack.
→ don’t lock in. compose tools.

this is the unix philosophy for the AI era.

the personal AI OS doesn’t need more features. it needs better plumbing. sandboxes. sensors. document parsers. coordination layers. educational resources. all open. all composable. all local-first when possible.

when the next paradigm shift happens — and it will — you won’t wait for someone to ship it. you’ll build it yourself. because you understand the substrate.

what this means for you

if you’re building on AI right now, ask yourself:

→ am I building an app or infrastructure?
→ can my users self-host this?
→ does this compose with other tools?
→ if my service dies tomorrow, do users lose everything?

if the answer to the last question is “yes,” you’re building on quicksand.

the future isn’t vendor platforms. it’s composable infrastructure. tools that do one thing well. that you can pipe together. that you control.

grep for the agent era.

Ray Svitla
stay evolving 🐌