The loop matters more than the interface

Most conversations about AI agents get lost in abstractions. Orchestration layers. Autonomous systems. Digital coworkers. None of that is very helpful.

What actually matters is much simpler.

An agent is just a loop.

Read context. Decide what to do next. Execute. Repeat.

That's it.

Tools like Claude Code, Gemini, or Codex CLIs make this obvious because they don't hide the mechanics. You give them a loose request like "build me a weather app" and they don't magically produce an answer. They wrap that request in system prompts that give them skills, then they start doing what any junior knowledge worker would do.

They list directories. They read files. They inspect context. They decide the next step.

The key insight isn't the code they write. It's the way they get there.

This is what "agenting" actually means once you strip away the technobabble. A model looping with access to tools, building its own next prompt from the state of the world it just observed.

It feels almost disappointingly simple, which is usually a sign you've hit something fundamental.

This is already how work works

If you look closely, this loop is how most knowledge work already happens.

You skim email. You open Slack. You check a doc. You dig one level deeper. You decide what matters. You take an action.

Rinse, repeat.

The only difference is that humans have been the glue between all these systems. We carry context in our heads, translate between tools, and decide what to do next. Agent loops just make that glue explicit and automatable.

Everything on your computer is a database

I ran a small experiment to see how far this could go.

Instead of using Claude Code for coding, I gave it broad access to my Mac and treated it as a general-purpose agent. With (dangerous) permissions in place, it could read my workout data from Hevy, write directly to my Obsidian vault, spin up temporary scripts to query PostHog or Google Analytics, and even interact with iMessage.

The realization that hit me was this: almost everything on your computer already exposes a way to be queried or manipulated. Files, CLIs, APIs, local databases, helper utilities. The interface isn't pixels. It's data.

Once an agent can read and write that data, coordination becomes trivial.

A single prompt like "create a traffic and conversion report for my projects, suggest a workout for today, and turn this recipe into a shopping list" becomes a sequence of tool calls that populate a daily note without any manual glue work.

The loop doesn't care whether the domain is code, fitness, analytics, or writing. Context in, action out.

The CLI is not the product

This is where a lot of people get stuck.

The command line terrifies most users, and for good reason. It's sharp, unforgiving, and exposes too much. But the CLI isn't the future interface. It's the laboratory.

Coding was simply the first domain where this pattern was forced into the open because developers already live in environments that are text-based, inspectable, and automatable. That doesn't mean the future is agents moving cursors around screens. Pixels are a terrible abstraction for reasoning.

The real interface is skills plus data access.

The loop stays the same. The surface changes.

This feels like the smartphone moment again

This whole shift reminds me of the "Uber for X" era about a decade ago.

Smartphones had quietly matured. GPS was reliable. Payments worked. Connectivity was always on. Suddenly a pattern emerged: real-world logistics could be coordinated from a single interface. Everyone rushed to apply it to food, groceries, transport, laundry. Some companies became massive. Many failed.

What mattered wasn't the buzzwords. It was that the primitives were finally in place.

We're at a similar moment now.

LLMs can reliably reason across multiple steps. Tool use actually works. Most workflows already live in queryable systems.

That combination unlocks agent loops everywhere.

The wrapper is the product

There's a tendency to dismiss new LLM-enabled products as "just AI wrappers." That misses the point.

Uber wrapped maps, payments, identity, and real-time location. None of those were novel on their own. The value came from wrapping them into a loop that matched riders and drivers at the right moment.

The wrapping was the product.

Agent loops will follow the same pattern. Horizontal tools prove the primitive. Vertical products make it usable, trustworthy, and safe within a specific domain. Coding happened to be first because the constraints were friendlier, not because it's the end goal.

Once you see the loop clearly, it becomes hard to unsee it.

We're not watching the rise of artificial coworkers. We're watching the emergence of a new primitive for coordinating work.

And like smartphones, it will feel obvious in hindsight.