I. OpenClaw is a structural event.
What makes OpenClaw shocking isn’t a new algorithm. It’s the fact that it exposes a new reality:
LLM capability + local execution privileges + open-source scaffolding is already enough to rewrite how software gets produced.
When a solo developer can stitch together an agent with something close to “OS-level permissions” using off-the-shelf models and open frameworks, it tells us something uncomfortable yet important: raw capability is no longer scarce. The scarce variable is now composability—the ability to combine tools, permissions, and workflows into outcomes.
And composability isn’t linear. It’s exponential. When your building blocks are callable functions, “more blocks” doesn’t add—it multiplies.
II. Why “80% of software” gets swallowed
Once agents can:
understand natural language intent directly,
break a task into steps automatically,
call tools dynamically,
and correct their own execution paths in real time,
a huge category of “workflow-frozen software” starts losing value fast.
For decades, software has trained humans to adapt to software. You open the right app, learn the right menu tree, follow the prescribed workflow, and hope your problem fits the box. The agent era flips the direction: software adapts to human intent.
That shift has a brutal implication: the core of software stops being UI, menus, and fixed workflows. The core becomes APIs and capability interfaces. Everything in the middle—the layers whose main job is turning workflows into a clickable experience—gets compressed.
Many products won’t “die.” They’ll be absorbed.
Tools that are mostly UI-wrapped procedures.
SaaS products that are largely data shuttling.
Systems whose main value is rigid rule execution.
Agents don’t need to replace them by competing head-on. They can simply embed them as invisible steps in an orchestration graph.
III. The moat is moving
Traditional software moats looked like:
complex feature depth,
data lock-in,
sticky workflows,
custom enterprise integrations.
But in an agent world, features can be composed on demand, workflows can be generated dynamically, and data can be surfaced through standardized interfaces. The moat migrates to things that are harder to synthesize by “tool composition” alone:
high-quality proprietary data assets,
specialized vertical knowledge,
security, compliance, and governance maturity.
Put bluntly: software shifts from selling features to selling capability access and safe execution.
In the agent era, the winning product is less “a beautiful UI” and more “a reliable interface to real power—with guardrails.”
IV. Startups are being rewired
The classic playbook for software startups was familiar:
pick a scenario,
build a product,
polish the UX,
retain users,
scale subscriptions.
The agent-era playbook is different:
pick a high-value capability domain,
expose it as an agent-callable interface,
integrate into the skills ecosystem,
create value through execution, not clicks.
Entrepreneurship shifts from “building an app” to building callable capability modules.
In a world where agents orchestrate work, owning the right tool interface is like owning a critical interchange on a highway system. You don’t need to be the entire city. You just need to sit on the route everything passes through.
V. Investment logic is being repriced
Investors used to ask:
How many users do you have?
What’s your ARR?
What’s your SaaS retention?
Increasingly, the questions will mutate into:
Can your capability be orchestrated by agents?
Do you control a defensible data interface?
Is your execution verifiably safe—auditable, permissioned, compliant?
Valuation logic will follow. Pure “feature SaaS” gets pressured. Execution infrastructure and governance layers get rewarded.
Because in the agent era, the truly expensive asset isn’t UI. It’s the right to execute—safely.
VI. Local agents are a transitional form
OpenClaw’s explosion also reveals something practical: demand for action-oriented AI is already there. People don’t just want a model that answers. They want a system that does things.
But local deployment is likely a bridge, not the destination. At scale—especially in enterprises—agents will converge toward:
cloud integration,
enterprise-grade governance,
least-privilege architectures,
compliance and audit systems.
Individuals can unlock power by removing constraints. The commercial world must do the opposite: it has to constrain power before it ships.
The long-term winners won’t be those most willing to grant authority. They’ll be those best at granting authority safely.
VII. Software won’t disappear. It will become invisible.
OpenClaw’s creator suggested that “maybe 80% of software will lose its value.” The number may be rhetorically inflated. But the direction is right.
Software doesn’t vanish. It goes dark.
Users stop operating software directly. Agents operate software on their behalf. Products shift from foreground experiences to background capability modules.
That’s not a collapse. It’s an industrial migration.
VIII. The real watershed isn’t OpenClaw. It’s what it forces us to talk about next.
OpenClaw isn’t the endpoint. It’s the first public, living demonstration of something many suspected:
LLMs are already capable of executing real-world tasks—if you give them the keys.
For the past two years, the mainstream conversation was “intelligence augmentation.” In the next few years, the dominant conversation will be delegated execution:
Who sets the boundaries of capability?
Who defines execution permissions?
Who bears responsibility when things go wrong?
Those questions—more than model size or benchmark scores—may determine where the next generation of tech giants comes from.
Closing
The significance of OpenClaw isn’t what it did. It’s what it made obvious:
the software era is ending, and the capability era is beginning.
And in the capability era, what’s truly scarce isn’t the model. It’s controllable execution power.
Authority and safety are natural enemies. The biggest winners will be the ones who can make them coexist—without pretending the tension isn’t real.
https://liweinlp.com/category/english
