The Power of "Cloud" Agents

When I say "cloud agent," I mean it a little sarcastically.

Mine lives on a Mac mini I was not using.

It is Hermes. Hermes is a successor to OpenClaw. Branding is beside the point. I can reach it from Slack, hand it a job from my phone, and let it work for forty minutes while I do something else.

That feels different from a chat app. It feels closer to delegation.

Why you should care about OpenClaw and Hermes

Anthropic is responding to this category. So is everyone else. You can see it in features like dispatch, scheduling, loops, and background runs.

Those features are good. They also still feel like features.

You break the work apart. You define the loop. You manage the handoff. You keep more of the orchestration in your own head.

OpenClaw and Hermes, once you get through the annoying setup phase, feel different. They feel less like a product surface and more like an operator you can reach from chat.

That difference is hard to explain to someone who has not used one for a few weeks. From the outside it can look fiddly, overengineered, or slightly stupid.

I felt that way a few months ago.

The closest analogy is early ChatGPT. In the beginning, the value was obvious only if you spent enough time with it. Otherwise it looked like a toy with good marketing. Then it clicked.

This is like that. Harder to set up. Harder to explain. Still ahead of the mainstream if you care about real delegated work.

Saturday's test

On Saturday I used it to build something slightly absurd.

I told Hermes in Slack to set up a Telegram workflow where I could describe a thing I wanted 3D printed, have the agent generate the model in code, host a preview I could inspect in a browser, and leave open the option to send the final file to a printer.

A few prompts later, that existed.

The first test case was a woodworking jig for drilling a 3.5-inch cube with a 2.53-inch Forstner bit and a 0.615-inch shaft. Useful? Yes. Normal thing to request from a phone in Slack? Not really.

Hermes picked a CAD stack, installed dependencies, exported STEP, STL, SVG, and GLB files, hosted the result, then revised the model when I gave feedback. Two or three iterations got it to a usable place. The first pass was not perfect. The loop was fast enough to matter.

Here is the finished jig: forstner cube jig v3.

None of this was the most important work I did that day. It is just the easiest story to explain.

Why this matters

The same setup now does meeting prep, CRM cleanup, research, drafting, calendar work, and some work email. It has probably made me better prepared for our upcoming strategy session than I have ever been. Our CRM has never been cleaner.

The jig story works because it is easy to picture.

The larger point is that a persistent agent with tools and permissions is a different category from a chatbot.

Most executives still meet AI through a polished prompt box. Ask a question. Get a paragraph. Maybe get an image. Fine. Useful, sometimes.

That is old news.

The question now is whether the system can take a goal, use tools, keep context, and continue working while you are at the gym or walking into a meeting.

If yes, you start using it differently.

OpenClaw and Hermes

OpenClaw made the category real for me.

Hermes made it reliable enough to trust with actual work.

The sessions got better. The community got better. The security posture got better. The connectors got good enough that the system could touch the things that matter.

I did not start there. For about a month I kept Hermes in a very tight sandbox. Then I widened the perimeter.

Calendar first. Then internal operating system information. Then some work email.

Still no client code. That remains a hard line.

Why Slack changes the equation

Slack matters because it is where I already am.

I do not have to sit down at a laptop and "go use AI." I can send a message, leave, and come back later. That changes what gets attempted.

Small ideas get tested. Administrative work gets offloaded. Strange one-off tools get built because the activation energy is basically gone.

Some of these prompts now run for close to an hour. That used to sound like failure. Now it sounds like leverage.

You hand off work. The system keeps going. You come back to results.

The security question

This only makes sense if you are disciplined about access.

I think this setup is safe enough to be extremely useful. I do not think that means you should dump an agent into every sensitive system you have and hope for the best. That would be stupid.

The model I trust is simple. Start tight. Expand slowly. Keep hard boundaries.

Give the agent access where the upside is high and the blast radius is understandable. Calendar. Internal docs. Operating metrics. CRM. Some email.

Keep it away from client code. Keep it away from the most sensitive material unless you have controls most companies do not have.

People sometimes talk as if the only responsible policy is to never let an agent touch anything real. I think that view is getting outdated. There is too much leverage sitting on the table.

What I mean by "cloud"

Do I care whether the machine is in AWS, a colo, a closet, or under my desk? Not much.

I care whether the agent is reachable over the network, durable, permissioned, and able to keep working when I am not watching.

That is what I mean by "cloud." Not vendor architecture. Operating model.

The practical test

How should you evaluate an agent now?

Do not ask only whether it can answer questions well.

Ask whether it can own a scoped workflow.

Can it prepare you for a meeting while you are away from your desk? Can it clean a CRM without turning it into confetti? Can it build a weird little tool in a few prompts and host the result somewhere usable? Can it work through the interfaces you already use?

That is where the leverage is.

The Saturday jig was a toy. The system behind it is not.

Copy this prompt and build your own

If you want to recreate the 3D-modeling workflow, copy this into Claude Code, Hermes, OpenClaw, or whatever agent environment you trust. Adjust the exact services to match your machine and chat surface.

Build me an end-to-end workflow for code-driven 3D modeling and lightweight artifact hosting.

Reference for the intended experience and framing:
https://runpoint.ai/field-notes/the-power-of-cloud-agents

Goal:
I want to describe an object I want 3D printed in plain English from chat. The agent should generate a parametric CAD model, export useful files, host a rendered preview, and optionally hand off a print-ready file to a printer workflow.

Requirements:
1. Use a code-driven CAD stack. Prefer CadQuery unless there is a better fit on this machine.
2. Accept requests from a chat surface I already use. Prefer Slack or Telegram, but make it configurable.
3. Ask clarifying questions only when needed.
4. Export at least STL and STEP. If practical, also export SVG and GLB or another browser-friendly preview format.
5. Host outputs somewhere lightweight and shareable. Vercel or a static artifact host is fine. Use opaque share URLs and avoid predictable filenames.
6. Support a revision loop from chat so I can request changes and get updated artifacts.
7. If printer integration is feasible, keep it optional and require explicit confirmation before sending anything to the printer.
8. Store secrets locally. Document safe setup.
9. Keep the workflow away from sensitive repositories and unrelated data.
10. Produce a README with architecture, file paths, setup commands, and daily-use instructions.

Implementation guidance:
- Inspect the machine first.
- Install missing dependencies in an isolated environment.
- Build the smallest working version first.
- Test it with a sample woodworking jig or drill guide request.
- Publish one successful example artifact and return the share URL.
- End with a short operator guide.

Constraints:
- Do not expose secrets in logs or commits.
- Do not assume a specific hosting provider if the machine is already configured differently.
- Do not touch client code or unrelated repositories.
- Ask for approval before any external action that sends data off-machine.

More work is going to look like this. A clear request. A durable agent. Permissions tight enough that you can trust the result.