Doctrines
08Eight principles. Everything we build traces back to these.
UI Parity
Whatever the user can do through the UI, the agent should be able to achieve through tools. If there's a button a human clicks, there should be a tool an agent calls. No exceptions. If your agent can't do what your user can, it's a second-class citizen in your own product.
Atomic Tools
Tools should be atomic primitives. Features are outcomes achieved by an agent operating in a loop. Don't bundle decisions into tools. The agent is the decision-maker. Tools just execute. A tool that does three things is three tools pretending to be one.
Prompts as Features
With atomic tools and parity, you can create new features just by writing new prompts. No code required. When you need a new capability, write an instruction — not a function. The codebase stays small. The capability surface grows through language.
Emergent Capability
The agent can accomplish things you didn't explicitly design for. This is a feature, not a bug. When you give an agent good tools and don't over-constrain it, it solves problems you didn't anticipate. The best agent-native features are discovered, not built.
Compounding Context
Agent-native applications get better through accumulated context and prompt refinement — not just code updates. Traditional software improves through engineering. Agent-native software improves through memory. The longer it runs, the better it gets.
Single Agent > Swarm
One well-equipped agent with good tools, durable context, and strong prompting beats a fleet of fragile, specialized agents. The emerging consensus across labs points the same way. Complexity is the enemy. Orchestration is overhead. Give one agent what it needs.
Build-Learn-Build
Build products. Discover what agents need to run them. Build that layer. Repeat. This is our operating rhythm. Not a methodology — a loop. Every product we ship teaches us what's missing in the stack. Every layer we build makes the next product better.
The Web Isn't Agent-Ready
Current software and the web assume a human operator. That's the gap. Every layer we build closes part of it. The interfaces, the authentication, the feedback loops — they're all designed for humans. Agents need different primitives. We're building them.