What AI-native
looks like
A working operating model for task boards, agent teams, private plugin stores, evidence, memory, and human approval.
AI-native is not a nicer chat box. It is a way of running work where agents have task systems, tool stores, memory, evidence, and explicit approval boundaries. My personal system, Reeves, is the clearest example I have.
The problem
The usual AI workflow is still a person sitting in front of a chat box, pasting context, waiting for an answer, and manually moving the result into the next system. That is useful, but it is not the operating model I think survives.
My current workflow is closer to a company made of agents. I manage six Linear teams with roughly a thousand open tasks and an unusually active completion rate. Reeves is my personal AI chief of staff. It handles travel, properties, retirement-account work, accounting, shopping, research, subscription control, and the boring connective tissue that normally sits between personal systems.
The other teams cover Eidos work, AI research, client/work systems, and new ventures. The important part is not the number of teams. The important part is that each team has a task surface, memory, evidence rules, and its own plugin store. The agent does not just answer. It accumulates tools and operating knowledge.
That is the rare move: treating AI work like an operating system that compounds, rather than a sequence of disposable conversations.
The approach
Reeves runs through Codex as the main surface, then delegates to Claude Code, Hermes, Perplexity, Ollama, browser workers, and other local agents when the work calls for it. The system spans three Macs. Linear is the action board. The repo/wiki layer is the evidence store. Plugins and skills are the behavior layer.
Work surface
- Linear teams hold the task graph, ownership, status, and priority.
- Each team has its own plugin-store context and operating memory.
- Agents route work to the right runtime instead of forcing every task through one model.
- Evidence survives outside the chat that produced it.
Control surface
- Human approval gates sit in front of money, credentials, email, and destructive actions.
- Financial claims are not public until screenshots, confirmations, or ledgers support them.
- Private names, account details, addresses, and file paths are redacted before publication.
- Agents improve the tools they use, but the durable record remains inspectable.
Eidos has been working since 2024 on proprioception and meta-cognitive algorithms for this pattern: agent teams that notice their own failures, improve their own plugin stores, and leave better tools behind for the next run. Storemetheus is the public version of that idea: a free plugin store that teaches agents how to build and maintain private plugin stores.
task enters Linear:
team: Reeves
owner: agent or human
boundary: read-only, approval-required, or human-only
agent runs:
choose runtime
gather evidence
update task state
improve plugin if repeated friction appears
boundary appears:
stop before money, credentials, email, or destructive changes
request explicit approval
preserve proof after actionThe evidence
The screenshots below are redacted, but the structure is intact. Reeves is not a single prompt. It is a personal operating board with issues, projects, labels, dates, progress, and evidence rules. The private text is hidden because the point is the operating pattern, not the details of my errands, accounts, or properties.
The most valuable asset is not the visible board. It is the accumulated problem-solving trace behind it. Reeves has access to roughly 12,500 chats from the last two years, about nine gigabytes of hard-won context across software, finance, property, operations, and personal systems. I treat that history as an asset because every solved problem can become searchable leverage for a future problem.
There is one proof boundary I am intentionally not crossing in the public article yet. Reeves did real investment research and a Vanguard workstream captured a list of pending buy orders on May 14, 2026. The public claim that the resulting portfolio was up about nine percent needs final executed-trade and holdings evidence before I will present it as proven. The private publishing pack keeps that screenshot request on the checklist.
Before and after
- The user pastes context into a single thread and asks for an answer.
- The output is copied into the real system by hand.
- Lessons disappear unless someone summarizes them later.
- Tools are general and static.
- Approval is an informal sentence inside the same chat.
- The task enters a durable board with status, owner, scope, and evidence rules.
- Agents choose the runtime and update the system of record.
- Evidence and learned patterns become searchable memory.
- Plugins improve when the team encounters repeated friction.
- Risky actions route through explicit human approval boundaries.
The result
My working philosophy is that code is debt and solved problems are assets. Reeves is instructed to write as little code as practical. The goal is to solve the problem, preserve the evidence, improve the reusable tools, and make the next similar problem cheaper.
This is not a new instinct. Years ago I made roughly $300,000 in profit on an Airbnb sale by keeping hundreds of pages of notes, collecting field intelligence from hotels during a 50-state road trip with my kids, and continuously improving the property. AI makes that style of data collection and operational learning cheap enough to apply everywhere.
That is what AI-native looks like to me right now: not a model demo, not a single agent, and not a pile of code. It is a compounding system of tasks, tools, memory, evidence, approval, and taste. The chat is just one interface into it.