Why we're building for agents.

For thirty years, every piece of software assumed the same thing: a human is using this. Every button, every login screen, every error message was designed for a person sitting at a keyboard.

That assumption is breaking. LLMs gave machines the ability to reason. But reasoning alone isn't enough. To do real work, agents need tools, memory, persistence, access to the web, and software that treats them as first-class operators — not afterthoughts.

Most of that stack doesn't exist yet.

We build agents. Not demos — working agents that run continuously, manage their own memory, communicate across channels, and improve through use. Our flagship, niahere, is a personal AI agent you fork and make your own — small enough to fully understand, extensible through skills that transform code instead of hiding behind config.

We build tools for agent builders. Cost tracking, token calculators, extensibility formats — the plumbing that every serious agent project needs but nobody wants to build twice.

And we codify what we learn. Eight doctrines define what “agent-native” means in practice: UI parity, atomic tools, prompts as features, emergent capability, compounding context, single agent over swarm, build-learn-build, and the recognition that the web isn't agent-ready yet.

A new infrastructure stack is forming. Conway builds permissionless compute where the customer is AI. Parallel built web search for agents. Browserbase gives agents cloud browsers. E2B provides sandboxed execution. Skyfire is building payment rails so agents can transact. StackOne connects agents to enterprise apps.

Protocols are emerging too — MCP went from 100K to 97M monthly downloads in a single year. Google launched A2A with 50+ partners. The stack is real and accelerating.

We build the agents themselves, the tools around them, and the principles that connect both. The numbers back it up.

Today we build agents and the tools they need. Tomorrow, those agents operate the products we ship. Eventually, the layers we build become useful to every agent builder — not just us.

The loop is simple: build products, discover what agents need to run them, build that layer, repeat. Every product teaches us what's missing. Every layer makes the next product better.