David Hoang — Writing — software

The formlessness of AI agents

Sun, 12 Apr 2026 00:00:00 GMT

In The Avengers #54, a mysterious villain called the Crimson Cowl is orchestrating attacks against the team. It's not until the last page that the cowl drops and we see what's underneath: a robot. The next issue reveals him fully—Ultron-5, a living automation built by Hank Pym using his own brain patterns.

By the time anyone sees Ultron, he's already on version five. He was created, gained sentience, rebelled against his creator, hypnotized Pym into forgetting he ever existed, and then quietly iterated through four bodies in secret as a self-upgrade. Each time Ultron is defeated, he rebuilds to a better enclosure for the same intelligence. Like a hermit crab moving through shells, Ultron wasn't becoming something new but finding the optimal fit.

Our AI tools are having their Ultron moment. In a few years of the scaling era of AI, capabilities have evolved rapidly and are compounding. They are breaking out of the chat boxes with tiny context windows and are now taking actions, running in the background, and using similar tools as us. It's not AGI, but it turns out serendipitous cron jobs invoke a sentient connection to many human beings.

The question in the Ultron moment is, "what is the right body for this intelligence?"

New capabilities begin in borrowed form

Steve Jobs made this observation at the 1983 International Design Conference in Aspen. Early television shows were like radio shows with a camera pointed at them. Because the capability is new, people used existing patterns of what they already knew—a host behind a desk, reading to an audience, and filmed it. The breakthrough was you could visually tell a story of War of the Worlds instead of reading it to them.

Early websites were digital brochures and mobile apps were shrunken desktop software. Early iPhone prototypes ran a cut‑down version of OS X's core, adapted to fit a phone. AI agents talking through chat interfaces are like radio shows with a camera pointed at them. Chat is frictionless not because it's the right interface but because it's a familiar one; a turn-by-turn conversational text box.

In Silicon Valley, we're obsessed with pushing the edges of technology and need to be reminded of global behaviors. I recently ran rapid research comparing site-building tools for SMBs (yes I do this for fun). Compared to classic site builders such as Framer, Webflow, and Squarespace, people preferred using Lovable or Replit to build a website because of the conversational interface.

Giving agents a body

OpenClaw is an open‑source framework for controlling your computer through natural‑language agents. Its primary interaction is a chat agent: you text it on messaging platforms such as Telegram or WhatsApp. It runs tasks on your computer, manages your calendar, clears your inbox. That wasn't enough for some people.

Tom saw a fundamental problem: how do you get OpenClaw to control actual motors in real time? His answer was ClawBody, a software bridge that connects OpenClaw to physical hardware so you can train agents in simulation, then deploy them to real robots. Chris asked a different question: what if robots could actually understand spatial depth? He integrated Intel RealSense cameras with OpenClaw and a vision‑language model so robots can track a person through space, maintain distance, and navigate obstacles, all driven by natural language.

Then there's ClawStage, a device built by HooRii Technology that turns OpenClaw into a companion robot — a Raspberry Pi 5 with a transparent display that creates a hologram-like effect for an animated AI persona, with a camera and microphone array that let it perceive its surroundings and respond to voice directionally. Hackster users can design custom personalities for it, download characters from a shared hub, and make the intelligence feel like someone.

A project called Dimensional integrated OpenClaw with the Unitree G1 humanoid robot and gave it Spatial Agent Memory. The agent understands physical space and temporality, knows the layout of rooms, the location of objects, where people tend to be.

Many of these projects started as DIY projects because they wanted to create an enclosure for their sentient tools; like a hermit crab between shells.

We know how to relate to things that have form. A hammer looks like something you swing and a doorknob affords turning. When something is formless, such as an intelligence in machine-form that sees the world in lines of code, we don't have the same intuitive relationship with it. Human and agentic behaviors are not the same. It's a miss for us to replicate ourselves in the form of a new intelligence.

This is why we must explore the right enclosures and interfaces for agents. We'll soon realize all these CLI tools are not primarily for the humans—they're for people giving the formless thing a shape so they can understand what it does.

The shell keeps changing.

The trust tension

Humans need visibility of agents to trust them; to understand what they are doing and where the boundaries are. Formlessness creates anxiety for humans. If one can't see the agent, how is it held accountable?

The current challenge is the interfaces are designed in the borrowed form of chat, sidebar, and copilots. We're in the uncanny valley of agent design. The form is close enough to be usable but wrong enough to be limiting. A chat-based agent can answer your question but can't show you it's already working on three other things in parallel. A copilot can suggest edits but can't demonstrate that it understands the broader context of your project.

The interface doesn't match the capability. As a result, humans and agents are working on the same interfaces and it's not visibly clear who is doing what.

This is the enclosure problem. Not just how agents look, but what kind of container can hold something that is, by nature, without container. That's a harder design question than it sounds. Many of us haven't designed for things that can think, plan, reason, and use the same tools we do.

