Original: Naveen Naidu · 02/02/2026
Summary
Instead of building features, you give an AI agent primitive tools and let it figure out how to accomplish what the user wants. I keep coming back to the concept of “agent-native” architecture. The idea is simple: instead of building features, you give an AI agent primitive tools (read file, write file, search) and let it figure out how to accomplish what the user wants.Key Insights
“Instead of building features, you give an AI agent primitive tools and let it figure out how to accomplish what the user wants.” — Introducing the concept of agent-native architecture.
“This isn’t just infrastructure. This is the backend for agent-native apps.” — Describing the role of Sprites.dev in enabling agent-native applications.
“Features emerge from primitive tools combined with good judgment.” — Summarizing the emergent behavior when AI agents are given basic file operations.
Topics
Full Article
Building an Agent-Native Read Later App in 2 Hours
Author: Naveen NaiduPublished: 2026-02-02
Source: https://www.naveennaidu.com/writing/building-agent-native-read-later
Building an Agent-Native Read Later App in 2 Hours
January 12, 2026 I keep coming back to the concept of “agent-native” architecture. The idea is simple: instead of building features, you give an AI agent primitive tools (read file, write file, search) and let it figure out how to accomplish what the user wants. Makes sense on paper. But every time I tried to imagine actually building something like this, I hit the same wall.The Problem I Couldn’t Solve
Here’s what agent-native architecture looks like on paper:- User’s data lives in a file system
- An LLM has access to file operations
- User asks for something, agent loops until it’s done
The Article That Unblocked Everything
Then I read Code And Let Live from fly.io. Kurt Mackey’s argument: AI agents need durable computers, not ephemeral sandboxes. The industry has been giving agents temporary environments that vanish after each task, forcing them to rebuild context every time. It’s like wiping someone’s memory between conversations. His solution: sprites.dev. Persistent Linux containers that:- Spin up in 1-2 seconds
- Persist state across sessions
- Automatically pause when idle
- Include 100GB of storage
- Come with built-in HTTPS URLs
The Weekend Hack
I had exactly 2 hours. It was a Sunday morning at a “Vibe Coding” session at the office. Dan Shipper was there. Willie, head of platform at Every, too. We were all building something with AI. My idea: a read-later app where I save articles and can chat with an AI about them. Ask for summaries. Find connections between topics. Generate notes. The constraint: 2 hours, then I’m leaving for lunch. I opened Claude Code and started building.The Architecture
The app has three layers: 1. Per-user Sprites When a user signs up, they get their own persistent Linux container. Inside it:read_file- Read any file in /librarywrite_file- Create or update fileslist_files- List directory contentssearch- Grep across all filesdelete_file- Remove files
summarize_article tool. No generate_reading_profile tool. Just primitives.
What matters is what the agent can compose from these.
The Emergent Behavior That Blew My Mind
After building the basic app, I saved a few articles I’d been meaning to read. Then I opened the chat and typed:“Based on my saved articles, what are the main themes I’m interested in? Create a reading profile for me.”I watched the agent work:
reading-profile-analysis.md file to my notes.
The result was a comprehensive breakdown of my reading patterns:
- Building in Public & Sharing Work - I’m drawn to transparency and public creation
- AI-Powered Development - Interest in how AI is changing software development
- Mindful Living & Intentional Solitude - Despite tech focus, I value disconnection
- Infrastructure Philosophy - Drawn to contrarian takes that challenge orthodoxies
I didn’t build a “generate reading profile” feature. I gave the agent files and file operations. It figured out the rest.
Features emerge from primitive tools combined with good judgment.
How It Actually Works
Let me walk through the key pieces.User Sprites
When a user authenticates, I check if they have a sprite. If not, I create one:The Agent System Prompt
I inject context about what the agent can see and do:The Agent Loop
When a user sends a message, the agent runs in a loop until it’s done:Tool Execution on Sprites
Each tool call runs a command in the user’s sprite:Why Files?
Claude (and other LLMs) are good at working with files. They understand directory structures. They can parse markdown. They know how to organize information. When I save an article, it becomes a markdown file with YAML frontmatter:The API Key Problem: Solved
Here’s how the security model works:- User authenticates with my API (email/password → session token)
- My API has the Sprites token and Anthropic key
- User sends chat message to my API
- My API runs the agent, executing tool calls on the user’s sprite
- Results stream back to the user
What I’d Tell Someone Building This
If you’ve been interested in agent-native architecture but didn’t know where to start: 1. Sprites.dev is the missing infrastructure. It handles the hard parts—container orchestration, persistence, networking—so you can focus on the agent. 2. Start with file primitives.read_file, write_file, list_files, search. You’ll be surprised what the agent can compose from these.
3. Inject context, don’t make the agent discover it. Tell the agent what exists in the system prompt. Discovery wastes tokens and time.
4. Let features emerge. I didn’t plan the reading profile feature. The agent invented it. Your users will ask for things you never imagined.
5. Files are transparent. Unlike databases, files are debuggable. You can see exactly what the agent did. This matters when things go wrong.
What’s Next
I built this in 2 hours. It’s rough. There are bugs. The UI needs work. But I can save articles. I can chat with them. The agent can create notes I never asked for but actually want. For the first time, I have a read-later app that understands my reading patterns better than I do. Not building features. Building environments where features can emerge.Key Takeaways
Notable Quotes
Instead of building features, you give an AI agent primitive tools and let it figure out how to accomplish what the user wants.Context: Introducing the concept of agent-native architecture.
This isn’t just infrastructure. This is the backend for agent-native apps.Context: Describing the role of Sprites.dev in enabling agent-native applications.
Features emerge from primitive tools combined with good judgment.Context: Summarizing the emergent behavior when AI agents are given basic file operations.
Related Topics
- [[topics/agent-native-architecture]]
- [[topics/ai-agents]]
- [[topics/persistent-linux-containers]]
Related Articles
How to Build Agent-native: Lessons From Four Apps
Dan Shipper (Every) · explanation · 83% similar
Agent-nativeArchitectures
Dan Shipper (Every) · how-to · 80% similar
Building agents with the Claude Agent SDK
Anthropic Engineering · tutorial · 75% similar
Originally published at https://www.naveennaidu.com/writing/building-agent-native-read-later.