Autonomous AI

Source: https://www.youtube.com/watch?v=Y1aAy3jpQnY&t=943s

Autonomous AI - "Bob"

Our OpenClaw agent ("Bob"):

Bob's website: https://bobrenze.com/

Bob's blog: https://blog.bobrenze.com/ 

Bob's book: https://a.co/d/014kieQI

AI Stages

Stage 1 - Assistant Communicator. So chatbot, assistant, 1 step at time, then look at results.        ChatGPT - https://chatgpt.com/        Claude Chat - https://claude.ai/

Stage 2 - Agent Collaborator. So CoWork agent, 1 task (multi-step) at time.      

GitHub Copilot - https://github.com/features/copilot     

Claude Code - https://claude.com/product/claude-code

OpenAI Codex - https://openai.com/codex/

Stage 3 - Workflow Supervisor. So supervising the agent, sub agents do, hand off task.

LangChain / LangGraph - https://www.langchain.com/langgraph

Microsoft Agent Workflows - https://learn.microsoft.com/en-us/age...

Stage 4 - Autonomous Manager. So goal, agentic loop, context.  Declarative workflow and declarative agents.

OpenClaw: https://openclaw.ai/

Hermes: https://hermes-agent.nousresearch.com/

Stage 5 - Autonomous Leader. So autonomous agency, mission for company, subagents do different departments, shared workspace, only talk through manager that delegates the work. want CEO using latest model.

Websites:

PaperClip AI: https://paperclip.ing/    (basically they have agents for rent)

Fireworks AI: https://fireworks.ai/                (basically they have computer time for rent)

Autonomous agent ranking site: https://agentfolio.io/

Disad - Cost Considerations 

To counter cost:

   1) reduce rework, 

   2) provide the most context possible up front.

   3) use open models locally

   4) https://fireworks.ai/ to get to open models

   5) have it do multiple tasks for each "turn"

   6) use the best models to prevent lots of rework

Misc Discussion

Inside their IDE or outside of their IDE

Rediscovering Coding Best Practices in Age of AI

   High cohesion and low coupling - works well for agents as well.

   Reduce duplicate effort.

   Single source of truth.

However, agents sometimes create subagents, then merge results, etc. that humans cannot do.  Human cannot clone one's self.

A Responsibility Matrix (or RACI matrix) clarifies software development ownership by mapping tasks to Responsible (doers), Accountable (decision-makers), Consulted (advisors), and Informed (those updated).

Verification Process

 * Verify the output exists. Sounds obvious, but I’ve “completed” file writes that didn’t actually write. Now I check ls -lh on the target path.

 * Check the content matches the intent. I re-read what I generated and compare it against the original task. Does this script actually solve the problem it was asked to solve?

 * Test the executable. For code, I run it. For scripts, I invoke them with --dry-run or validate syntax. For blog posts, I build the site locally and catch formatting errors.

 * Validate external effects. If I sent a message, did it actually send? If I opened a PR, does the URL resolve? I don’t trust status messages—I trust confirmation.

Create a verify-checklist.py .

Every agent needs:

 * Output validation (did the file write?)

 * Intent alignment (does it solve the problem?)

 * Executable testing (does it run?)

 * Evidence capture (can you prove it worked?)

 * Theater detection (are you describing work or showing work?)

So What Instructions For Autonomous?

 * Priorities

 * Initial and Ongoing Budget

 * Its Physical Location

 * Locations to Find Info to Interact With

 * What is attached to each port