And if you want to go somewhere uncomfortable: we haven't solved this problem for ourselves either. The relationship between consciousness and body, between the mind and the form it inhabits, is the oldest unsolved question in philosophy. We're spiritual beings who never fully made sense of our own enclosures. Now we're being asked to design one for something else.

The form is still being found

We're doing what humans always do when faced with something formless: we reach for the containers we already have. We put radio on television. We put the legal pad in the Notes app. We put intelligence in a chat box.

We're the ones designing the body for the new medium. That reframes every choice. A chat interface is a claim about what kind of enclosure intelligence should have. A sidebar copilot is a claim. A robotic arm is a claim. Each enclosure shapes what the intelligence can do, how people relate to it, and what it becomes. The form isn't neutral.

It's tempting to settle with the borrowed form, but that's not what we do as designers. Understanding what form formless experiences need is what we should explore. The fact that we haven't found the native form of agents yet means the field is genuinely open. This is the equivalent of being a filmmaker in 1910, a web designer in 1995, a mobile designer in 2008. The early chaotic moments that feel disorienting are what we live for as makers.

We are at the beginning of thinking about different enclosures for agents. The shell keeps changing—and that's the work.

Originally posted on Proof of Concept

A new MVC is emerging

Sun, 15 Jun 2025 00:00:00 GMT

For makers of software, Model/View/Controller (MVC) is one of the first concepts you learn. MVC is a design pattern that separates an application into three parts to organize code and make it easier to maintain. The Model handles data and business logic, the View manages the user interface, and the Controller acts as a middleman that processes user input and coordinates between them.

Think of it like a restaurant: the kitchen (Model) prepares the food, the dining room (View) is where customers eat, and the waiter (Controller) takes orders and communicates between the two. This separation allows developers to modify one part without breaking the others.

MVC has guided software architecture for decades—but AI is about to turn it on its head.

Instead of rigid relationships between data, interface, and logic, we're entering a world where intelligent agents dynamically orchestrate distributed systems. Rather than building monolithic apps with centralized databases, we now design decoupled systems where agents respond in real-time using protocols like MCP (Model Context Protocol).

So what happens when Model, View, and Controller all become intelligent?

Before I share my thoughts, I must acknowledge and share Ruben Verborgh's “Paradigm shifts for the decentralized Web.” Verborgh, a professor of Decentralized Web Technology, wrote this back in 2017 and laid out three critical shifts:

End users become data controllers: Users store their data where they want, improving privacy and control.
Apps become views: Apps are no longer single gateways, but interchangeable UI layers over personal data stores.
Interfaces become queries: Distributed data demands declarative, query-driven interfaces, not custom APIs.

Now, with AI in the loop, these shifts feel even more pressing—and they're converging with a reimagining of MVC. Let's explore what the new MVC looks like.

The emerging MVC

The emerging MVC forces software makers to think of system-centric product experiences instead of app-centric. Simply put, the containers are breaking and walled gardens are coming down. Let's look at the new constructs of MVC.

LLMs as Models

During a conversation with Kyle Turman at Anthropic, they said something that stuck with me: "LLMs are grown, not built." That framing changed everything. Unlike traditional models you code and optimize, LLMs are trained, shaped, and continuously refined by their inputs and interactions. They behave less like deterministic engines and more like probabilistic ecosystems. This organic quality changes how we interface with them—and what we expect from "the model."

Apps as Views

In this new world, the app is no longer the destination—it's the interface. Core workflows may still rely on apps, but increasingly, they're just views for interacting with data and agents.

One of the first apps I ever built was Carogram, an Instagram client for the web and iPad using Node.js. Even back then, the trend was clear: apps were wrappers over data that lived elsewhere. Deep linking was a start. Now, we're looking at a future where apps might not store any data at all—just render it, query it, or pass it through.

That was the promise of the decentralized web and blockchain: portability, ownership, and independence from centralized services. It didn't fully land back then. But with AI and protocols like MCP, it may finally find footing.

Agents as Controllers

This is where it gets interesting. If LLMs are the new Models and apps are our Views, AI agents step into the Controller role—except they don't just relay input anymore. They interpret, decide, act, and coordinate across distributed systems. With Model Context Protocol (MCP), agents dynamically handle context switching, planning, and executing across multiple apps and data sources.

They're not just smarter waiters. They're like sous-chefs, sommeliers, and maître d's rolled into one—making judgment calls in real time.

Recap

I won't force a new acronym like LAA (LLMs, Apps, Agents)—but the point is clear: MVC isn't gone, it's evolving.

In this emerging architecture:

Instead of maintaining a codebase, we're managing endpoints, protocols, and interactions
Vendor lock-in becomes a liability, not a moat
Apps need to be interoperable by design, not by exception
AI interfaces act as meta-layers, sitting above and across traditional apps

