I do not think the next big step in computer history is just a chatbot alone.

A chatbot is a mouth. Useful, sometimes brilliant, often wrong. The interesting part starts when the mouth is connected to hands: files, tools, browsers, terminals, tests, notes, permissions, memory, and a machine it can actually work inside.

That is why I am building this website by voice.

Not because it is the fastest way to make a blog. It probably is not. I am doing it because I want to know how far the new interface already reaches.

#The Old Deal

For decades, computers made us translate our thoughts into machine-shaped instructions. First commands. Then menus. Then icons, windows, folders, buttons, forms, touchscreens. Every generation made the machine easier to reach, but the basic deal stayed the same: the human had to learn the interface.

Language models change the starting point.

Now I can say what I want in normal language. Not perfectly. Not magically. But enough that the computer can start from my intent instead of from a predefined button.

“Make this clearer.”

“Find the bug.”

“Check the server, but do not restart it without asking.”

“Turn this rough idea into an article draft.”

That is a very different feeling.

But language alone is not enough.

A normal chatbot can explain things. It can summarize, rewrite, argue, brainstorm, and occasionally sound smarter than it is. What it cannot reliably do by itself is hold the bigger picture of a real project. It forgets hidden constraints. It misses files it never saw. It gives confident answers without checking the machine. It can drift into philosophy when the useful answer would be: open the folder, inspect the logs, run the test, and show the diff.

This is where agents become interesting.

An agent is not just a model that talks. It is a model inside an environment. It can inspect files. Use tools. Run commands. Read errors. Make edits. Search notes. Call workflows. Keep a plan. Ask for approval before risky actions. Try something, see what happened, and adjust.

That feedback loop matters.

It is also why agents are currently strongest in coding. Code talks back. A test passes or fails. A build works or breaks. A page renders or it does not. A linter complains. A diff can be reviewed. A bug can be reproduced. A command returns an error. The agent does not have to guess forever; the machine can answer.

That is much harder in areas where success is fuzzy. If you ask an AI to solve something philosophical, social, or strategic, the feedback is often vague. It can sound good and still be wrong. With code, the model can be wrong too, but the environment can slap it in the face immediately. That is useful.

#The Feedback Loop

The market has noticed.

Cursor talks about agents that turn ideas into code, understand the codebase, build and test features, and give you demos to review. GitHub Copilot’s agent mode can iterate on its own code, recognize errors, and fix them. Windsurf’s Cascade combines planning, tool calling, terminal access, voice input, linter feedback, and checkpoints. Devin sells the idea of an AI software engineer working through large coding tasks with humans reviewing the result. OpenAI Codex is positioned as a coding agent for real engineering work, refactors, migrations, code review, debugging, and background automation. Aider maps your codebase, edits through the terminal, uses git, runs tests, and even supports voice-to-code.

Different products, same direction.

They are not only selling “the model is smarter now.” They are selling context, tools, feedback, and execution.

That is the missing glue.

Language is the handle. Agents are the hand. The machine is the world.

This is also why OpenClaw caught my attention. I do not want to claim it was historically the first project to attempt this. That would be too strong, and probably impossible to prove. It was simply the first one I noticed that made the idea feel concrete on my own machine.

OpenClaw is not just another chat window. It is a self-hosted gateway between normal messages and AI agents running on a computer you control. Telegram, Signal, Discord, WhatsApp, a browser interface, mobile nodes, coding agents, sessions, tools, memory, cron jobs, approvals — suddenly language is not floating in a web app somewhere. It has a place to land.

That matters because the future interface is not only conversational. It is operational.

A sentence can become a task.

A voice note can become a draft.

A reminder can become a scheduled check.

A rough instruction can become a coding session.

And if the system is built carefully, the dangerous parts still need visibility, logs, permissions, and human approval.

The dream version is not one giant god-bot with the keys to everything. That sounds impressive until it deletes the wrong folder or leaks the wrong file. The better version is a workbench: small agents with limited tools, clear jobs, recoverable changes, and receipts.

This website is my experiment with that.

HackerBunny is not being built by voice because voice is already perfect. It is being built by voice because I want to feel where the edges are. Where the agent understands me. Where it loses the thread. Where it needs structure. Where it needs a source note. Where it should ask. Where it should stop. Where it can actually save me work.

That is the only honest way to write about this stuff.

Not from the press release.

From the machine.

If language really is becoming the next user interface, then the important question is not whether chatbots can talk nicely. The question is whether they can act safely inside a real environment.

Can they see enough context?

Can they use the right tools?

Can they recover from mistakes?

Can they show their work?

Can they ask before touching the dangerous parts?

Can they help a normal person command a machine without forcing that person to become the machine?

That is the line I am interested in.

The future of computing may not be a blank chat box that knows everything. It may be a local agent with a toolbox, memory, voice input, logs, approvals, and enough humility to show its work before it touches the important parts.

Language is becoming the UI.

Agent glue is what makes it real.