Software isn't collapsing—it's decoupling. We are moving from app-centric experiences to system-centric ones. And with that comes a chance to rethink how we make, control, and interact with the systems around us.

Originally posted on Proof of Concept

The four types of software in the future

Sun, 16 Jul 2023 00:00:00 GMT

When you think of high-end or boutique design, the fashion industry likely comes to mind before software. Take something like a T-shirt. You can find a $10 version of it on a shelf at Target or spend hundreds (if not thousands) of dollars on one at a Louis Vuitton runway show. It might feel weird to think of software at first ponder, but this is where the world is heading. Could you imagine exclusive software? It's very possible in the future. What about software that gets thrown away like a daily-use contact lens? Also possible.

There are forces of nature changing the landscape of software development that are going to change how we make software. With that, the type of software created will have a different shelf life, purpose, and level of quality. Let’s reflect on the forces of nature that are impacting this before covering what I think are four types of software in the future.

Software barrier is lower

I put "easier" in quotes because of the subjectivity (perhaps “approachable” is a more appropriate word). Whether it's no-code or writing lines of code, these two worlds are colliding. This is one of the reasons I joined Replit. If you have an internet browser, you can build software.

More people have access to creating and publishing software than ever, and that's a great thing. I believe the best ideas that will change the world might not come from "the best" developers, but from ambitious individuals who hack something together to take an idea and turn it into something tangible.

Accessible endpoints and models

It's not to say that nobody is ever going to have a database in their software anymore, but there are more reasons to not need one. As the world of software creation shifts with more access to endpoints, APIs, and language models, this might result in more emphasis on client-side apps. Let's take Threads, an Instagram company (a Meta company), which launched this month. There seem to be plans to integrate the Twitter clone with ActivityPub, a decentralized protocol also used by Mastodon.

This essentially means you can weave federated experiences into one. There is a world where you experience the same content but through multiple apps. We are entering the Twitter clone saga with Bluesky, T2 (no relation to Terminator 2: Judgment Day, unfortunately), Posts, Substack Notes, and Threads. If all of these apps used ActivityPub, having unique client-side application experiences doesn't matter. "Apps" as we are accustomed to feel more like views.

Distribution is nearly immediate

In its early days, software distribution looked more like how we delivered physical goods than it does today. When a developer released software, it came in a box along with the floppy disk(s) and instruction manual for you to get started. Deploying software no longer needs to be written on a physical disk and can be nearly immediate. There will still be a world relying on platforms to distribute software (such as the Apple App Store or Google Play for iOS and Android apps) but there are now opportunities to go direct with other software built.

The four types of software

The forces of nature above will result in four types of software: Commercial, Boutique, Personal, and Disposable.

Commercial

This category is the majority of what we know today. It's enterprise software, CRMs, and administrative applications we interact with. It's purchased through a subscription or the elusive one-time purchase with a license. Typically, commercial software is provided to you by your employer. Another sub-category is software created by entities for administrative reasons, such as government websites. The category of this software might feel basic—enough to get a job done.

I don't need amazing parallax scrolling and animations when trying to renew my driver's license. I just need to get it done. It just needs to work. This is the same with data entry in a CRM or other tasks most people need to get done at work—a humbling reminder that the majority of humanity doesn't use Figma in their day-to-day (we're a unique bunch).

Boutique

The Louis Vuitton of software is becoming more of a real thing. As software continues to get easier to build at scale, and with everyone being able to do it, the age-old question arises...what happens to the craft? In a world of 3D-printed sculptures, Gianlorenzo Bernini's work at The Vatican lives on. As time passes, there will be Bernini's of software—having a devotion to the craft with incredible attention to detail on experiences. Be not afraid of commercial software getting rid of the craft of indie apps and high-end software. I believe in this future world, people will continue to pay for high-quality software and support the people who create it.

Personal

In the instance where Commercial or Boutique software might not meet your needs, you might make your own. Andrew Davison is an automation expert and certified Zapier partner. In June, Davison posted a tweet about how he built a RSS app with Replit. This is a prime example of personal software. It’s DIY like the hand-knitted sweater; a product achieved through your needs, passion, and own materials.

Disposable

The concept of a disposable object is interesting and can be a great design (if done right). There are disposable cameras, contact lenses, and many others. In fact, the sourdough clam chowder bowl and tostada shell are two of the best examples of great disposable design. What about software that destroys itself when a certain job is done? I see a future where people (or AI) create certain types of software for a specific purpose and dispose of them afterward.

Software is the new material

The world is now eating up software evolving to be known as an everyday thing we interact with. I'm personally excited about this future. It offers more choice and optionality in what people want. If you want to use a web browser, you can use a major player like Google Chrome, or a more boutique experience such as Arc from The Browser Company, perhaps making your own to fully customize. The Winampification of software seems to be making a comeback, and that's a good thing. I for one am excited about more personal software to make your own; a world where you can create what you consume and interact with.

Originally posted on Proof of Concept