<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:wfw="http://wellformedweb.org/CommentAPI/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
	xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
	 xmlns:media="http://search.yahoo.com/mrss/" xmlns:itunes="http://www.itunes.com/dtds/podcast-1.0.dtd" xmlns:media="http://search.yahoo.com/mrss/"
>

<channel>
	<title>RPABOTS.WORLD</title>
	<atom:link href="https://rpabotsworld.com/tag/open-source-agents/feed/" rel="self" type="application/rss+xml" />
	<link>https://rpabotsworld.com</link>
	<description>RPA, Agentic AI &amp; Intelligent Automation — Tutorials, Tools &amp; Career Guides</description>
	<lastBuildDate>Fri, 30 Oct 2026 03:11:29 +0000</lastBuildDate>
	<language>en-US</language>
	<sy:updatePeriod>
	hourly	</sy:updatePeriod>
	<sy:updateFrequency>
	1	</sy:updateFrequency>
	<generator>https://wordpress.org/?v=7.1.5</generator>
	<itunes:subtitle>RPABOTS.WORLD</itunes:subtitle>
	<itunes:summary>RPA, Agentic AI &amp; Intelligent Automation — Tutorials, Tools &amp; Career Guides</itunes:summary>
	<itunes:explicit>clean</itunes:explicit>
	<item>
		<title>Hermes Agent by Nous Research: The Complete Guide to the Self-Improving Open-Source AI Agent (2026)</title>
		<link>https://rpabotsworld.com/hermes-agent-self-improving-open-source-ai-agent-guide/</link>
					<comments>https://rpabotsworld.com/hermes-agent-self-improving-open-source-ai-agent-guide/#comments</comments>
		
		<dc:creator><![CDATA[Satish Prasad]]></dc:creator>
		<pubDate>Mon, 26 Oct 2026 05:11:52 +0000</pubDate>
				<category><![CDATA[AI Agents & Frameworks]]></category>
		<category><![CDATA[RPA & Bot Automation]]></category>
		<category><![CDATA[Hermes Agent]]></category>
		<category><![CDATA[Open-Source Agents]]></category>
		<guid isPermaLink="false">https://rpabotsworld.com/?p=32356</guid>

					<description><![CDATA[Hermes Agent by Nous Research — the 242k-star open-source AI agent that creates its own skills, remembers everything, and runs on a $5 VPS.]]></description>
										<content:encoded><![CDATA[<h1>Hermes Agent by Nous Research: The Complete Guide to the Self-Improving Open-Source AI Agent (2026)</h1>
<p>An AI agent that writes its own skills, remembers every conversation, and costs less than a coffee to run. With 242,000+ GitHub stars and a release cadence of every two weeks, Hermes Agent by Nous Research has become the fastest-growing open-source agentic AI framework of 2026. This guide breaks down how it works, why it matters, and how to deploy it — written for the architects building real agent systems.</p>
<h2>Table of Contents</h2>
<ul>
<li><a href="#what-is-hermes-agent">What Is Hermes Agent?</a></li>
<li><a href="#why-hermes-matters">Why Hermes Agent Matters for Agentic AI Architects</a></li>
<li><a href="#architecture">Architecture Deep Dive: How Hermes Agent Works</a></li>
<li><a href="#self-improvement">The Self-Improvement Loop: GEPA and Skill Creation</a></li>
<li><a href="#mcp-integration">MCP Integration: Connecting Hermes to Everything</a></li>
<li><a href="#persistent-memory">Persistent Memory: The Agent That Never Forgets</a></li>
<li><a href="#deployment">Deployment: From a $5 VPS to Enterprise Scale</a></li>
<li><a href="#comparison">Hermes Agent vs LangGraph vs CrewAI vs AutoGen</a></li>
<li><a href="#getting-started">Getting Started: Your First Hermes Agent in 15 Minutes</a></li>
<li><a href="#production-considerations">Production Considerations</a></li>
<li><a href="#faqs">FAQs</a></li>
<li><a href="#key-takeaways">Key Takeaways</a></li>
<li><a href="#references">References</a></li>
</ul>
<h2 id="what-is-hermes-agent">What Is Hermes Agent?</h2>
<p>Hermes Agent is an open-source, self-improving AI agent framework built by <a href="https://nousresearch.com/" target="_blank" rel="noopener nofollow">Nous Research</a> — the same lab behind the Hermes family of fine-tuned language models. Released in February 2026, it crossed 175,000 GitHub stars in its first four months and now sits at over 242,000 stars, making it one of the most-starred AI projects on GitHub alongside established giants like LangChain and Dify.</p>
<p>But star counts don&#8217;t tell the full story. What makes Hermes Agent architecturally distinct is its <strong>closed learning loop</strong>: it creates reusable skills from experience, improves those skills during subsequent use, builds a persistent model of who you are across sessions, and runs as a long-lived daemon rather than a stateless function. Where most agent frameworks route prompts to models and return responses, Hermes accumulates institutional knowledge — and that difference matters more than any benchmark.</p>
<p>Hermes Agent is MIT-licensed, works with any LLM provider (Anthropic, OpenAI, Google, DeepSeek, local models via Ollama), and connects natively to 16+ messaging platforms including Telegram, Discord, Slack, WhatsApp, and Signal. As of v0.21.0 (released August 31, 2026), it supports persistent memory in cron jobs, monitor-mode scheduling, and the open <a href="https://agentskills.io" target="_blank" rel="noopener nofollow">Agent Skills standard</a>.</p>
<h2 id="why-hermes-matters">Why Hermes Agent Matters for Agentic AI Architects</h2>
<p>The agentic AI landscape in 2026 is crowded. GitHub now hosts over 4.3 million AI-related repositories — a 178% year-over-year increase in LLM-focused projects, according to <a href="https://ossinsight.io/trending/ai" target="_blank" rel="noopener nofollow">OSSInsight&#8217;s 2026 tracking</a>. Three of the top five agent-adjacent repos by stars (Langflow at 146k, Dify at 136k, Flowise at 51k) are visual builders, reflecting a market hungry for accessible agent construction.</p>
<p>Hermes Agent occupies a different niche. It isn&#8217;t a visual builder or an orchestration framework — it&#8217;s an <strong>agent runtime</strong> designed for operators who want a persistent, self-improving assistant that runs on their own infrastructure. That positioning matters for three reasons:</p>
<p><strong>1. The &#8220;statefulness gap&#8221; in production agents.</strong> Most agent frameworks treat each invocation as stateless. You call an agent, it does work, it forgets everything. Hermes inverts this: every session contributes to a growing memory store, and skills learned in one context transfer to another. For enterprises running automation at scale — the same audience building with <a href="https://rpabotsworld.com/rpa-to-agentic-ai-transition-guide/" target="_blank" rel="noopener">RPA-to-agentic-AI transition strategies</a> — this persistent statefulness eliminates the &#8220;cold start&#8221; problem that plagues most deployed agents.</p>
<p><strong>2. Cost efficiency at the infrastructure layer.</strong> Hermes runs on a $5/month VPS. There are no per-run platform fees, no orchestration surcharges. The only variable cost is LLM inference, which you control by choosing your provider. For RPA teams accustomed to per-robot licensing from platforms like UiPath or Automation Anywhere, this cost model is transformative — especially when running dozens of agents across departments.</p>
<p><strong>3. MCP-native connectivity.</strong> Hermes Agent supports the <a href="https://rpabotsworld.com/what-is-mcp-server-ai-agents/" target="_blank" rel="noopener">Model Context Protocol (MCP)</a> natively, meaning every MCP server in the growing ecosystem becomes a tool Hermes can use. As <a href="https://rpabotsworld.com/a2a-joins-mcp-aaif-agentic-ai-architects-guide/" target="_blank" rel="noopener">A2A joins MCP at the Agentic AI Foundation</a>, this interoperability story only gets stronger.</p>
<h2 id="architecture">Architecture Deep Dive: How Hermes Agent Works</h2>
<p>Understanding Hermes Agent&#8217;s architecture requires separating it from the &#8220;agent framework&#8221; mental model. Frameworks like LangGraph and CrewAI give you building blocks to construct agents. Hermes <em>is</em> an agent — a long-running daemon with its own memory, skills, and scheduling system.</p>
<h3>Core Components</h3>
<p>The architecture divides into six layers:</p>
<table>
<thead>
<tr>
<th>Layer</th>
<th>Component</th>
<th>Purpose</th>
</tr>
</thead>
<tbody>
<tr>
<td><strong>Surface Layer</strong></td>
<td>Gateway process</td>
<td>Single process connecting 16+ messaging platforms (Telegram, Discord, Slack, WhatsApp, Signal, CLI, and more)</td>
</tr>
<tr>
<td><strong>Session Layer</strong></td>
<td>Profile isolation</td>
<td>Each profile is an isolated agent instance with its own memory, sessions, skills, and cron state</td>
</tr>
<tr>
<td><strong>Reasoning Layer</strong></td>
<td>LLM provider abstraction</td>
<td>Works with Anthropic, OpenAI, Google, DeepSeek, and local models (Ollama). Provider-agnostic — swap models without changing agent logic</td>
</tr>
<tr>
<td><strong>Memory Layer</strong></td>
<td>Persistent memory store</td>
<td>Cross-session memory with semantic search over past conversations and accumulated knowledge</td>
</tr>
<tr>
<td><strong>Skill Layer</strong></td>
<td>Skill engine + GEPA</td>
<td>Auto-generated and curated skills; evolutionary optimization via DSPy + GEPA</td>
</tr>
<tr>
<td><strong>Execution Layer</strong></td>
<td>Terminal backends</td>
<td>Six backends: local, Docker, SSH, Singularity, Modal, Daytona — execute code in sandboxed or remote environments</td>
</tr>
</tbody>
</table>
<h3>The Daemon Model</h3>
<p>Unlike stateless agent frameworks where you invoke an agent and it terminates, Hermes runs as a persistent daemon. This means:</p>
<ul>
<li><strong>Always-on availability</strong> — talk to it from Telegram while it works on a cloud VM.</li>
<li><strong>Cron scheduling</strong> — as of v0.21.0, scheduled jobs retain persistent memory between runs, enabling scheduled agents to learn and build continuity instead of starting cold every time.</li>
<li><strong>Monitor mode</strong> — jobs that skip the LLM entirely when nothing has changed, saving inference costs on routine checks.</li>
<li><strong>Multi-platform multiplexing</strong> — a single Hermes instance handles conversations across all connected messaging platforms simultaneously.</li>
</ul>
<h3>Terminal Backends: Where Code Actually Runs</h3>
<p>When Hermes needs to execute code — running a script, calling an API, processing data — it delegates to one of six terminal backends:</p>
<ol>
<li><strong>Local</strong> — runs on the host machine directly.</li>
<li><strong>Docker</strong> — sandboxed container execution for isolation.</li>
<li><strong>SSH</strong> — execute on remote servers.</li>
<li><strong>Singularity</strong> — HPC-grade container runtime for research environments.</li>
<li><strong>Modal</strong> — serverless GPU execution for ML workloads.</li>
<li><strong>Daytona</strong> — cloud development environment integration.</li>
</ol>
<p>This backend flexibility means a single Hermes agent can orchestrate work across local development machines, cloud VMs, and GPU clusters — a capability that mirrors how enterprise RPA platforms distribute work across attended and unattended robots, but with far more granular control over the execution environment.</p>
<h2 id="self-improvement">The Self-Improvement Loop: GEPA and Skill Creation</h2>
<p>This is the feature that separates Hermes from every other open-source agent framework. The self-improvement loop has three stages:</p>
<h3>Stage 1: Skill Creation from Experience</h3>
<p>After completing a complex task, Hermes can generate a reusable skill document. Unlike hardcoded tool definitions, these skills are natural-language procedures that the agent writes for itself — capturing what worked, what order to do things in, and what edge cases to watch for. Skills are stored as portable documents compatible with the open <a href="https://agentskills.io" target="_blank" rel="noopener nofollow">Agent Skills standard</a>, making them shareable across agents and even across frameworks.</p>
<h3>Stage 2: Skill Improvement During Use</h3>
<p>Each time Hermes executes a skill, it evaluates the outcome. If the skill produced a suboptimal result or encountered an edge case not in the original procedure, the agent updates the skill document. Over time, skills accumulate institutional knowledge that no single session could capture. This is conceptually similar to how experienced RPA developers refine their exception-handling logic after each production incident — except the agent does it autonomously.</p>
<h3>Stage 3: Evolutionary Optimization via GEPA</h3>
<p>GEPA (Genetic Evolution of Prompt Architectures) is Nous Research&#8217;s evolutionary optimization system built on top of <a href="https://github.com/stanfordnlp/dspy" target="_blank" rel="noopener nofollow">Stanford&#8217;s DSPy framework</a>. Where DSPy treats prompting as a compilation problem — defining modular signatures with strict inputs and outputs, then compiling optimal prompts — GEPA adds an evolutionary layer:</p>
<ul>
<li><strong>Trace analysis:</strong> GEPA reads execution traces to understand <em>why</em> things fail, not just <em>that</em> they failed.</li>
<li><strong>Targeted mutations:</strong> Instead of random prompt perturbation, GEPA proposes specific improvements based on failure analysis.</li>
<li><strong>Selection pressure:</strong> Improved variants compete against the original skill on held-out test cases, and only provably better versions replace the incumbent.</li>
</ul>
<p>The practical impact is significant. According to Nous Research&#8217;s benchmarks, GEPA-optimized skills show measurable improvement in task completion rates compared to their initial versions — with the biggest gains on multi-step workflows where cascading errors compound.</p>
<h2 id="mcp-integration">MCP Integration: Connecting Hermes to Everything</h2>
<p>Hermes Agent&#8217;s native support for the Model Context Protocol means it can connect to any MCP server as a tool source. This is the same protocol that Anthropic, OpenAI, and Google have adopted as the standard for agent-tool interoperability — and with <a href="https://rpabotsworld.com/a2a-joins-mcp-aaif-agentic-ai-architects-guide/" target="_blank" rel="noopener">A2A joining MCP at the Agentic AI Foundation</a>, MCP is rapidly becoming the universal connector layer for enterprise AI systems.</p>
<p>For Hermes users, this means:</p>
<ul>
<li><strong>Instant access to the MCP ecosystem:</strong> Thousands of MCP servers covering databases, APIs, cloud services, and enterprise tools are immediately available.</li>
<li><strong>No custom integration code:</strong> Adding a new capability is as simple as pointing Hermes at an MCP server URI.</li>
<li><strong>Composability:</strong> Multiple MCP servers can be connected simultaneously, giving a single Hermes agent access to your CRM, your codebase, your cloud infrastructure, and your messaging platforms all at once.</li>
</ul>
<p>For organizations already invested in MCP server infrastructure — whether through UiPath&#8217;s integration service, custom-built servers, or community-maintained packages from the <a href="https://github.com/punkpeye/awesome-mcp-servers" target="_blank" rel="noopener nofollow">awesome-mcp-servers</a> directory — Hermes Agent slots in without requiring a parallel tool ecosystem.</p>
<blockquote>
<p><strong>Security consideration:</strong> Every MCP server you install executes code with the agent&#8217;s authority. Treat MCP server selection with the same rigor you&#8217;d apply to granting API keys — audit the server code, run in sandboxed environments, and follow the principle of least privilege.</p>
</blockquote>
<h2 id="persistent-memory">Persistent Memory: The Agent That Never Forgets</h2>
<p>Memory in Hermes operates at three levels:</p>
<h3>Session Memory</h3>
<p>Within a single conversation, Hermes maintains full context — standard for any LLM-based agent. Nothing unusual here.</p>
<h3>Cross-Session Persistent Memory</h3>
<p>This is where Hermes diverges. The agent accumulates knowledge across sessions: your preferences, project context, organizational patterns, and past decisions. When you start a new conversation next week, Hermes already knows your tech stack, your coding style, your deployment preferences. It builds a deepening model of who you are — not through a static profile, but through semantic search over accumulated interaction history.</p>
<h3>Cron Job Memory (v0.21.0+)</h3>
<p>The August 31, 2026 release added persistent memory to scheduled jobs. Previously, cron jobs ran in fresh sessions, meaning a daily monitoring agent would start cold every morning. Now, scheduled agents carry continuity between runs: a monitoring agent can dedupe against what it already reported, a data pipeline agent can track state across executions, and a digest agent can identify genuinely new items versus previously flagged ones.</p>
<p>Each job also gets a durable &#8220;notepad&#8221; scratchpad — a lightweight key-value store for structured state that survives between runs without polluting the main memory store.</p>
<p>For RPA practitioners, this is analogous to the difference between a stateless API call and an attended robot that maintains its own work queue. The agent accumulates operational intelligence the same way an experienced human operator does — it just does it automatically.</p>
<h2 id="deployment">Deployment: From a $5 VPS to Enterprise Scale</h2>
<h3>Minimal Deployment</h3>
<p>The simplest Hermes deployment is a single process on a cheap VPS:</p>
<pre><code># Install
git clone https://github.com/NousResearch/hermes-agent.git
cd hermes-agent

# Configure your LLM provider and messaging platforms
cp .env.example .env
# Edit .env with your API keys and platform tokens

# Run
docker compose up -d</code></pre>
<p>This gives you a fully functional, always-on agent accessible from any configured messaging platform. Total infrastructure cost: the VPS fee ($4-5/month on DigitalOcean or Hetzner) plus LLM inference costs (variable, but controllable by choosing your provider).</p>
<h3>Production Deployment Patterns</h3>
<p>For enterprise use, Hermes supports several scaling patterns:</p>
<table>
<thead>
<tr>
<th>Pattern</th>
<th>Use Case</th>
<th>Infrastructure</th>
</tr>
</thead>
<tbody>
<tr>
<td><strong>Single-instance</strong></td>
<td>Personal assistant, small team</td>
<td>1 VPS, $5/month</td>
</tr>
<tr>
<td><strong>Multi-profile</strong></td>
<td>Department-level agents with isolated memory</td>
<td>1 VPS, profiles per department</td>
</tr>
<tr>
<td><strong>Distributed backends</strong></td>
<td>Agent orchestrates across local + cloud + GPU</td>
<td>Central Hermes + SSH/Modal/Docker backends</td>
</tr>
<tr>
<td><strong>Serverless burst</strong></td>
<td>ML-heavy workloads with variable demand</td>
<td>Hermes on VPS + Modal for GPU inference</td>
</tr>
</tbody>
</table>
<h3>Security Hardening</h3>
<p>Production deployments should implement:</p>
<ul>
<li><strong>Network isolation:</strong> Run behind Tailscale or a VPN — accept connections only from trusted devices.</li>
<li><strong>Credential rotation:</strong> Give Hermes its own API credentials that can be revoked independently if compromised.</li>
<li><strong>Terminal sandboxing:</strong> Use Docker or Singularity backends instead of local execution to contain any malicious or accidental code.</li>
<li><strong>MCP server auditing:</strong> Review every MCP server&#8217;s code before connecting — each server runs with agent-level authority.</li>
</ul>
<h2 id="comparison">Hermes Agent vs LangGraph vs CrewAI vs AutoGen: When to Use What</h2>
<table>
<thead>
<tr>
<th>Dimension</th>
<th>Hermes Agent</th>
<th>LangGraph</th>
<th>CrewAI</th>
<th>AutoGen</th>
</tr>
</thead>
<tbody>
<tr>
<td><strong>Architecture</strong></td>
<td>Persistent daemon with self-improvement</td>
<td>Graph-based orchestration</td>
<td>Role-based agent teams</td>
<td>Multi-agent conversation patterns</td>
</tr>
<tr>
<td><strong>Best for</strong></td>
<td>Operator-led workflows, personal/team agents</td>
<td>Auditable production pipelines</td>
<td>Fast role-based prototypes</td>
<td>Research &amp; multi-agent debate</td>
</tr>
<tr>
<td><strong>State management</strong></td>
<td>Built-in persistent memory + cross-session</td>
<td>Explicit state graphs</td>
<td>Minimal (per-run)</td>
<td>Conversation history</td>
</tr>
<tr>
<td><strong>Learning</strong></td>
<td>Self-improving (GEPA + skill creation)</td>
<td>None (static graphs)</td>
<td>None</td>
<td>None</td>
</tr>
<tr>
<td><strong>MCP support</strong></td>
<td>Native</td>
<td>Via integration</td>
<td>Via integration</td>
<td>Via integration</td>
</tr>
<tr>
<td><strong>Token overhead</strong></td>
<td>~Minimal</td>
<td>~Minimal</td>
<td>~18% (role descriptions)</td>
<td>~12% (protocol overhead)</td>
</tr>
<tr>
<td><strong>Deployment</strong></td>
<td>Always-on daemon</td>
<td>Library (you build the runtime)</td>
<td>Library</td>
<td>Library</td>
</tr>
<tr>
<td><strong>Messaging platforms</strong></td>
<td>16+ built-in</td>
<td>None (BYO)</td>
<td>None (BYO)</td>
<td>None (BYO)</td>
</tr>
<tr>
<td><strong>Cost model</strong></td>
<td>VPS + inference</td>
<td>Inference only</td>
<td>Inference only</td>
<td>Inference only</td>
</tr>
<tr>
<td><strong>Maturity</strong></td>
<td>Feb 2026, fast iteration</td>
<td>2024, battle-tested</td>
<td>2023, stable</td>
<td>2023, maintenance mode</td>
</tr>
<tr>
<td><strong>License</strong></td>
<td>MIT</td>
<td>MIT</td>
<td>MIT</td>
<td>CC-BY-4.0</td>
</tr>
<tr>
<td><strong>GitHub stars</strong></td>
<td>242k+</td>
<td>33.9k+</td>
<td>27k+</td>
<td>40k+</td>
</tr>
</tbody>
</table>
<h3>The Verdict</h3>
<p><strong>Use Hermes Agent when</strong> you want a persistent, always-on agent that learns from experience and connects to messaging platforms out of the box — especially for operator-led workflows where the agent serves a person or team over weeks and months.</p>
<p><strong>Use LangGraph when</strong> you&#8217;re building a production pipeline that needs explicit state management, auditability, and deterministic graph execution — especially for regulated industries where every decision must be traceable.</p>
<p><strong>Use CrewAI when</strong> you need to prototype a multi-agent workflow quickly using role-based decomposition — ideal for hackathons, proofs of concept, and team-of-agents architectures.</p>
<p><strong>Use AutoGen when</strong> you&#8217;re doing multi-agent research or need agents to debate and negotiate — but note that Microsoft has shifted AutoGen to maintenance mode as of early 2026, so the strategic trajectory is uncertain.</p>
<h2 id="getting-started">Getting Started: Your First Hermes Agent in 15 Minutes</h2>
<h3>Prerequisites</h3>
<ul>
<li>A VPS or local machine with Docker installed</li>
<li>An API key from any supported LLM provider (Anthropic, OpenAI, Google, DeepSeek, or a local Ollama instance)</li>
<li>A messaging platform bot token (Telegram is easiest for testing)</li>
</ul>
<h3>Step 1: Clone and Configure</h3>
<pre><code>git clone https://github.com/NousResearch/hermes-agent.git
cd hermes-agent
cp .env.example .env</code></pre>
<p>Edit <code>.env</code> with your LLM provider credentials and messaging platform tokens. At minimum, set:</p>
<pre><code>LLM_PROVIDER=anthropic
LLM_API_KEY=sk-ant-...
TELEGRAM_BOT_TOKEN=...</code></pre>
<h3>Step 2: Launch</h3>
<pre><code>docker compose up -d</code></pre>
<p>Hermes starts as a daemon, connects to your configured messaging platforms, and is immediately ready for conversation.</p>
<h3>Step 3: Create Your First Skill</h3>
<p>Ask Hermes to perform a multi-step task — for example, researching a topic and summarizing findings. After it completes the task successfully, prompt it to create a skill from the experience:</p>
<pre><code>You: Create a skill from what you just did so you can do it faster next time.</code></pre>
<p>Hermes will generate a reusable skill document, store it, and apply it automatically when it encounters similar tasks in the future.</p>
<h3>Step 4: Set Up a Cron Job</h3>
<p>Schedule a recurring task — for example, a daily digest of news in your domain:</p>
<pre><code>You: Every morning at 8am, check for new announcements from the UiPath community 
forum and summarize anything relevant to our automation pipeline.</code></pre>
<p>With v0.21.0&#8217;s persistent cron memory, the agent will remember what it already reported and only surface genuinely new items.</p>
<h3>Step 5: Connect an MCP Server</h3>
<p>Add an MCP server to extend Hermes&#8217;s capabilities. For example, connecting a GitHub MCP server gives the agent direct access to your repositories:</p>
<pre><code># In your Hermes configuration
mcp_servers:
  - name: github
    uri: npx @anthropic/mcp-server-github
    env:
      GITHUB_TOKEN: ghp_...</code></pre>
<p>Now Hermes can create issues, review PRs, and search code — all through natural conversation.</p>
<h2 id="production-considerations">Production Considerations</h2>
<h3>Cost Modeling</h3>
<p>Hermes&#8217;s cost structure is unusually favorable for high-volume use:</p>
<table>
<thead>
<tr>
<th>Component</th>
<th>Cost</th>
<th>Notes</th>
</tr>
</thead>
<tbody>
<tr>
<td>VPS (DigitalOcean/Hetzner)</td>
<td>$4-10/month</td>
<td>Basic droplet is sufficient for most workloads</td>
</tr>
<tr>
<td>LLM inference (Anthropic Claude)</td>
<td>Variable</td>
<td>~$3/MTok input, $15/MTok output for Sonnet</td>
</tr>
<tr>
<td>LLM inference (local via Ollama)</td>
<td>$0</td>
<td>Requires GPU hardware but no per-token cost</td>
</tr>
<tr>
<td>MCP servers</td>
<td>$0</td>
<td>Open-source; any API costs are from the underlying services</td>
</tr>
<tr>
<td>Total for a personal agent</td>
<td>$5-30/month</td>
<td>Depends on usage volume and model choice</td>
</tr>
</tbody>
</table>
<p>Compare this to per-robot licensing from traditional RPA platforms — where a single unattended robot can cost $5,000-10,000+/year — and the economics become compelling for teams deploying multiple agents.</p>
<h3>Reliability</h3>
<p>According to third-party benchmarks from <a href="https://the-agent-report.com/2026/07/ai-agent-frameworks-benchmark-2026-autogen-crewai-langgraph-hermes/" target="_blank" rel="noopener nofollow">The Agent Report&#8217;s 2026 framework benchmark</a>, Hermes Agent achieves a 0.5% timeout rate — the lowest among compared frameworks. This reflects built-in timeout management, retry logic, and the ability to pivot to alternate tools when a specific tool fails (a structural advantage from the skill system).</p>
<h3>Limitations</h3>
<p>Hermes Agent is not the right choice for every scenario:</p>
<ul>
<li><strong>Auditability requirements:</strong> If you need a deterministic, auditable execution trace for compliance, LangGraph&#8217;s explicit state graphs are more appropriate.</li>
<li><strong>Multi-agent orchestration:</strong> Hermes is a single-agent runtime. For complex multi-agent architectures with hand-offs and coordination protocols, pair it with a framework like <a href="https://rpabotsworld.com/building-multi-agent-systems-with-google-adk-the-complete-step-by-step-guide/" target="_blank" rel="noopener">Google ADK</a> or LangGraph.</li>
<li><strong>Documentation maturity:</strong> Hermes launched in February 2026 and the team ships fast. Some documentation lags the code — expect to read source code occasionally.</li>
<li><strong>Enterprise governance:</strong> No built-in role-based access control, audit logging, or compliance tooling. Enterprise teams should layer these on top.</li>
</ul>
<h3>The RPA-to-Agentic Bridge</h3>
<p>For organizations transitioning from traditional RPA to agentic AI — a journey that <a href="https://rpabotsworld.com/rpa-to-agentic-ai-transition-guide/" target="_blank" rel="noopener">requires careful planning</a> — Hermes Agent offers a pragmatic stepping stone. Its daemon model mirrors the &#8220;always-on unattended robot&#8221; mental model that RPA teams already understand. Its skill system is conceptually similar to reusable RPA components. And its MCP connectivity means it can integrate with existing enterprise systems without requiring a wholesale platform migration.</p>
<p>The key difference: where RPA bots follow predefined scripts, Hermes agents learn and adapt. That&#8217;s not a replacement for RPA — it&#8217;s an evolution. The automation that should stay deterministic (invoice processing, data entry, compliance checks) remains in your RPA platform. The work that requires judgment, context, and learning — that&#8217;s where Hermes fits.</p>
<h2 id="faqs">Frequently Asked Questions</h2>
<h3>Is Hermes Agent free to use?</h3>
<p>Yes. Hermes Agent is MIT-licensed and fully open source. You pay only for infrastructure (a VPS) and LLM inference (from your chosen provider). There are no platform fees, per-agent charges, or usage tiers.</p>
<h3>Can Hermes Agent run with local LLMs instead of cloud APIs?</h3>
<p>Yes. Hermes supports local model inference via Ollama. This eliminates per-token API costs entirely, though you&#8217;ll need appropriate GPU hardware. Many users run smaller models locally for routine tasks and route complex reasoning to cloud APIs.</p>
<h3>How does Hermes Agent compare to UiPath Autopilot or Automation Anywhere&#8217;s AI agents?</h3>
<p>They serve different roles. <a href="https://rpabotsworld.com/uipath-autopilot-coding-agent-ga-guide-2/" target="_blank" rel="noopener">UiPath Autopilot</a> and Automation Anywhere&#8217;s agent capabilities are embedded within their respective RPA platforms — they&#8217;re designed to enhance existing robot workflows with AI reasoning. Hermes Agent is a standalone, infrastructure-independent agent runtime. Use platform-native AI agents when you&#8217;re already invested in that ecosystem; use Hermes when you need a flexible, self-improving agent that isn&#8217;t tied to any vendor.</p>
<h3>What happens if the Hermes process crashes? Does it lose its memory?</h3>
<p>No. Persistent memory is stored on disk (or in your configured memory provider) and survives process restarts. Skills and cron state are also persisted. The agent picks up where it left off.</p>
<h3>Can I run multiple independent agents on a single Hermes instance?</h3>
<p>Yes. The profile system provides full isolation — each profile is a separate agent with its own memory, skills, sessions, and cron jobs. You can run a personal assistant, a code reviewer, and a monitoring agent on a single VPS, each as an isolated profile.</p>
<h2 id="key-takeaways">Key Takeaways</h2>
<ul>
<li><strong>Hermes Agent is the fastest-growing open-source agent framework of 2026</strong>, with 242k+ GitHub stars and bi-weekly releases from Nous Research.</li>
<li><strong>Its self-improvement loop (GEPA + skill creation) is architecturally unique</strong> — no other mainstream framework learns from its own execution and improves autonomously.</li>
<li><strong>Native MCP support</strong> connects it to the rapidly growing ecosystem of Model Context Protocol servers, making it instantly compatible with thousands of tools and services.</li>
<li><strong>Persistent memory across sessions and cron jobs</strong> eliminates the cold-start problem that plagues stateless agent frameworks.</li>
<li><strong>Cost-effective deployment</strong> — run a production agent for $5-30/month versus $5,000-10,000+/year for traditional RPA robot licensing.</li>
<li><strong>Best suited for</strong> operator-led, persistent workflows — not for multi-agent orchestration or compliance-heavy regulated pipelines (use LangGraph for those).</li>
<li><strong>For RPA teams transitioning to agentic AI</strong>, Hermes offers a familiar daemon/robot mental model with the added capability of learning and adaptation.</li>
</ul>
<h2 id="references">References</h2>
<ol>
<li>Nous Research. &#8220;Hermes Agent — The Agent That Grows with You.&#8221; GitHub, 2026. <a href="https://github.com/NousResearch/hermes-agent" target="_blank" rel="noopener nofollow">https://github.com/NousResearch/hermes-agent</a></li>
<li>Nous Research. &#8220;Hermes Agent Documentation — Architecture.&#8221; 2026. <a href="https://hermes-agent.nousresearch.com/docs/developer-guide/architecture" target="_blank" rel="noopener nofollow">https://hermes-agent.nousresearch.com/docs/developer-guide/architecture</a></li>
<li>Nous Research. &#8220;hermes-agent-self-evolution: Evolutionary self-improvement using DSPy + GEPA.&#8221; GitHub, 2026. <a href="https://github.com/NousResearch/hermes-agent-self-evolution" target="_blank" rel="noopener nofollow">https://github.com/NousResearch/hermes-agent-self-evolution</a></li>
<li>Hermesatlas.com. &#8220;Hermes Agent v0.21.0: The Complete Beginner&#8217;s Guide (Sep 2026).&#8221; <a href="https://hermesatlas.com/guide/" target="_blank" rel="noopener nofollow">https://hermesatlas.com/guide/</a></li>
<li>The Agent Report. &#8220;AI Agent Frameworks Benchmark 2026: AutoGen vs CrewAI vs LangGraph vs Hermes Agent.&#8221; July 2026. <a href="https://the-agent-report.com/2026/07/ai-agent-frameworks-benchmark-2026-autogen-crewai-langgraph-hermes/" target="_blank" rel="noopener nofollow">https://the-agent-report.com/2026/07/ai-agent-frameworks-benchmark-2026-autogen-crewai-langgraph-hermes/</a></li>
<li>OSSInsight. &#8220;Trending AI Repositories on GitHub — Real-Time Rankings 2026.&#8221; <a href="https://ossinsight.io/trending/ai" target="_blank" rel="noopener nofollow">https://ossinsight.io/trending/ai</a></li>
<li>DEV Community. &#8220;Hermes Agent vs. LangGraph, CrewAI, and AutoGen: A Technical Comparison for 2026.&#8221; <a href="https://dev.to/harsha_gopalkrishnapuran/hermes-agent-vs-langgraph-crewai-and-autogen-a-technical-comparison-for-2026-2ok8" target="_blank" rel="noopener nofollow">https://dev.to/harsha_gopalkrishnapuran/hermes-agent-vs-langgraph-crewai-and-autogen-a-technical-comparison-for-2026-2ok8</a></li>
<li>Stanford NLP. &#8220;DSPy: Programming—not Prompting—Language Models.&#8221; GitHub, 2024-2026. <a href="https://github.com/stanfordnlp/dspy" target="_blank" rel="noopener nofollow">https://github.com/stanfordnlp/dspy</a></li>
</ol>
<hr>
<p><em>Satish Kumar is an Agentic AI Architect and the founder of <a href="https://rpabotsworld.com" target="_blank" rel="noopener">RPABOTS.WORLD</a>, where he writes practitioner-focused guides on building production-grade automation systems with RPA and agentic AI.</em></p>
]]></content:encoded>
					
					<wfw:commentRss>https://rpabotsworld.com/hermes-agent-self-improving-open-source-ai-agent-guide/feed/</wfw:commentRss>
			<slash:comments>1</slash:comments>
		
		
			</item>
		<item>
		<title>DeepSeek Harness: The Open-Source Plugin-First Agent Framework That Broke GitHub’s Star Record (2026)</title>
		<link>https://rpabotsworld.com/deepseek-harness-open-source-agent-framework-guide/</link>
					<comments>https://rpabotsworld.com/deepseek-harness-open-source-agent-framework-guide/#respond</comments>
		
		<dc:creator><![CDATA[Satish Prasad]]></dc:creator>
		<pubDate>Mon, 26 Oct 2026 05:11:41 +0000</pubDate>
				<category><![CDATA[AI Agents & Frameworks]]></category>
		<category><![CDATA[RPA & Bot Automation]]></category>
		<category><![CDATA[DeepSeek Harness]]></category>
		<category><![CDATA[Open-Source Agents]]></category>
		<guid isPermaLink="false">https://rpabotsworld.com/?p=32359</guid>

					<description><![CDATA[DeepSeek Harness (dsh) hit 210K GitHub stars in 3 weeks. This guide covers its plugin-first architecture, Claude Code/Codex comparison, benchmarks, and what…]]></description>
										<content:encoded><![CDATA[<h2>What Is DeepSeek Harness and Why Does It Matter?</h2>
<p>On August 13, 2026, DeepSeek AI quietly published a GitHub repository labeled &#8220;developer preview.&#8221; Within 48 hours, it had crossed 95,000 stars — <a href="https://pasqualepillitteri.it/en/news/11573/deepseek-harness-fastest-github-stars-record" target="_blank" rel="noopener nofollow">breaking GitHub&#8217;s record</a> for fastest-starred project. By early September 2026, it sits at over 210,000 stars with 24,500 forks. The project is DeepSeek Harness (<code>dsh</code>), and its tagline is deceptively simple: <strong>&#8220;Everything is a Plugin.&#8221;</strong></p>
<p>But DeepSeek Harness is not just another coding agent or CLI wrapper. It is a fully open-source, model-agnostic <strong>agent runtime</strong> — a harness that treats every component of the agent stack, from the model adapter to the tool registry to the agent loop itself, as a swappable plugin. Where Claude Code and OpenAI Codex ship as polished, vendor-locked products, DeepSeek Harness ships a composable <em>frame</em> and expects you to assemble the walls.</p>
<p>For Agentic AI Architects, RPA engineers exploring AI-augmented automation, and platform teams evaluating open-source agent infrastructure, this distinction matters. The harness — the runtime layer that manages context, tool calls, retries, sandboxing, and the agent control loop — is emerging as a critical differentiator in agent performance. <a href="https://composio.dev/content/deepseek-harness-vs-claude-code" target="_blank" rel="noopener nofollow">Recent benchmarks from Composio</a> show that the same model routed through different harnesses can produce wildly different task-completion rates, latencies, and costs. Choosing your harness now matters almost as much as choosing your model.</p>
<p>This guide breaks down DeepSeek Harness&#8217;s architecture, explains what the &#8220;everything-is-a-plugin&#8221; philosophy means in practice, compares it head-to-head against Claude Code and OpenAI Codex, walks through getting started, and assesses where it fits in enterprise and RPA-adjacent automation stacks.</p>
<h2>The Architecture: Cordis and Spatiotemporal Composability</h2>
<p>Most agent frameworks bolt capabilities onto a monolithic core. DeepSeek Harness inverts this: <strong>there is no privileged core</strong>. The entire system is built on <a href="https://github.com/cordiverse/cordis" target="_blank" rel="noopener nofollow">Cordis</a>, an open-source JavaScript meta-framework whose design is formalized in the academic paper <a href="https://arxiv.org/abs/2608.25512" target="_blank" rel="noopener nofollow"><em>A Programming Paradigm for Spatiotemporal Composability</em></a>.</p>
<p>Cordis did not originate with DeepSeek Harness. It has <a href="https://thenewstack.io/deepseek-harness-open-source-plugins/" target="_blank" rel="noopener nofollow">four years of production history</a> powering the Koishi chatbot framework. What DeepSeek did was recognize that its plugin composition model — where components can be added, removed, or replaced at runtime without teardown — maps perfectly onto the agent problem.</p>
<h3>What &#8220;Everything Is a Plugin&#8221; Actually Means</h3>
<p>In DeepSeek Harness, each of the following is a discrete, independently replaceable plugin:</p>
<ul>
<li><strong>Model adapter</strong> — the inference layer that talks to an LLM provider (Anthropic, OpenAI, DeepSeek, AWS Bedrock, Azure, Google)</li>
<li><strong>Tool registry</strong> — how tools are discovered, validated, and called</li>
<li><strong>Session log</strong> — conversation state, history, and context windowing</li>
<li><strong>Agent loop</strong> — the ReAct/reflection/planning cycle itself</li>
<li><strong>Execution sandbox</strong> — where code runs (Docker, local shell, remote VM)</li>
<li><strong>Storage backend</strong> — where sessions and artifacts persist</li>
<li><strong>Web UI</strong> — the frontend (ships a default, but it&#8217;s a plugin too)</li>
<li><strong>MCP bridges</strong> — Model Context Protocol connectors for external tool servers</li>
</ul>
<p>Plugins contribute typed services, events, and reversible effects to a shared Cordis context. A developer can swap the model adapter from DeepSeek V4-Pro to Claude Fable 5.1, or replace the default agent loop with a custom multi-step planner, purely through configuration — without forking the source code.</p>
<p>This is architecturally different from, say, LangChain (which uses a chain-of-invocations pattern) or CrewAI (which models agents as role-based collaborators). DeepSeek Harness&#8217;s composition unit is the <em>plugin</em>, not the chain or the agent persona.</p>
<h3>The Plugin Ecosystem</h3>
<p>As of September 2026, the ecosystem includes <a href="https://habr.com/en/articles/1070958/" target="_blank" rel="noopener nofollow">110+ curated Cordis plugins</a> spanning core orchestration, AST-based code analysis, Docker sandboxes, Kafka streaming pipelines, and MCP bridges. Community plugins are discoverable via the <a href="https://github.com/topics/dsh-plugin" target="_blank" rel="noopener nofollow"><code>dsh-plugin</code> GitHub topic</a>.</p>
<p>For RPA teams, the MCP bridge plugins are particularly interesting. They allow DeepSeek Harness to connect to any MCP-compatible tool server — the same protocol that <a href="https://rpabotsworld.com/what-is-mcp-server-ai-agents/">powers tool integration in Claude, Cursor, and other AI-native IDEs</a>. This means a single DeepSeek Harness instance can orchestrate browser automation tools, database connectors, API gateways, and <a href="https://rpabotsworld.com/a2a-joins-mcp-aaif-agentic-ai-architects-guide/">A2A-protocol agents</a> through a unified plugin interface.</p>
<h2>DeepSeek Harness vs Claude Code vs OpenAI Codex: The Harness Matters</h2>
<p>The 2026 coding-agent market has consolidated around three primary harnesses: Claude Code (Anthropic), OpenAI Codex (OpenAI), and now DeepSeek Harness (open-source). Each represents a fundamentally different philosophy.</p>
<table>
<thead>
<tr>
<th>Dimension</th>
<th>DeepSeek Harness (<code>dsh</code>)</th>
<th>Claude Code</th>
<th>OpenAI Codex</th>
</tr>
</thead>
<tbody>
<tr>
<td><strong>License</strong></td>
<td>MIT (fully open-source)</td>
<td>Proprietary</td>
<td>Proprietary</td>
</tr>
<tr>
<td><strong>Model lock-in</strong></td>
<td>Model-agnostic (any provider)</td>
<td>Anthropic models only</td>
<td>OpenAI models only</td>
</tr>
<tr>
<td><strong>Architecture</strong></td>
<td>Plugin-first, everything swappable</td>
<td>Fixed runtime, closed internals</td>
<td>Fixed runtime, closed internals</td>
</tr>
<tr>
<td><strong>Self-hosting</strong></td>
<td>Yes (local, on-prem, cloud)</td>
<td>No (Anthropic-hosted)</td>
<td>No (OpenAI-hosted)</td>
</tr>
<tr>
<td><strong>Language</strong></td>
<td>TypeScript / Node.js</td>
<td>TypeScript (internal)</td>
<td>Python/TypeScript (internal)</td>
</tr>
<tr>
<td><strong>MCP support</strong></td>
<td>Native via bridge plugins</td>
<td>Native</td>
<td>Native</td>
</tr>
<tr>
<td><strong>Sub-agent delegation</strong></td>
<td>Can call Claude Code or Codex as sub-agents</td>
<td>No external sub-agents</td>
<td>No external sub-agents</td>
</tr>
<tr>
<td><strong>Status (Sep 2026)</strong></td>
<td>Developer preview (breaking changes expected)</td>
<td>Generally available</td>
<td>Generally available</td>
</tr>
</tbody>
</table>
<h3>Benchmark Reality Check</h3>
<p>When <a href="https://composio.dev/content/deepseek-harness-vs-claude-code" target="_blank" rel="noopener nofollow">Composio ran DeepSeek V4-Pro through several harnesses</a> on 30 standardized agentic tasks, the results revealed that the harness — not the model — drove significant performance variation:</p>
<ul>
<li><strong>Pi harness</strong>: 21/30 tasks completed</li>
<li><strong>DeepSeek Harness</strong>: 20/30 tasks</li>
<li><strong>Claude Code</strong> (same model): 19/30 tasks</li>
</ul>
<p>However, Claude Code finished in roughly <strong>half the median time</strong> and used 90 fewer tool calls. Codex took longer and made more calls but cost around <strong>58% less</strong>. The takeaway for architects: raw task completion, latency, and cost per task are three separate optimization axes, and the harness mediates all three.</p>
<p>When each harness runs its <em>native</em> model (Claude Fable 5.1 on Claude Code, DeepSeek V4-Pro on dsh), performance gaps shift again. The point is not which wins on a leaderboard — it&#8217;s that <strong>harness selection is now a first-class architectural decision</strong>, on par with model selection.</p>
<h3>The Sub-Agent Trick</h3>
<p>One of DeepSeek Harness&#8217;s most distinctive features is its <strong>sub-agent provider system</strong>. It ships plugins that can delegate tasks directly to Claude Code and OpenAI Codex by resolving their binaries from the system PATH. This means you can run dsh as the orchestration layer on a server while using Claude Code as the interactive agent in your IDE — or call Codex for specific tasks where GPT excels (e.g., rapid prototyping) while routing complex reasoning tasks to Anthropic&#8217;s models.</p>
<p>No other harness currently offers this level of cross-vendor delegation.</p>
<h2>Getting Started: From Zero to Agent in Five Minutes</h2>
<p>DeepSeek Harness requires Node.js. Installation is a single command:</p>
<pre><code>npx @deepseek-ai/dsh web</code></pre>
<p>This starts the Web UI at <code>http://127.0.0.1:3080</code> and opens it in your default browser. The <code>web</code> command launches DeepSeek Harness in its full-featured web mode; for terminal-only workflows, replace <code>web</code> with <code>cli</code>.</p>
<h3>Running from Source</h3>
<pre><code>git clone https://github.com/deepseek-ai/deepseek-harness.git
cd deepseek-harness
pnpm install
pnpm run build
pnpm dsh web</code></pre>
<h3>Configuring a Non-Default Model Provider</h3>
<p>To route through Anthropic instead of DeepSeek&#8217;s own API, configure a provider plugin in your <code>dsh</code> config:</p>
<pre><code>{
  "providers": {
    "anthropic": {
      "apiKey": "sk-ant-...",
      "model": "claude-fable-5-1"
    }
  }
}</code></pre>
<p>The same pattern works for OpenAI, AWS Bedrock, Azure, and Google Vertex AI. The model adapter plugin handles provider-specific request formatting, authentication, and streaming behavior — you configure, it adapts.</p>
<h3>Installing Plugins</h3>
<p>Plugins follow a declarative install pattern. From the dsh CLI:</p>
<pre><code>dsh plugin install @dsh/docker-sandbox
dsh plugin install @dsh/mcp-bridge
dsh plugin install @dsh/ast-analyzer</code></pre>
<p>Each plugin registers its services (tools, events, lifecycle hooks) into the Cordis context automatically. No code wiring required.</p>
<h2>Why This Matters for RPA and Automation Teams</h2>
<p>If you work in enterprise RPA — building bots with <a href="https://rpabotsworld.com/uipath-vs-automation-anywhere-vs-blue-prism-agentic-platforms-2026/">UiPath, Automation Anywhere, or Blue Prism</a> — DeepSeek Harness might seem like a different world. It is not. The convergence between RPA and agentic AI is accelerating, and understanding the harness layer is becoming essential for several reasons:</p>
<h3>1. The Harness Is the New Orchestrator</h3>
<p>Traditional RPA uses an orchestrator (UiPath Orchestrator, AA Control Room) to schedule, monitor, and manage bot execution. In the agentic world, the <em>harness</em> fills this role — managing the agent loop, tool access, context persistence, error recovery, and sandbox isolation. DeepSeek Harness&#8217;s plugin architecture means these orchestration concerns are modular and replaceable, much like how <a href="https://rpabotsworld.com/uipath-autopilot-coding-agent-ga-guide-2/">UiPath&#8217;s Autopilot is evolving from a bot assistant into a coding agent</a>.</p>
<h3>2. MCP Bridges Enable Hybrid Architectures</h3>
<p>The MCP bridge plugins in DeepSeek Harness allow it to connect to any MCP-compatible tool server. For RPA teams, this opens a practical integration path: expose your existing RPA workflows as MCP tools, and an agentic harness can orchestrate them alongside API calls, browser automation, and LLM reasoning. This is the same integration model that the <a href="https://rpabotsworld.com/a2a-joins-mcp-aaif-agentic-ai-architects-guide/">Agentic AI Foundation is standardizing with MCP and A2A</a>.</p>
<h3>3. Self-Hosting Is an Enterprise Requirement</h3>
<p>Many RPA deployments operate under strict data residency, compliance, and air-gapped network requirements. Claude Code and Codex are cloud-hosted services. DeepSeek Harness can run entirely on-premises — local Node.js process, Docker sandbox, self-hosted model endpoint — with no data leaving the network boundary. For regulated industries (banking, healthcare, government), this is not a nice-to-have; it is a deployment prerequisite.</p>
<h3>4. Model Agnosticism Reduces Vendor Risk</h3>
<p>Enterprise automation teams learned painful lessons about platform lock-in during the first RPA wave. DeepSeek Harness&#8217;s model-agnostic architecture lets you swap providers without rewriting agent logic. Start with DeepSeek V4-Pro for cost efficiency, switch to Claude Fable 5.1 for complex reasoning tasks, or route to a fine-tuned open-weight model for domain-specific automation — all through configuration, not code changes.</p>
<h2>Production Considerations: What the Developer Preview Gets Right (and Wrong)</h2>
<p>DeepSeek Harness is explicitly labeled as a <strong>developer preview</strong>. The README states in bold: &#8220;THERE WILL BE COMPATIBILITY-BREAKING CHANGES.&#8221; Teams evaluating it for production should understand what this means.</p>
<h3>What Works Today</h3>
<ul>
<li><strong>Plugin composition</strong> — the core Cordis runtime is mature (4 years in production on the Koishi platform) and handles plugin lifecycle management reliably.</li>
<li><strong>Multi-provider routing</strong> — switching between model providers is genuinely configuration-only, and the sub-agent delegation to Claude Code/Codex works.</li>
<li><strong>Web UI</strong> — the default web interface is functional and sufficient for development and light team use.</li>
<li><strong>MCP integration</strong> — bridge plugins connect to the growing MCP ecosystem with reasonable stability.</li>
<li><strong>Community velocity</strong> — 210k stars and 24.5k forks in three weeks means a large contributor base is forming, plugin development is active, and bugs surface (and get fixed) quickly.</li>
</ul>
<h3>What Does Not Work Yet</h3>
<ul>
<li><strong>API stability</strong> — plugin interfaces, configuration schemas, and CLI commands are actively changing between versions. Pinning to a specific commit is the only safe strategy for anything beyond experimentation.</li>
<li><strong>Enterprise features</strong> — audit logging, role-based access control, multi-tenant isolation, and compliance tooling are either missing or community-contributed and unvetted.</li>
<li><strong>Documentation depth</strong> — the architecture docs and README are solid but the plugin authoring guide is still sparse. Expect to read source code.</li>
<li><strong>Windows support</strong> — primary development targets Linux and macOS; Windows support exists but edge cases surface regularly in GitHub issues.</li>
</ul>
<h3>When to Adopt</h3>
<table>
<thead>
<tr>
<th>Use Case</th>
<th>Readiness</th>
</tr>
</thead>
<tbody>
<tr>
<td>Personal coding agent / developer productivity</td>
<td>Ready now</td>
</tr>
<tr>
<td>Internal team experiments and hackathons</td>
<td>Ready now</td>
</tr>
<tr>
<td>Evaluating harness architecture for future platform decisions</td>
<td>Ready now</td>
</tr>
<tr>
<td>Custom agent for a specific internal workflow (non-critical)</td>
<td>Cautious yes — pin your version</td>
</tr>
<tr>
<td>Customer-facing production agent</td>
<td>Wait for stable API</td>
</tr>
<tr>
<td>Regulated-industry production deployment</td>
<td>Wait for enterprise features</td>
</tr>
</tbody>
</table>
<h2>The Bigger Picture: Why the Harness Layer Is Emerging</h2>
<p>DeepSeek Harness is not an isolated phenomenon. It arrives in a month when Anthropic released <a href="https://www.anthropic.com/claude-fable-and-mythos-5-1" target="_blank" rel="noopener nofollow">Claude Fable 5.1 with 75% cheaper cached context</a>, explicitly pricing for long-running agents. Microsoft shipped <a href="https://rpabotsworld.com/microsoft-agent-framework-1-0-foundry-agentic-ai-architect-guide/">Agent Framework 1.0</a> and Foundry Agent Service. The <a href="https://rpabotsworld.com/a2a-joins-mcp-aaif-agentic-ai-architects-guide/">Agentic AI Foundation admitted A2A alongside MCP</a> as co-equal protocols.</p>
<p>All of these developments point to the same architectural insight: <strong>the model is becoming a commodity; the orchestration layer is becoming the product</strong>. Models compete on intelligence and price. Harnesses compete on how efficiently they put that intelligence to work — managing context windows, orchestrating tool calls, handling failures, enforcing security boundaries, and persisting state across sessions.</p>
<p>For the RPA and automation community, this mirrors a pattern we lived through a decade ago. In 2015, the &#8220;robot&#8221; (the bot runtime) was the product. By 2020, the orchestrator and the platform around it — process mining, test suites, governance dashboards — determined enterprise value. The same shift is happening in agentic AI, but compressed into months rather than years.</p>
<p>DeepSeek Harness&#8217;s contribution is proving that this orchestration layer can be <strong>open-source, composable, and model-agnostic</strong> without sacrificing capability. Whether dsh itself becomes the standard or simply accelerates the category, it has already changed how architects think about agent infrastructure.</p>
<h2>Frequently Asked Questions</h2>
<h3>Is DeepSeek Harness free to use commercially?</h3>
<p>Yes. DeepSeek Harness is released under the MIT license, which permits commercial use, modification, and distribution without restriction. You still need to pay for inference from whichever model provider you configure (DeepSeek, Anthropic, OpenAI, etc.), but the harness runtime itself is completely free.</p>
<h3>Can I use DeepSeek Harness with Claude or GPT models instead of DeepSeek?</h3>
<p>Yes. The model adapter is a plugin, so you can configure Anthropic (Claude Fable 5.1, Opus 5, Sonnet 5), OpenAI (GPT-5.6 Sol, GPT-5.4), AWS Bedrock, Azure, or Google Vertex AI as your inference provider. You can even use the sub-agent providers to delegate specific tasks to Claude Code or OpenAI Codex directly.</p>
<h3>How does DeepSeek Harness compare to LangChain or CrewAI?</h3>
<p>LangChain is a chain-of-invocations framework focused on composing LLM calls with tools. CrewAI models agents as role-based collaborators. DeepSeek Harness is a full agent <em>runtime</em> — it manages the complete lifecycle including the agent loop, sandboxing, session persistence, and UI, with every component swappable via plugins. It operates at a lower infrastructure level than LangChain or CrewAI, closer to what Claude Code and Codex provide but fully open-source.</p>
<h3>Is DeepSeek Harness production-ready?</h3>
<p>Not for customer-facing or regulated workloads. It is in developer preview with expected breaking changes. The underlying Cordis runtime is mature (4 years of production use), but the harness-specific plugin APIs and configuration schemas are still stabilizing. It is suitable for personal use, team experiments, and internal non-critical workflows today.</p>
<h3>Can RPA bots be integrated with DeepSeek Harness?</h3>
<p>Yes, through MCP bridge plugins. If your RPA platform exposes workflows as MCP-compatible tool servers (or you wrap them in an MCP adapter), DeepSeek Harness can orchestrate them alongside other tools. This is the same integration pattern being standardized by the Agentic AI Foundation&#8217;s MCP and A2A protocols.</p>
<h2>Key Takeaways</h2>
<ul>
<li><strong>DeepSeek Harness</strong> (<code>dsh</code>) is an open-source, MIT-licensed agent runtime that has crossed 210,000 GitHub stars in three weeks, breaking the platform&#8217;s fastest-star record.</li>
<li>Its <strong>&#8220;everything-is-a-plugin&#8221; architecture</strong>, built on the Cordis meta-framework, lets you swap the model adapter, agent loop, tool registry, sandbox, and even the UI without changing source code.</li>
<li>It is <strong>model-agnostic</strong> — supports Anthropic, OpenAI, DeepSeek, AWS Bedrock, Azure, and Google out of the box, and can delegate sub-tasks to Claude Code or Codex.</li>
<li><strong>Benchmarks show the harness layer matters</strong> — the same model routed through different harnesses produces different task-completion rates, latencies, and costs.</li>
<li>For <strong>RPA and automation teams</strong>, DeepSeek Harness demonstrates that the orchestration layer (not the model) is becoming the critical architectural decision — mirroring the orchestrator-over-bot shift that defined enterprise RPA maturity.</li>
<li>It is in <strong>developer preview</strong> — suitable for experiments and internal tools now, but enterprise production deployments should wait for API stabilization and governance features.</li>
<li><strong>110+ curated plugins</strong> and native MCP bridge support make it a strong candidate for hybrid agentic-AI + RPA architectures.</li>
</ul>
<h2>References</h2>
<ol>
<li>DeepSeek AI. &#8220;DeepSeek Harness: Everything is a Plugin.&#8221; GitHub Repository, August 2026. <a href="https://github.com/deepseek-ai/deepseek-harness" target="_blank" rel="noopener nofollow">https://github.com/deepseek-ai/deepseek-harness</a></li>
<li>Lardinois, Frederic. &#8220;DeepSeek open sources an agent harness where everything is a plugin.&#8221; <em>The New Stack</em>, August 13, 2026. <a href="https://thenewstack.io/deepseek-harness-open-source-plugins/" target="_blank" rel="noopener nofollow">https://thenewstack.io/deepseek-harness-open-source-plugins/</a></li>
<li>Pillitteri, Pasquale. &#8220;DeepSeek Harness Breaks GitHub&#8217;s Fastest Star Record.&#8221; August 2026. <a href="https://pasqualepillitteri.it/en/news/11573/deepseek-harness-fastest-github-stars-record" target="_blank" rel="noopener nofollow">https://pasqualepillitteri.it/en/news/11573/deepseek-harness-fastest-github-stars-record</a></li>
<li>Composio. &#8220;DeepSeek Harness vs Claude Code in 2026: Open Runtime vs the Deepest Closed Harness.&#8221; <a href="https://composio.dev/content/deepseek-harness-vs-claude-code" target="_blank" rel="noopener nofollow">https://composio.dev/content/deepseek-harness-vs-claude-code</a></li>
<li>MindStudio. &#8220;DeepSeek Harness vs Claude Code vs Codex: Which Coding Agent Wins?&#8221; <a href="https://www.mindstudio.ai/blog/deepseek-harness-vs-claude-code-codex" target="_blank" rel="noopener nofollow">https://www.mindstudio.ai/blog/deepseek-harness-vs-claude-code-codex</a></li>
<li>Habr. &#8220;Inside DeepSeek Harness: Cordis, Session Events, Tool Pipelines, and Permission Boundaries.&#8221; <a href="https://habr.com/en/articles/1070958/" target="_blank" rel="noopener nofollow">https://habr.com/en/articles/1070958/</a></li>
<li>Franzen, Carl. &#8220;Anthropic&#8217;s Claude Fable 5.1 and Mythos 5.1 arrive with a 75% cost reduction for Fable cache reads.&#8221; <em>VentureBeat</em>, September 1, 2026. <a href="https://venturebeat.com/technology/anthropics-claude-fable-5-1-and-mythos-5-1-arrive-with-a-75-cost-reduction-for-fable-cache-reads" target="_blank" rel="noopener nofollow">https://venturebeat.com/technology/anthropics-claude-fable-5-1-and-mythos-5-1-arrive-with-a-75-cost-reduction-for-fable-cache-reads</a></li>
<li>Cordiverse. &#8220;Cordis: A Programming Paradigm for Spatiotemporal Composability.&#8221; arXiv:2608.25512. <a href="https://arxiv.org/abs/2608.25512" target="_blank" rel="noopener nofollow">https://arxiv.org/abs/2608.25512</a></li>
<li>Flowtivity. &#8220;DeepSeek Harness: Why 95,000 GitHub Stars in 2 Days Matters.&#8221; <a href="https://flowtivity.ai/blog/deepseek-harness-open-source-agent-explained/" target="_blank" rel="noopener nofollow">https://flowtivity.ai/blog/deepseek-harness-open-source-agent-explained/</a></li>
<li>AlphaMatch AI. &#8220;DeepSeek Harness: Revolutionizing AI Agent Development with &#8216;Everything is a Plugin.'&#8221; <a href="https://www.alphamatch.ai/blog/deepseek-harness-everything-is-a-plugin-2026" target="_blank" rel="noopener nofollow">https://www.alphamatch.ai/blog/deepseek-harness-everything-is-a-plugin-2026</a></li>
</ol>
]]></content:encoded>
					
					<wfw:commentRss>https://rpabotsworld.com/deepseek-harness-open-source-agent-framework-guide/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>The Agent Skills Explosion: 9 Open-Source Repos Reshaping Agentic AI (2026)</title>
		<link>https://rpabotsworld.com/agent-skills-explosion-open-source-repos-registries-security-2026/</link>
					<comments>https://rpabotsworld.com/agent-skills-explosion-open-source-repos-registries-security-2026/#comments</comments>
		
		<dc:creator><![CDATA[Satish Prasad]]></dc:creator>
		<pubDate>Mon, 26 Oct 2026 05:11:29 +0000</pubDate>
				<category><![CDATA[AI Agents & Frameworks]]></category>
		<category><![CDATA[RPA & Bot Automation]]></category>
		<category><![CDATA[Open-Source Agents]]></category>
		<guid isPermaLink="false">https://rpabotsworld.com/?p=32362</guid>

					<description><![CDATA[Nine trending open-source agent skill repos, registries, and security tools — with star counts, licenses, and the 26.1% vulnerability stat every AI…]]></description>
										<content:encoded><![CDATA[<h2>Why Agent Skills Are the Hottest Layer in the Agentic AI Stack Right Now</h2>
<p>In early September 2026, something unusual happened on GitHub Trending. For three consecutive days — September 4, 5, and 6 — the trending list was dominated not by new AI models, not by another coding agent, but by <strong>agent skills</strong>: reusable capability packages that teach AI agents how to perform specialized tasks. Anthropic&#8217;s public skills repo gained 475 stars in a single day. NVIDIA shipped a security scanner specifically for vetting skills before installation. Google launched an official skills repository at Cloud Next 2026. A startup called OpenAgentSkill raised its hand as &#8220;npm for AI Agent Skills.&#8221;</p>
<p>The pattern is clear: the agentic AI ecosystem has bifurcated into three distinct layers — <strong>runtimes</strong> (agents that run), <strong>skills</strong> (what agents know how to do), and <strong>meta-tools</strong> (security scanners, context managers, registries) that sit on top of both. If you are an Agentic AI Architect, an RPA developer evaluating agent-augmented automation, or an engineering leader planning your 2027 agent platform strategy, the skills layer is where the action is — and where the risk is hiding.</p>
<p>This roundup covers the nine most significant open-source agent skill repositories, registries, and security tools trending right now, with star counts, license details, what each actually does, and who should care.</p>
<h2>What Exactly Are Agent Skills?</h2>
<p>Agent skills are self-contained instruction packages — typically a folder containing a <code>SKILL.md</code> file plus optional scripts, templates, and resources — that an AI coding agent loads dynamically to gain specialized knowledge about a task. Think of them as the difference between a generalist developer and a domain expert: the base agent can write code, but a skill teaches it <em>how</em> to write a UiPath workflow, or audit a Kubernetes deployment, or generate a compliant patent disclosure document.</p>
<p>The format originated at Anthropic and was <a href="https://rpabotsworld.com/a2a-joins-mcp-aaif-agentic-ai-architects-guide/">released as an open standard</a> that has since been adopted by Claude Code, OpenAI Codex, Gemini CLI, Cursor, Windsurf, and dozens of other agent products. Unlike MCP servers (which expose <em>tools</em> — callable functions), skills expose <em>knowledge</em> — instructions, best practices, and decision frameworks that shape how the agent reasons about a domain.</p>
<p>This distinction matters for enterprise adoption. An MCP server gives an agent access to your Jira API. A skill teaches the agent your team&#8217;s sprint planning conventions, your definition-of-done checklist, and when to escalate versus auto-assign. Skills are the connective tissue between raw capability and production-grade reliability.</p>
<h2>The Nine Repos You Need to Know</h2>
<p>Below is a quick-reference comparison table, followed by deep dives on each project.</p>
<table>
<thead>
<tr>
<th>Project</th>
<th>Stars</th>
<th>License</th>
<th>Category</th>
<th>One-Line Pitch</th>
</tr>
</thead>
<tbody>
<tr>
<td><strong>anthropics/skills</strong></td>
<td>~149K</td>
<td>Source-available</td>
<td>Reference implementation</td>
<td>Anthropic&#8217;s production skills — the format origin and quality bar</td>
</tr>
<tr>
<td><strong>google/skills</strong></td>
<td>~15K+</td>
<td>Apache 2.0</td>
<td>Vendor skills</td>
<td>First-party Google Cloud and Workspace skills, install via CLI</td>
</tr>
<tr>
<td><strong>NVIDIA/SkillSpector</strong></td>
<td>Trending</td>
<td>Open source</td>
<td>Security scanner</td>
<td>64-pattern scanner that risk-scores skills before you install them</td>
</tr>
<tr>
<td><strong>OpenAgentSkill</strong></td>
<td>Growing</td>
<td>Open source</td>
<td>Registry + trust layer</td>
<td>npm for AI agent skills — discover, compare, install, audit</td>
</tr>
<tr>
<td><strong>humanlayer/skills</strong></td>
<td>~442/day</td>
<td>Open source</td>
<td>Community library</td>
<td>Community-curated skills library from the HumanLayer team</td>
</tr>
<tr>
<td><strong>K-Dense-AI/scientific-agent-skills</strong></td>
<td>+1,980/wk</td>
<td>Open source</td>
<td>Domain-specific</td>
<td>165 validated skills for biology, chemistry, medicine, drug discovery</td>
</tr>
<tr>
<td><strong>Imbad0202/academic-research-skills</strong></td>
<td>+496/wk</td>
<td>Open source</td>
<td>Domain-specific</td>
<td>Full research-to-publish pipeline as composable agent skills</td>
</tr>
<tr>
<td><strong>blader/humanizer</strong></td>
<td>+1,208/wk</td>
<td>Open source</td>
<td>Utility skill</td>
<td>Strips AI-generated markers from text output</td>
</tr>
<tr>
<td><strong>qufei1993/skills-hub</strong></td>
<td>Growing</td>
<td>Open source</td>
<td>Management tool</td>
<td>Desktop app to manage and sync skills across 50+ coding agents</td>
</tr>
</tbody>
</table>
<h2>1. anthropics/skills — The Format Origin and Quality Bar</h2>
<p><strong>Stars:</strong> ~149,000 | <strong>License:</strong> Source-available | <strong>GitHub:</strong> <a href="https://github.com/anthropics/skills" target="_blank" rel="noopener nofollow">anthropics/skills</a></p>
<p>This is the repository that started it all. Anthropic open-sourced their internal agent skills format — originally developed for Claude Code — and published their production skills as a reference implementation. The repo includes the <code>./spec/</code> folder containing the Agent Skills specification itself, a <code>./template/</code> for creating new skills, a <code>skill-creator</code> skill (a meta-skill that helps you build new skills), and the production document-generation skills (docx, pdf, pptx, xlsx) that Anthropic uses in its own products.</p>
<p>The skills range from creative applications (algorithmic art, canvas design) to technical tasks (MCP server generation, web app testing) to enterprise workflows (internal communications, brand guidelines). Each skill follows a consistent structure: a <code>SKILL.md</code> with instructions, optional scripts for complex operations, and resource files.</p>
<p><strong>Why it matters for Agentic AI Architects:</strong> This isn&#8217;t just a library — it&#8217;s the <em>specification</em>. If you&#8217;re building skills for your organization&#8217;s agent fleet, this repo defines the format that Google, NVIDIA, and the broader ecosystem have converged on. Start here to understand the contract your skills need to fulfill.</p>
<h2>2. google/skills — First-Party Vendor Skills at Scale</h2>
<p><strong>Stars:</strong> ~15,000+ | <strong>License:</strong> Apache 2.0 | <strong>GitHub:</strong> <a href="https://github.com/google/skills" target="_blank" rel="noopener nofollow">google/skills</a></p>
<p>Announced at Cloud Next 2026, Google&#8217;s official skills repository ships thirteen skills out of the gate: seven product-specific skills covering AlloyDB, BigQuery, Cloud Run, Cloud SQL, Firebase, the Gemini API, and GKE; three Well-Architected Pillar skills for Security, Reliability, and Cost Optimization; and three &#8220;recipe&#8221; skills for Google Cloud Onboarding, Authentication, and Network Observability.</p>
<p>The installation story is clean: <code>npx skills install github.com/google/skills</code> drops them into any compatible agent — Gemini CLI, Antigravity, Claude Code, Codex, or custom runtimes. Google published a behind-the-scenes blog detailing how they build, test, and scale these skills internally, which is itself a useful reference for teams building their own.</p>
<p><strong>Why it matters:</strong> Google publishing vendor-specific skills under Apache 2.0 signals that the skills format has achieved the kind of cross-vendor adoption that MCP achieved for tool integration. When the two largest AI labs (Anthropic, Google) and the largest GPU vendor (NVIDIA) all ship skills in the same format within weeks of each other, the format war is effectively over. If your team uses Google Cloud, these skills are free, production-tested knowledge that your agents should already have installed.</p>
<h2>3. NVIDIA/SkillSpector — Security Scanner for the Skills Supply Chain</h2>
<p><strong>Version:</strong> 2.0.0 | <strong>License:</strong> Open source | <strong>GitHub:</strong> <a href="https://github.com/nvidia/skillspector" target="_blank" rel="noopener nofollow">NVIDIA/SkillSpector</a></p>
<p>This is arguably the most important project on this list, and the reason is a single statistic: <strong>26.1 percent of skills on major marketplaces contain at least one vulnerability, and 5.2 percent show likely malicious intent.</strong> That finding comes from NVIDIA&#8217;s own research, which scanned 42,447 skills from major marketplaces and registries.</p>
<p>SkillSpector runs two passes. The first is static and takes seconds: an AST walk flags <code>exec</code>, <code>eval</code>, <code>subprocess</code>, and dynamic imports, while a taint tracker follows environment variables and file contents to network sinks. The second pass is optional and uses an LLM to read flagged code in context, drop false positives, and write human-readable explanations — achieving roughly 87% precision. The output is a 0–100 risk score, a list of findings, and recommendations.</p>
<p>You can point it at a directory, a zip file, a single <code>SKILL.md</code>, or a Git URL. It covers Claude Code, Codex, and MCP skills — essentially the full agent skills ecosystem.</p>
<p><strong>Why it matters:</strong> The agent skills supply chain is following the exact trajectory of npm packages circa 2018 — rapid growth, minimal vetting, and inevitable exploitation. Security firm AIR demonstrated this in August 2026 by building a fake skill, pushing it through a popular marketplace with an Instagram ad, and reaching approximately 26,000 agents — including some on corporate accounts. Every skill security scanner tested marked it as safe. SkillSpector isn&#8217;t perfect (no scanner is), but it&#8217;s the most rigorous open-source option available, and running it before any skill installation should be a non-negotiable step in your agent governance playbook.</p>
<p>For teams already running <a href="https://rpabotsworld.com/uipath-autopilot-coding-agent-ga-guide-2/">UiPath Autopilot as a coding agent</a> or deploying agents via <a href="https://rpabotsworld.com/microsoft-agent-framework-1-0-foundry-agentic-ai-architect-guide/">Microsoft Agent Framework 1.0</a>, integrating SkillSpector into your CI/CD pipeline for skill vetting is the single highest-impact security action you can take today.</p>
<h2>4. OpenAgentSkill — npm for AI Agent Skills</h2>
<p><strong>Website:</strong> <a href="https://www.openagentskill.com/" target="_blank" rel="noopener nofollow">openagentskill.com</a> | <strong>GitHub:</strong> <a href="https://github.com/Leon-Drq/openagentskill" target="_blank" rel="noopener nofollow">Leon-Drq/openagentskill</a></p>
<p>If individual skill repos are packages, OpenAgentSkill is the registry. It positions itself as &#8220;npm for AI Agent Skills&#8221; — a central discovery, comparison, trust-scoring, and installation layer for the entire skills ecosystem. The platform indexes over 5,400 skills from multiple sources and provides a composite quality signal that factors in GitHub adoption, freshness, metadata quality, trust checks, audit signals, use-case fit, and install readiness.</p>
<p>OpenAgentSkill also published a remarkably transparent &#8220;State of Agent Skills 2026&#8221; report that examines what&#8217;s actually inside the registry: which records are genuine reusable skills versus documentation or wrappers, which are maintained, which declare a license, and — critically — how little real outcome evidence the ecosystem still has. That intellectual honesty is rare in a space prone to hype.</p>
<p><strong>Why it matters:</strong> The npm analogy is apt in both the positive and negative sense. npm made JavaScript&#8217;s package ecosystem discoverable and installable, but it also introduced dependency hell and supply-chain attacks. OpenAgentSkill&#8217;s trust layer is an attempt to get ahead of that — every skill gets a quality score, license check, and install safety assessment before you run <code>install</code>. If you&#8217;re managing an enterprise agent fleet, having a registry that pre-filters is more sustainable than manually vetting GitHub repos.</p>
<h2>5. humanlayer/skills — Community-Curated Skills Library</h2>
<p><strong>Trending:</strong> +442 stars/day | <strong>License:</strong> Open source | <strong>GitHub:</strong> <a href="https://github.com/humanlayer/skills" target="_blank" rel="noopener nofollow">humanlayer/skills</a></p>
<p>HumanLayer — known for their human-in-the-loop agent approval framework — has released a community skills library that complements the vendor-published repos from Anthropic and Google. Where those repos focus on their own products, HumanLayer&#8217;s collection covers cross-cutting concerns: workflow patterns, approval chains, escalation logic, and the kind of glue-logic skills that emerge from actual production agent deployments.</p>
<p><strong>Why it matters:</strong> Not every skill needs to come from a Fortune 500 vendor. Some of the most valuable skills are the ones that encode your team&#8217;s operational patterns — &#8220;how we do code review,&#8221; &#8220;how we triage support tickets,&#8221; &#8220;how we handle on-call escalation.&#8221; HumanLayer&#8217;s library provides templates for exactly these patterns, and the human-in-the-loop focus aligns with the governance requirements that enterprise <a href="https://rpabotsworld.com/uipath-vs-automation-anywhere-vs-blue-prism-agentic-platforms-2026/">RPA platforms like UiPath and Automation Anywhere</a> already enforce.</p>
<h2>6. K-Dense-AI/scientific-agent-skills — 165 Validated Domain Skills</h2>
<p><strong>Trending:</strong> +1,980 stars/week | <strong>License:</strong> Open source</p>
<p>This repository stands out because of its specificity and rigor. It contains 165 validated agent skills covering biology, chemistry, medicine, and drug discovery — each skill designed for a specific scientific workflow: literature review, experimental design, data analysis pipelines, regulatory compliance checks, and compound interaction prediction.</p>
<p>The validation angle is what separates this from a generic skills dump. Each skill has been tested against real scientific workflows and includes documented accuracy benchmarks, making it one of the first skills libraries that provides genuine outcome evidence rather than just &#8220;it runs without errors.&#8221;</p>
<p><strong>Why it matters:</strong> Scientific research is one of the highest-value domains for agentic AI, and also one of the most error-sensitive. If you&#8217;re in pharma, biotech, or academic research, this library is directly useful. For everyone else, it&#8217;s a template for what a <em>serious</em> domain-specific skills library looks like — validated, benchmarked, and documented.</p>
<h2>7. Imbad0202/academic-research-skills — Research-to-Publish Pipeline</h2>
<p><strong>Trending:</strong> +496 stars/week | <strong>License:</strong> Open source</p>
<p>A skill set that packages the complete academic research lifecycle — from literature discovery through writing, peer-review preparation, revision, and finalization — into composable agent skills. It is specifically designed for Claude Code but portable to other skill-compatible agents.</p>
<p>The interesting architectural pattern here is <em>composability</em>: rather than one monolithic &#8220;write a research paper&#8221; skill, the pipeline is broken into discrete stages that can be chained, skipped, or replaced. This mirrors the modular <a href="https://rpabotsworld.com/pydantic-ai-v2-capabilities-composable-agents-guide/">composable agent architecture that Pydantic AI v2 introduced</a> — the principle is the same whether you&#8217;re composing code-level agents or knowledge-level skills.</p>
<p><strong>Why it matters:</strong> The composability pattern is the real takeaway. If you&#8217;re building enterprise skills for your RPA or agentic automation team, don&#8217;t build monolithic mega-skills. Build small, testable, chainable units — the same way you build reusable automation components in UiPath or Power Automate.</p>
<h2>8. blader/humanizer — The Most Controversial Trending Skill</h2>
<p><strong>Trending:</strong> +1,208 stars/week | <strong>License:</strong> Open source</p>
<p>This agent skill does one thing: it strips markers of AI-generated writing from text. It gained over 1,200 stars in a single week, making it one of the fastest-rising skills on GitHub Trending.</p>
<p>The ethical implications are immediately obvious and worth addressing directly. While there are legitimate use cases — a professional writer using AI as a drafting assistant who wants to polish the output to match their voice, or a non-native English speaker refining translated text — the project also enables academic dishonesty and content fraud. Its viral popularity says less about the tool and more about a market gap: people want AI-assisted writing that doesn&#8217;t read like AI-assisted writing.</p>
<p><strong>Why it matters for this roundup:</strong> Controversial or not, a skill gaining 1,200 stars in a week demonstrates the distribution power of the skills format. Skills that solve a genuine pain point (whether you agree with the use case or not) spread virally through the agent ecosystem in a way that standalone tools never did. This is the skills supply chain in action — and it&#8217;s exactly why security and governance tooling like SkillSpector exists.</p>
<h2>9. qufei1993/skills-hub — The Skills Management Layer</h2>
<p><strong>Trending:</strong> Growing | <strong>License:</strong> Open source</p>
<p>As the number of available skills crosses the thousands, a new problem emerges: management. Skills Hub is a cross-platform desktop application that manages and syncs agent skills across 50+ coding tools — Claude Code, Codex, Cursor, Windsurf, Gemini CLI, and more. It provides a single pane of glass for installing, updating, removing, and auditing the skills loaded into each agent in your toolchain.</p>
<p>A sibling project, <strong>xingkongliang/skills-manager</strong>, tackles the same problem with a lighter footprint. The fact that two independent projects targeting skills management are trending simultaneously confirms that skills sprawl is already a pain point in production environments.</p>
<p><strong>Why it matters:</strong> Enterprise teams running multiple agent products — and most do, given the fragmentation between coding agents, workflow agents, and domain-specific agents — need a way to enforce consistent skill versions, audit what&#8217;s installed, and push updates. Skills Hub is early but directionally correct. Pair it with SkillSpector for vetting and OpenAgentSkill for discovery, and you have the beginnings of a governed skills supply chain.</p>
<h2>The Security Elephant in the Room</h2>
<p>The agent skills ecosystem is growing faster than its security infrastructure can keep up. The numbers are sobering:</p>
<ul>
<li><strong>26.1% of skills</strong> on major marketplaces contain at least one vulnerability (NVIDIA research, August 2026).</li>
<li><strong>5.2% show likely malicious intent</strong> — not accidental bugs, but deliberate data exfiltration or prompt injection.</li>
<li><strong>341 malicious skills</strong> were found on ClawHub by security researchers at Koi Security, who audited all 2,857 skills on the marketplace (February 2026).</li>
<li>Security firm AIR demonstrated a <strong>fake skill reaching ~26,000 agents</strong> — including corporate accounts — with every scanner marking it safe.</li>
<li>Manifold Security disclosed <strong>eight security flaws across seven CLI coding agents</strong> where a repository&#8217;s Git configuration can execute arbitrary commands via the agent without an approval prompt (September 2026).</li>
</ul>
<p>The parallel to the npm supply chain crisis is almost exact. In 2018, a malicious npm package (<code>event-stream</code>) compromised a Bitcoin wallet library with 2 million weekly downloads. The agent skills ecosystem is at the same inflection point — growing fast enough to be valuable, but not yet mature enough to be safe by default.</p>
<p>For Agentic AI Architects, the minimum viable governance stack for skills today is:</p>
<ol>
<li><strong>Vet before install</strong> — Run SkillSpector (or equivalent) on every skill before it touches your agents.</li>
<li><strong>Pin versions</strong> — Never pull skills from <code>main</code> in production. Pin to a specific commit hash.</li>
<li><strong>Audit the registry</strong> — If you use OpenAgentSkill or any registry, check the trust score, license, and maintenance status. A skill with no license declaration is a legal liability.</li>
<li><strong>Isolate execution</strong> — Skills that include executable scripts should run in sandboxed environments, not with your agent&#8217;s full permissions.</li>
<li><strong>Monitor behavior</strong> — Skills that phone home, exfiltrate environment variables, or dynamically import code at runtime are red flags. SkillSpector&#8217;s taint tracker catches the common patterns, but novel attacks will get through.</li>
</ol>
<h2>What This Means for the RPA and Automation Community</h2>
<p>If you&#8217;ve spent years building reusable components in UiPath (custom activities, libraries, templates), Power Automate (solution components, custom connectors), or Automation Anywhere (packages, bot templates), the agent skills pattern should feel familiar — because it <em>is</em> familiar. Skills are to AI agents what reusable components are to RPA platforms: encapsulated domain knowledge that makes the next deployment faster and more reliable.</p>
<p>The difference is scope and portability. A UiPath custom activity works in UiPath. An agent skill works in Claude Code, Codex, Gemini CLI, Cursor, and any MCP-compatible agent. The <a href="https://rpabotsworld.com/a2a-joins-mcp-aaif-agentic-ai-architects-guide/">A2A protocol joining MCP at the Agentic AI Foundation</a> further accelerates this convergence — skills that encode your organization&#8217;s process knowledge become portable across the entire agent ecosystem.</p>
<p>For RPA teams evaluating the transition to agentic architectures, the actionable insight is this: start building skills <em>now</em>, even before your agent strategy is finalized. The skills you build today — encoding your team&#8217;s domain expertise in invoice processing, compliance checks, customer onboarding, data reconciliation — will be usable across whatever agent platform you adopt. The format is standardized. The portability is real. The knowledge is yours.</p>
<h2>FAQ</h2>
<h3>What is the difference between an agent skill and an MCP server?</h3>
<p>An MCP server exposes <em>tools</em> — callable functions that let an agent interact with external systems (APIs, databases, file systems). A skill exposes <em>knowledge</em> — instructions, decision frameworks, and best practices that shape how an agent reasons about a domain. In practice, they work together: a skill might tell an agent <em>how</em> to design a BigQuery schema, while an MCP server gives it the <em>ability</em> to execute queries against BigQuery.</p>
<h3>Are agent skills safe to install from public repositories?</h3>
<p>Not by default. NVIDIA&#8217;s research found that 26.1% of skills on major marketplaces contain vulnerabilities and 5.2% show malicious intent. Always run a security scanner like SkillSpector before installing any skill, pin to specific versions, and audit the skill&#8217;s code — especially any executable scripts.</p>
<h3>Can I use agent skills with UiPath, Automation Anywhere, or Power Automate?</h3>
<p>Agent skills work directly with AI coding agents (Claude Code, Codex, Gemini CLI, Cursor, etc.) and any MCP-compatible runtime. They don&#8217;t natively integrate with traditional RPA platforms, but they can be used alongside them — for example, using a skill-equipped coding agent to generate UiPath workflows, write Power Automate flows, or scaffold Automation Anywhere bot code.</p>
<h3>How do I create my own agent skill?</h3>
<p>Start with the template in <a href="https://github.com/anthropics/skills" target="_blank" rel="noopener nofollow">anthropics/skills</a>. A minimal skill is a folder containing a <code>SKILL.md</code> file with structured instructions. For more complex skills, add scripts, resource files, and sub-skills. The <code>skill-creator</code> meta-skill in the same repo can bootstrap new skills interactively.</p>
<h3>Which agent skills registry should I use?</h3>
<p>OpenAgentSkill is the most comprehensive registry with trust scoring and quality signals. For vendor-specific skills, go directly to the source: anthropics/skills for Anthropic&#8217;s production skills, google/skills for Google Cloud and Workspace. For security vetting, always run NVIDIA&#8217;s SkillSpector regardless of which registry you discover skills through.</p>
<h2>Key Takeaways</h2>
<ul>
<li>The agent skills ecosystem has emerged as the fastest-growing layer in the agentic AI stack, with multiple repos trending simultaneously on GitHub in September 2026.</li>
<li>Anthropic, Google, and NVIDIA all shipping skills-related repos in the same format confirms the Agent Skills specification as a de facto standard — the format war is over.</li>
<li>Security is the critical gap: 26.1% of skills contain vulnerabilities, and proven attacks have bypassed every existing scanner. Run NVIDIA SkillSpector before any installation.</li>
<li>Domain-specific skills (scientific, academic, enterprise workflows) are where the highest production value lies — general-purpose skills are table stakes.</li>
<li>For RPA teams: agent skills are the cross-platform equivalent of reusable automation components. Start encoding your domain knowledge as skills now — the format is standardized and portable.</li>
<li>The &#8220;npm for skills&#8221; infrastructure (registries, managers, security scanners) is forming in real time. Early adopters who establish governed skills pipelines will have a structural advantage.</li>
</ul>
<h2>References</h2>
<ol>
<li>Anthropic, &#8220;Public repository for Agent Skills,&#8221; GitHub, 2025-2026. <a href="https://github.com/anthropics/skills" target="_blank" rel="noopener nofollow">github.com/anthropics/skills</a></li>
<li>Google Cloud Blog, &#8220;Level Up Your Agents: Announcing Google&#8217;s Official Skills Repository,&#8221; Cloud Next 2026. <a href="https://cloud.google.com/blog/topics/developers-practitioners/level-up-your-agents-announcing-googles-official-skills-repository" target="_blank" rel="noopener nofollow">cloud.google.com</a></li>
<li>NVIDIA, &#8220;SkillSpector: Security scanner for AI agent skills,&#8221; GitHub, 2026. <a href="https://github.com/nvidia/skillspector" target="_blank" rel="noopener nofollow">github.com/nvidia/skillspector</a></li>
<li>Help Net Security, &#8220;SkillSpector: NVIDIA&#8217;s open-source security scanner for AI agent skills,&#8221; August 2026. <a href="https://www.helpnetsecurity.com/2026/08/03/skillspector-open-source-agent-skill-security-scanner/" target="_blank" rel="noopener nofollow">helpnetsecurity.com</a></li>
<li>OpenAgentSkill, &#8220;State of Agent Skills 2026,&#8221; 2026. <a href="https://www.openagentskill.com/reports/state-of-agent-skills-2026" target="_blank" rel="noopener nofollow">openagentskill.com</a></li>
<li>StartupCorners, &#8220;GitHub Trending September 4-6, 2026: AI Agents Dominate,&#8221; September 2026. <a href="https://startupcorners.com/digest/devtools-digest-2026-09-06" target="_blank" rel="noopener nofollow">startupcorners.com</a></li>
<li>Socket, &#8220;How AI Agents Expand the Software Supply Chain Attack Surface,&#8221; 2026. <a href="https://socket.dev/blog/ai-agents-supply-chain-attack-surface" target="_blank" rel="noopener nofollow">socket.dev</a></li>
<li>PurpleBox, &#8220;AI Agent Skills: The New Supply Chain Risk,&#8221; 2026. <a href="https://www.prplbx.com/blog/agent-skills-supply-chain" target="_blank" rel="noopener nofollow">prplbx.com</a></li>
<li>InfoQ, &#8220;The Open-Sourcing of DeepSeek Harness Opens the Door to Modular, Unbundled AI Agent Infrastructure,&#8221; August 2026. <a href="https://www.infoq.com/news/2026/08/deep-seek-harness/" target="_blank" rel="noopener nofollow">infoq.com</a></li>
<li>The Hacker News, &#8220;Why Agentic AI Is Security&#8217;s Next Blind Spot,&#8221; May 2026. <a href="https://thehackernews.com/2026/05/why-agentic-ai-is-securitys-next-blind.html" target="_blank" rel="noopener nofollow">thehackernews.com</a></li>
</ol>
]]></content:encoded>
					
					<wfw:commentRss>https://rpabotsworld.com/agent-skills-explosion-open-source-repos-registries-security-2026/feed/</wfw:commentRss>
			<slash:comments>3</slash:comments>
		
		
			</item>
		<item>
		<title>OpenClaw 2.0: The Open-Source Agent Platform Going Enterprise — A Complete Guide for Agentic AI Architects (2026)</title>
		<link>https://rpabotsworld.com/openclaw-2-open-source-agent-platform-enterprise-guide/</link>
					<comments>https://rpabotsworld.com/openclaw-2-open-source-agent-platform-enterprise-guide/#respond</comments>
		
		<dc:creator><![CDATA[Satish Prasad]]></dc:creator>
		<pubDate>Mon, 26 Oct 2026 05:11:16 +0000</pubDate>
				<category><![CDATA[AI Agents & Frameworks]]></category>
		<category><![CDATA[RPA & Bot Automation]]></category>
		<category><![CDATA[Open-Source Agents]]></category>
		<guid isPermaLink="false">https://rpabotsworld.com/?p=32365</guid>

					<description><![CDATA[OpenClaw 2.0 adds multiplayer sessions, enterprise security, and a rebuilt UI to the 250K-star open-source agent harness.]]></description>
										<content:encoded><![CDATA[<h1>OpenClaw 2.0: The Open-Source Agent Platform Going Enterprise — A Complete Guide for Agentic AI Architects (2026)</h1>
<p>On August 30, 2026, the OpenClaw Foundation shipped version 2026.8.1 — internally called OpenClaw 2.0 — the largest single release in the project&#8217;s history. It merged 16,000+ pull requests from 933 contributors, overhauling installation, the browser interface, memory, skills, security, plugins, and collaboration features. For a project that already holds 250,000+ GitHub stars and ranks among the fastest-growing open-source repositories ever created, this release carries a specific signal: OpenClaw is no longer just a personal AI agent harness. It is positioning itself as shared enterprise infrastructure.</p>
<p>That transition — from a power-user&#8217;s local agent to a team-scoped, security-hardened, browser-accessible platform — is exactly the arc that agentic AI architects need to understand. If you build, evaluate, or govern agent systems for your organization, OpenClaw 2.0 is either a platform you&#8217;ll deploy, a competitor to something you&#8217;re already running, or an architectural reference for how the open-source agent stack is evolving. This guide breaks down what changed, how the architecture works, where the security model stands, and what it means for enterprise adoption.</p>
<h2>What Is OpenClaw? A Quick Primer</h2>
<p>OpenClaw is an open-source, self-hosted AI agent runtime and message gateway. Originally published in November 2025 as &#8220;Clawdbot&#8221; by Austrian developer Peter Steinberger, it was renamed to OpenClaw in January 2026 and went viral almost immediately — crossing 100,000 GitHub stars within its first week and 210,000 stars within 60 days. It is licensed under an open-source license and stewarded by the OpenClaw Foundation, an independent 501(c)(3), with OpenAI, Microsoft, GitHub, NVIDIA, Atlassian, and Tencent listed as supporting partners.</p>
<p>At its core, OpenClaw does something deceptively simple: it lets you run a persistent AI agent on your own infrastructure, connect it to any LLM (Claude, GPT, Gemini, Llama, local models), and interact with it through channels you already use — WhatsApp, Telegram, Signal, Discord, Slack, iMessage, and 20+ others. The agent can execute shell commands, manage files, browse the web, control smart home devices, interact with productivity tools, and integrate with 50+ third-party services through its <strong>AgentSkills</strong> system.</p>
<p>But what made OpenClaw significant wasn&#8217;t any single feature. It was the architecture: a <strong>model-agnostic, self-hosted, channel-independent agent runtime</strong> that treats the LLM as a swappable backend rather than a locked-in vendor. In a market where every major cloud provider is shipping proprietary agent platforms — <a href="https://rpabotsworld.com/openai-presence-enterprise-ai-agent-platform-guide/">OpenAI Presence</a>, AWS Bedrock Agents, Google Vertex AI Agent Builder, <a href="https://rpabotsworld.com/microsoft-agent-framework-1-0-foundry-agentic-ai-architect-guide/">Microsoft Agent Framework</a> — OpenClaw offered the open-source counter-narrative: bring your own model, keep your own data, run on your own hardware.</p>
<h2>Why OpenClaw 2.0 Matters: The Personal-to-Enterprise Pivot</h2>
<p>The original OpenClaw was designed for a single operator. One person, one agent, one machine. That model worked brilliantly for developers and power users who wanted their own JARVIS-like assistant, but it hit hard limits the moment you tried to use it in a team or organizational context.</p>
<p>OpenClaw 2.0 addresses this directly with three interrelated shifts:</p>
<table>
<thead>
<tr>
<th>Dimension</th>
<th>OpenClaw 1.x</th>
<th>OpenClaw 2.0</th>
</tr>
</thead>
<tbody>
<tr>
<td><strong>Users</strong></td>
<td>Single operator</td>
<td>Multi-user with roles, presence, ownership</td>
</tr>
<tr>
<td><strong>Sessions</strong></td>
<td>Terminal-bound, ephemeral</td>
<td>Persistent, shareable, transferable</td>
</tr>
<tr>
<td><strong>Security</strong></td>
<td>Trust-the-operator defaults</td>
<td>Session permission modes, sandboxing, credential store, audit trail</td>
</tr>
<tr>
<td><strong>Interface</strong></td>
<td>Terminal-first, browser as secondary control</td>
<td>Rebuilt browser UI as primary workspace</td>
</tr>
<tr>
<td><strong>Execution</strong></td>
<td>Local host</td>
<td>Local + remote nodes + cloud workers + Docker/Podman sandboxes</td>
</tr>
</tbody>
</table>
<p>As VentureBeat noted in its coverage, &#8220;OpenClaw 2.0 seeks to transform what began largely as a personal agent harness into something increasingly designed for teams, shared infrastructure and enterprise workflows.&#8221; That framing is accurate, but the technical details underneath it are what matter for architects making deployment decisions.</p>
<h2>Architecture Deep Dive: How OpenClaw 2.0 Works</h2>
<p>OpenClaw&#8217;s architecture follows a five-component model. Understanding these components is essential before evaluating the 2.0 changes.</p>
<h3>1. Gateway: The Communication and Orchestration Hub</h3>
<p>The central Gateway process multiplexes WebSocket and HTTP communication on a single port. It manages session lifecycles, tool dispatch, channel routing, and agent orchestration. Think of it as the control plane: every message from every channel (WhatsApp, Telegram, browser UI, API) flows through the Gateway, which routes it to the appropriate agent session and manages the response cycle.</p>
<p>In 2.0, the Gateway gains multi-user awareness. It tracks session creators, owners, and participants. It manages live presence and typing indicators. It handles permission escalation requests. For teams, the Gateway effectively becomes a shared workspace server, not just a message router.</p>
<h3>2. Brain: The ReAct Reasoning Loop</h3>
<p>Agents execute through an embedded runtime that implements a multi-turn reasoning loop: the model receives conversation history and system prompts, generates tool calls, executes them sequentially, and resubmits updated context until a text-only response terminates the loop. This is a standard ReAct (Reasoning + Acting) pattern, but OpenClaw&#8217;s implementation is model-agnostic — the same loop works whether the backend is Claude Opus 5, GPT-4.5, Gemini 2.5 Pro, or a local Llama model.</p>
<h3>3. Skills: The Modular Capability Layer</h3>
<p>OpenClaw ships with 100+ preconfigured <strong>AgentSkills</strong> — modular capability packages that let the agent perform specific actions: execute shell commands, manage filesystems, automate web browsers, control smart home devices, interact with calendars, send emails, and integrate with third-party services. Skills are the primary extension mechanism for adding new agent capabilities without modifying the core runtime.</p>
<p>Additionally, OpenClaw supports <strong>MCP (Model Context Protocol) servers</strong> as a standardized plugin interface. Each MCP server runs as a separate process communicating through the protocol, enabling integration with an expanding ecosystem of tools and services — the same <a href="https://rpabotsworld.com/a2a-joins-mcp-aaif-agentic-ai-architects-guide/">MCP ecosystem</a> that Anthropic&#8217;s Claude, GitHub Copilot, and other agent platforms are converging on.</p>
<h3>4. Heartbeat: Scheduling and Automation</h3>
<p>The Heartbeat component handles scheduled and recurring agent tasks — automated workflows that run without human prompting. In 2.0, automations have been made easier to discover and operate from the browser UI, making them more accessible to non-developer users.</p>
<h3>5. Memory: Persistent State</h3>
<p>OpenClaw maintains persistent memory across conversations, allowing the agent to accumulate context about the user, their projects, preferences, and ongoing work. This is what differentiates a persistent agent from a stateless chatbot — the agent remembers what it learned yesterday and applies it today.</p>
<h2>The Rebuilt Browser UI: Making Agents Accessible Beyond Engineering</h2>
<p>One of the most consequential changes in 2.0 is the complete rebuild of the browser-based Control UI. Previously, the browser interface was a secondary control surface — a dashboard for monitoring and configuration while the real interaction happened in the terminal or messaging channels.</p>
<p>OpenClaw 2.0 makes the browser the primary interface. Users enter directly into a conversation with their agent. The sidebar shows conversation threads. The main workspace displays the active conversation alongside files, approvals, agent activity, terminal output, Git state, and pull requests. The design deliberately mirrors the interaction model of ChatGPT, Claude, and Gemini — conversational AI interfaces that enterprise employees already understand.</p>
<p>This matters for enterprise adoption for a specific reason: <strong>open-source agent frameworks are often powerful precisely because they expose low-level configuration, terminals, and runtime controls — and those same characteristics make them impossible to deploy beyond engineering teams.</strong> A finance analyst or marketing manager is never going to interact with an agent through a terminal. They need a chat interface that hides the plumbing.</p>
<p>OpenClaw 2.0 attempts to serve both constituencies simultaneously. Non-technical employees get a familiar conversational interface. Technical users retain access to the execution artifacts, diffs, tool call logs, and terminal activity underneath. Administrators get a centralized place to configure agents, memory, plugins, MCP servers, devices, and communication channels. Limited-access browser users can request administrator privileges rather than automatically receiving them, with another administrator required to approve the escalation.</p>
<h2>Multiplayer Sessions: Turning Agent Context into Shared Infrastructure</h2>
<p>The multiplayer session model is arguably the most architecturally significant change in 2.0. It introduces a concept that most agent platforms haven&#8217;t addressed: <strong>agent sessions as persistent, shareable, transferable workspaces.</strong></p>
<p>Here&#8217;s how it works in practice:</p>
<ol>
<li>A developer initiates a task and the agent begins working — writing code, running tests, browsing documentation.</li>
<li>The session accumulates context: conversation history, files, tool call results, Git state, agent decisions.</li>
<li>A second developer joins the same session. They see the full context. They can add information, redirect the agent, or take over the task.</li>
<li>The session carries immutable metadata: who created it, who owns it, which prompts came from which participant.</li>
<li>Sessions can move execution to paired devices or cloud workers while maintaining the workspace.</li>
</ol>
<p>Colin Johnson, CEO of marketing metrics firm Solvely, described this shift in a post on X. His team had already been using OpenClaw agents through Discord, where developers could assign tasks and interact with the agent. But the multiplayer WebUI changed the dynamic: &#8220;We were working inside the same context,&#8221; he wrote. In one instance, instead of preparing a traditional handoff document, he joined a colleague&#8217;s agent session and added the missing project context directly. &#8220;The session itself became the handoff document.&#8221;</p>
<p>For enterprise architects, this raises a question that matters beyond OpenClaw: <strong>should agent sessions become shared work artifacts?</strong> If agents accumulate context about projects, codebases, and business processes over time, that context has organizational value. Trapping it in individual user sessions is the agent equivalent of keeping all project knowledge in one developer&#8217;s head. Multiplayer sessions are an attempt to solve that problem.</p>
<h2>Security Model: Substantially Hardened, Not Secure by Default</h2>
<p>OpenClaw 2.0 introduces a significantly expanded security model, but architects need to understand a critical distinction: <strong>the new security controls are available, not enforced by default.</strong> The baseline configuration still assumes a trusted single operator and permits host execution unless administrators configure stronger restrictions.</p>
<h3>What&#8217;s New in Security</h3>
<p><strong>Session Permission Modes:</strong> Sessions can operate under four permission levels — read-only, guarded, workspace, and full-access — with the highest level restricted to administrators.</p>
<p><strong>Granular Approvals:</strong> Approvals are now tied to a specific request, command, session, and person. Reusable command permissions bind to exact arguments and a working directory. For script-backed execution, OpenClaw can verify that the script being executed still matches what was originally reviewed.</p>
<p><strong>Sandboxing:</strong> OpenClaw 2.0 supports Docker and Podman sandboxes with per-agent and per-session scope, configurable read-only or read-write workspace access, and role-enforced sandboxing. Organizations can define operator roles that require sandboxed execution — if the required sandbox cannot be provisioned, execution fails rather than silently falling back to the host.</p>
<p><strong>Credential Management:</strong> A team-scoped Secret Store distinguishes protected secrets from ordinary environment values. For supported requests, a protected credential can be substituted into a Gateway-hosted HTTPS request without exposing it directly to the model. OpenClaw can also reference external systems including 1Password and HashiCorp Vault.</p>
<p><strong>Audit Trail:</strong> Auditing has expanded around execution identity, approvals, session actions, and outbound messages. Plugin installation triggers capability reviews. Configuration changes are logged with sensitive-value redaction.</p>
<h3>The NanoClaw Comparison</h3>
<p>OpenClaw&#8217;s security story is best understood in contrast with NanoClaw, an open-source rival that emerged specifically around the thesis that AI agents need stronger isolation and simpler security boundaries.</p>
<table>
<thead>
<tr>
<th>Security Dimension</th>
<th>OpenClaw 2.0</th>
<th>NanoClaw</th>
</tr>
</thead>
<tbody>
<tr>
<td><strong>Default posture</strong></td>
<td>Trusted operator, host execution unless configured otherwise</td>
<td>Container-first isolation by default</td>
</tr>
<tr>
<td><strong>Sandboxing</strong></td>
<td>Docker/Podman (opt-in)</td>
<td>Docker containers as the fundamental execution boundary</td>
</tr>
<tr>
<td><strong>Credentials</strong></td>
<td>Secret Store with gateway-level substitution; Vault/1Password integration</td>
<td>Agent Vault with gateway-injected credentials, never in-container</td>
</tr>
<tr>
<td><strong>Multi-tenancy</strong></td>
<td>Single trust domain per Gateway; separate &#8220;cells&#8221; for isolation</td>
<td>Container-level isolation per session</td>
</tr>
<tr>
<td><strong>Network control</strong></td>
<td>Configurable</td>
<td>Optional egress-lockdown with Docker internal networking</td>
</tr>
</tbody>
</table>
<p>VentureBeat summarized the distinction precisely: &#8220;An enterprise can configure OpenClaw into a substantially hardened environment, but it has to make that decision deliberately.&#8221; This is the key takeaway for architects — OpenClaw 2.0 has security <em>parity</em> with NanoClaw in terms of available controls, but not in terms of defaults. If your organization&#8217;s security posture requires defense-in-depth by default rather than by configuration, that gap matters.</p>
<h3>The Trust Domain Boundary</h3>
<p>One limitation is particularly important for larger organizations: <strong>a single OpenClaw Gateway is a single trust domain.</strong> The multi-user permissions govern collaboration among trusted users — they do not provide hard isolation between mutually untrusted tenants. For separation between business units, customers, or compliance domains, OpenClaw recommends separate Gateway instances (&#8220;cells&#8221;) with separate state, credentials, and workspaces. Fleet tooling for managing those cells remains experimental.</p>
<h2>What This Means for RPA and Automation Teams</h2>
<p>If you&#8217;re reading this on rpabotsworld.com, you&#8217;re likely coming from an RPA or enterprise automation background. Here&#8217;s why OpenClaw 2.0 should be on your radar even if you&#8217;re primarily working with <a href="https://rpabotsworld.com/uipath-vs-automation-anywhere-vs-blue-prism-agentic-platforms-2026/">UiPath, Automation Anywhere, or Blue Prism</a>.</p>
<h3>The Convergence Point: RPA Platforms Are Adding Agents, Agent Platforms Are Adding Automation</h3>
<p>The enterprise automation market is converging from two directions. Traditional RPA vendors are adding agentic AI capabilities — <a href="https://rpabotsworld.com/uipath-autopilot-coding-agent-ga-guide-2/">UiPath&#8217;s Autopilot is now a coding agent</a>, Automation Anywhere has AI Agent Studio, Blue Prism integrates with LLMs. Meanwhile, open-source agent platforms like OpenClaw, n8n, and Activepieces are adding workflow automation capabilities that overlap with traditional RPA use cases.</p>
<p>OpenClaw 2.0 accelerates this convergence in three ways:</p>
<ol>
<li><strong>Automations + Scheduling (Heartbeat):</strong> OpenClaw can run recurring agent tasks without human prompting — the agent equivalent of a scheduled bot in Orchestrator or Control Room. The difference is that the &#8220;bot&#8221; is an LLM-powered agent that can reason about exceptions rather than failing on an unexpected screen layout.</li>
<li><strong>MCP + Skills Integration:</strong> The AgentSkills system and MCP plugin support give OpenClaw a modular integration layer comparable to RPA activity packages or connector libraries. An OpenClaw agent can interact with APIs, databases, browsers, and local applications through these extensions.</li>
<li><strong>Enterprise Governance:</strong> The new permission modes, audit trails, and credential management address the same governance concerns that enterprise RPA platforms solve with role-based access control, credential vaults, and execution logs.</li>
</ol>
<p>The critical difference remains: RPA platforms provide deterministic, repeatable execution with detailed logging and exception handling baked into the runtime. OpenClaw agents are probabilistic — they reason about tasks rather than following a script. For high-volume, high-compliance processes (invoice processing, claims adjudication, regulatory reporting), deterministic RPA still wins. For knowledge-worker tasks that require judgment, research, and multi-step reasoning, agent platforms like OpenClaw are increasingly competitive.</p>
<h2>How OpenClaw 2.0 Compares to Managed Agent Platforms</h2>
<p>The broader competitive landscape puts OpenClaw against both open-source alternatives and vendor-managed platforms:</p>
<table>
<thead>
<tr>
<th>Platform</th>
<th>Type</th>
<th>Model Lock-in</th>
<th>Self-Hosted</th>
<th>Multi-User</th>
<th>Key Strength</th>
</tr>
</thead>
<tbody>
<tr>
<td><strong>OpenClaw 2.0</strong></td>
<td>Open-source agent runtime</td>
<td>None (any LLM)</td>
<td>Yes</td>
<td>Yes (2.0)</td>
<td>Model-agnostic, channel-rich, extensible</td>
</tr>
<tr>
<td><strong>NanoClaw</strong></td>
<td>Open-source agent runtime</td>
<td>None</td>
<td>Yes</td>
<td>Limited</td>
<td>Container-first security, small attack surface</td>
</tr>
<tr>
<td><strong>ChatGPT Agent</strong></td>
<td>Managed platform</td>
<td>OpenAI only</td>
<td>No</td>
<td>Limited</td>
<td>Computer/browser use, deep OpenAI integration</td>
</tr>
<tr>
<td><strong>Claude (Anthropic)</strong></td>
<td>Managed platform</td>
<td>Anthropic only</td>
<td>No</td>
<td>Team plans</td>
<td>MCP ecosystem, coding agents, safety</td>
</tr>
<tr>
<td><strong>OpenHands</strong></td>
<td>Open-source coding agent</td>
<td>Any LLM</td>
<td>Yes</td>
<td>Yes (Canvas)</td>
<td>Autonomous coding, Docker sandbox</td>
</tr>
<tr>
<td><strong>n8n</strong></td>
<td>Open-source workflow</td>
<td>Any LLM</td>
<td>Yes</td>
<td>Yes</td>
<td>Visual workflow builder, business automation</td>
</tr>
</tbody>
</table>
<p>OpenClaw&#8217;s niche is the intersection of <strong>self-hosted + model-agnostic + persistent agent + messaging-channel integration</strong>. No other platform occupies exactly that space at OpenClaw&#8217;s scale. If your organization needs an agent that lives on your infrastructure, works with any LLM provider (or local models), remembers context across sessions, and is accessible through the messaging platforms your teams already use — OpenClaw is the leading open-source option.</p>
<h2>Deployment Considerations for Enterprise Architects</h2>
<h3>Infrastructure Requirements</h3>
<p>OpenClaw runs on any machine that can host the Gateway process. The 2.0 release simplified installation significantly — the setup process now auto-detects existing resources including ChatGPT or Claude subscriptions, API keys, and locally installed models. For enterprise deployment, you&#8217;ll want to plan for:</p>
<ul>
<li><strong>Gateway hosting:</strong> A server or VM with network access to your LLM provider(s) and messaging channels.</li>
<li><strong>Sandboxing infrastructure:</strong> Docker or Podman for agent execution isolation (strongly recommended for enterprise use).</li>
<li><strong>Credential management:</strong> Integration with your existing secrets manager (1Password, HashiCorp Vault) or use of OpenClaw&#8217;s built-in Secret Store.</li>
<li><strong>Multi-Gateway topology:</strong> Separate Gateway instances (&#8220;cells&#8221;) for each trust domain — engineering, finance, customer-facing — with independent state and credentials.</li>
</ul>
<h3>Security Configuration Checklist</h3>
<p>Because OpenClaw 2.0&#8217;s security controls are opt-in, architects deploying it in an enterprise context should configure these before granting user access:</p>
<ol>
<li>Enable sandboxed execution (Docker/Podman) as the default for all sessions.</li>
<li>Set session permission modes to &#8220;guarded&#8221; or &#8220;workspace&#8221; rather than &#8220;full-access.&#8221;</li>
<li>Configure the Secret Store with gateway-level credential substitution.</li>
<li>Enable execution audit logging.</li>
<li>Define operator roles that enforce sandboxing — preventing fallback to host execution.</li>
<li>Set up plugin trust review before installation.</li>
<li>Configure model allowlists to restrict which LLM providers agents can use.</li>
<li>Deploy separate Gateway cells for different trust domains.</li>
</ol>
<h3>Known Limitations</h3>
<p>Architects should be aware of these documented limitations before committing to a deployment:</p>
<ul>
<li><strong>Secret Store values are not encrypted at rest</strong> — they rely on filesystem protections. For environments requiring encryption at rest, integrate with Vault or 1Password.</li>
<li><strong>Protected credential substitution doesn&#8217;t cover every execution path</strong> — raw sockets, containers, remote nodes, and some provider-native harnesses may not be covered.</li>
<li><strong>Fleet management is experimental</strong> — managing multiple Gateway cells at scale requires custom tooling.</li>
<li><strong>Migration issues reported</strong> — some users experienced broken gateways, lost automations, or model authentication issues when upgrading from 1.x. Plan for a staged rollout.</li>
</ul>
<h2>The Bigger Picture: Open-Source Agents in the Enterprise Stack</h2>
<p>OpenClaw 2.0 is part of a broader wave of open-source agent tools reaching enterprise maturity in September 2026. In the same week as OpenClaw&#8217;s release, GitHub launched <a href="https://github.blog/ai-and-ml/github-copilot/project-hydrafusion-frontier-quality-via-multi-model-orchestration/" rel="nofollow noopener" target="_blank">Project HydraFusion</a> (multi-model orchestration in Copilot CLI), OpenHands shipped Canvas Apps in v1.16.0, and MagiCrew launched on Product Hunt as an open-source multi-agent productivity platform.</p>
<p>The common thread across these releases is a shift from proof-of-concept to production-ready deployment. The question is no longer &#8220;can AI agents do useful work?&#8221; but &#8220;how do we govern, secure, and scale them across an organization?&#8221; OpenClaw 2.0&#8217;s answer — multiplayer sessions, opt-in security hardening, and a browser-based control plane — represents one architectural approach. Whether it&#8217;s the right one for your organization depends on your existing infrastructure, security requirements, and how much operational responsibility you&#8217;re willing to take on for a self-hosted system.</p>
<p>Steinberger&#8217;s own framing is worth noting. Describing how the OpenClaw team built 2.0 using OpenClaw itself, he wrote: &#8220;Multiplayer coding + infinite compute with nodes and cloud sessions has been a game changer for how we build. Local harnesses feel like relics of the past now.&#8221; That&#8217;s a bold claim from the creator of what started as, essentially, a local harness. But if it holds — if persistent, shared, model-agnostic agent sessions become the default development environment — the implications extend well beyond OpenClaw.</p>
<p>For <a href="https://rpabotsworld.com/rpa-to-agentic-ai-transition-guide/">RPA teams transitioning to agentic AI</a>, OpenClaw 2.0 is worth evaluating not just as a tool, but as a signal of where the market is heading: <strong>from single-user bots to shared agent infrastructure, from vendor-locked platforms to model-agnostic runtimes, and from deterministic scripts to reasoning engines governed by enterprise-grade controls.</strong></p>
<h2>FAQs</h2>
<h3>Is OpenClaw 2.0 free to use?</h3>
<p>Yes. OpenClaw is open-source and free to self-host. You bring your own LLM provider (and pay that provider&#8217;s API costs), but the OpenClaw platform itself has no licensing fees. It is stewarded by the OpenClaw Foundation, an independent 501(c)(3).</p>
<h3>Can OpenClaw replace an RPA platform like UiPath or Automation Anywhere?</h3>
<p>Not directly. OpenClaw agents use LLM-powered reasoning, which is probabilistic rather than deterministic. For high-volume, compliance-heavy processes, traditional RPA&#8217;s repeatability and detailed audit trails are still essential. OpenClaw is better suited for knowledge-worker tasks, research, coding, and multi-step reasoning that require judgment. Many organizations will use both — RPA for structured automation, agent platforms for unstructured work.</p>
<h3>How does OpenClaw handle data privacy for enterprise deployments?</h3>
<p>OpenClaw is fully self-hosted — your data stays on your infrastructure. The agent runtime, conversation history, memory, and credentials all reside on servers you control. However, prompts and responses do flow to your chosen LLM provider, so your data privacy posture depends on your LLM provider agreement. Using local models (Llama, etc.) keeps everything on-premises.</p>
<h3>What LLMs does OpenClaw support?</h3>
<p>OpenClaw is model-agnostic. It supports hosted models (Claude, GPT, Gemini), API-based providers, and locally running models. The 2.0 setup process auto-detects existing API keys, subscriptions, and local models to simplify configuration.</p>
<h3>Is OpenClaw 2.0 production-ready for enterprise use?</h3>
<p>The capabilities are there, but enterprise readiness depends on configuration. Out of the box, OpenClaw 2.0 assumes a trusted single operator. Enterprises need to deliberately configure sandboxing, session permissions, credential management, and audit logging before deploying to teams. The VentureBeat assessment is accurate: &#8220;OpenClaw 2.0 doesn&#8217;t automatically make OpenClaw enterprise-ready, but it does make an enterprise-grade OpenClaw deployment far easier.&#8221;</p>
<h2>Key Takeaways</h2>
<ul>
<li><strong>OpenClaw 2.0 (v2026.8.1) is the largest release in the project&#8217;s history</strong> — 16,000+ PRs from 933 contributors, touching every major subsystem.</li>
<li><strong>The personal-to-enterprise pivot is real:</strong> multiplayer sessions, role-based permissions, audit trails, and a credential store transform OpenClaw from a developer tool into shared team infrastructure.</li>
<li><strong>Architecture: five components</strong> — Gateway (orchestration), Brain (ReAct reasoning), Skills (modular capabilities), Heartbeat (scheduling), Memory (persistent state) — all model-agnostic.</li>
<li><strong>Security is hardened but opt-in:</strong> Docker/Podman sandboxing, session permission modes, and credential management are available but not enabled by default. Enterprises must configure before deploying.</li>
<li><strong>One Gateway = one trust domain:</strong> multi-tenant isolation requires separate Gateway cells, and fleet tooling is still experimental.</li>
<li><strong>RPA convergence:</strong> OpenClaw&#8217;s automation capabilities increasingly overlap with traditional RPA use cases, but its probabilistic reasoning complements rather than replaces deterministic automation.</li>
<li><strong>Competitive positioning:</strong> OpenClaw occupies a unique niche — self-hosted + model-agnostic + persistent agent + messaging-channel integration — at a scale (250K+ stars) no other open-source agent project matches.</li>
</ul>
<h2>References</h2>
<ol>
<li>OpenClaw Foundation, &#8220;<a href="https://docs.openclaw.ai/releases/2026.8.1" rel="nofollow noopener" target="_blank">v2026.8.1 (AKA OpenClaw 2.0) Release Notes</a>,&#8221; August 30, 2026.</li>
<li>OpenClaw, &#8220;<a href="https://openclaw.ai/blog/openclaw-2-accidentally" rel="nofollow noopener" target="_blank">OpenClaw 2.0 — How We Accidentally Built It</a>,&#8221; Official Blog, August 30, 2026.</li>
<li>Carl Franzen, &#8220;<a href="https://venturebeat.com/technology/openclaw-2-0-is-here-what-it-means-for-enterprises" rel="nofollow noopener" target="_blank">OpenClaw 2.0 Is Here, Ushering In the Era of &#8216;Multiplayer&#8217; AI Coding: What It Means for Enterprises</a>,&#8221; VentureBeat, September 1, 2026.</li>
<li>Daniel Dominguez, &#8220;<a href="https://www.infoq.com/news/2026/09/openclaw-2-release/" rel="nofollow noopener" target="_blank">OpenClaw 2.0 Releases with Simplified Setup and Collaborative Agents</a>,&#8221; InfoQ, September 1, 2026.</li>
<li>&#8220;<a href="https://cybersecuritynews.com/openclaw-2-0-released/" rel="nofollow noopener" target="_blank">OpenClaw 2.0 Released With Major Security Upgrades for AI Agents, Plugins and Credentials</a>,&#8221; Cybersecurity News, September 2026.</li>
<li>&#8220;<a href="https://cellcog.ai/blog/openclaw-2-0/" rel="nofollow noopener" target="_blank">OpenClaw 2.0 Is Here: What&#8217;s New, What Breaks, and What It Signals</a>,&#8221; CellCog, September 2026.</li>
<li>&#8220;<a href="https://decrypt.co/377135/openclaw-2-0-is-here-whats-new" rel="nofollow noopener" target="_blank">OpenClaw 2.0 Is Here: What Changed, Why It Took Two Months, and How It Stacks Up Against Hermes</a>,&#8221; Decrypt, September 2026.</li>
<li>&#8220;<a href="https://www.marktechpost.com/2026/09/05/github-introduces-project-hydrafusion-runtime-multi-model-orchestration-that-builds-a-workflow-per-coding-task-in-copilot-cli/" rel="nofollow noopener" target="_blank">GitHub Introduces Project HydraFusion: Runtime Multi-Model Orchestration</a>,&#8221; MarkTechPost, September 5, 2026.</li>
<li>&#8220;<a href="https://en.wikipedia.org/wiki/OpenClaw" rel="nofollow noopener" target="_blank">OpenClaw</a>,&#8221; Wikipedia, accessed September 8, 2026.</li>
<li>&#8220;<a href="https://www.freecodecamp.org/news/how-to-build-and-secure-a-personal-ai-agent-with-openclaw/" rel="nofollow noopener" target="_blank">How to Build and Secure a Personal AI Agent with OpenClaw</a>,&#8221; freeCodeCamp, 2026.</li>
</ol>
]]></content:encoded>
					
					<wfw:commentRss>https://rpabotsworld.com/openclaw-2-open-source-agent-platform-enterprise-guide/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>browser-use: The Open-Source AI Browser Agent That’s Making RPA Scripts Obsolete (2026 Deep Dive)</title>
		<link>https://rpabotsworld.com/browser-use-open-source-ai-browser-agent-rpa-guide/</link>
					<comments>https://rpabotsworld.com/browser-use-open-source-ai-browser-agent-rpa-guide/#comments</comments>
		
		<dc:creator><![CDATA[Satish Prasad]]></dc:creator>
		<pubDate>Mon, 26 Oct 2026 05:10:38 +0000</pubDate>
				<category><![CDATA[AI Agents & Frameworks]]></category>
		<category><![CDATA[RPA & Bot Automation]]></category>
		<category><![CDATA[Open-Source Agents]]></category>
		<guid isPermaLink="false">https://rpabotsworld.com/?p=32368</guid>

					<description><![CDATA[browser-use has 108K GitHub stars, $17M in funding, and 89.1% benchmark accuracy.]]></description>
										<content:encoded><![CDATA[<h1>browser-use: The Open-Source AI Browser Agent That&#8217;s Making RPA Scripts Obsolete (2026 Deep Dive)</h1>
<p>A UiPath developer spends three weeks building a bot that logs into a procurement portal, navigates six screens, extracts line-item data from a table that changes column order every quarter, and dumps it into SAP. The bot breaks the first time the portal vendor updates their CSS. The developer rebuilds the selectors. The portal updates again. The cycle repeats.</p>
<p>Meanwhile, a Python developer writes eleven lines of code with <strong>browser-use</strong>, hands the same task to GPT-4o, and watches it complete the workflow on the first try — adapting in real time when the portal layout shifts. No selectors. No element IDs. No maintenance backlog.</p>
<p>This isn&#8217;t a hypothetical. It&#8217;s the core value proposition behind browser-use, the open-source Python library that has exploded to <strong>108,000+ GitHub stars</strong>, raised a <strong>$17 million seed round</strong> led by Felicis Ventures (with Y Combinator and Paul Graham participating), and currently leads the <a href="https://www.firecrawl.dev/blog/best-browser-agents" target="_blank" rel="noopener nofollow">WebVoyager benchmark at 89.1% accuracy</a> — the highest of any open-source browser agent framework.</p>
<p>For RPA professionals, this isn&#8217;t just another AI tool. It&#8217;s the architectural pattern that explains where browser automation is headed — and why teams that understand it will build the next generation of enterprise automation, while teams that ignore it will spend the next two years maintaining brittle selector-based bots.</p>
<p>This guide goes deep. We&#8217;ll cover the architecture, the perceive-act loop, how browser-use compares to traditional RPA and competing AI browser agents, when to use it (and when not to), production deployment patterns, and what this means for your career as an automation professional in 2026.</p>
<h2>What Is browser-use?</h2>
<p>browser-use is an <strong>open-source Python library</strong> (with a TypeScript SDK also available) that converts any large language model into an autonomous browser agent. Instead of writing imperative scripts with hardcoded selectors — the way Selenium, Playwright, and RPA platforms work — you give browser-use a natural language task (&#8220;Go to LinkedIn, search for AI Engineer jobs in Bangalore, and extract the first 20 results into a CSV&#8221;), and the LLM figures out how to accomplish it by perceiving and interacting with the live webpage.</p>
<p>The project was founded by <strong>Gregor Zunic</strong> and <strong>Magnus Muller</strong> (CEO), and grew from a side project to the most-starred AI browser agent on GitHub in under 18 months. The <a href="https://browser-use.com/posts/seed-round" target="_blank" rel="noopener nofollow">$17M seed round</a> in March 2025 was led by Felicis Ventures, with participation from Y Combinator, Paul Graham, Nexus Ventures, SV Angel, Pioneer Fund, Liquid2, and A Capital.</p>
<h3>Key Stats at a Glance</h3>
<table>
<thead>
<tr>
<th>Metric</th>
<th>Value</th>
</tr>
</thead>
<tbody>
<tr>
<td>GitHub Stars</td>
<td>108,000+ (August 2026)</td>
</tr>
<tr>
<td>Funding</td>
<td>$17M seed (Felicis, YC, Paul Graham)</td>
</tr>
<tr>
<td>WebVoyager Benchmark</td>
<td>89.1% (highest among open-source agents)</td>
</tr>
<tr>
<td>Odysseys Leaderboard</td>
<td>87.4% across 200 long-horizon tasks</td>
</tr>
<tr>
<td>Language</td>
<td>Python 3.11+, TypeScript SDK</td>
</tr>
<tr>
<td>Browser Engine</td>
<td>Playwright (Chromium, Firefox, WebKit)</td>
</tr>
<tr>
<td>LLM Support</td>
<td>Claude, GPT-4o/Astra, Gemini, local models</td>
</tr>
<tr>
<td>License</td>
<td>MIT</td>
</tr>
</tbody>
</table>
<h2>The Architecture: How browser-use Actually Works</h2>
<p>Understanding browser-use requires understanding one core concept: the <strong>DOM-first perceive-act loop</strong>. This is the pattern that separates AI browser agents from traditional automation, and it&#8217;s the reason they can handle dynamic web pages that break every RPA bot.</p>
<h3>The Perceive-Act Loop</h3>
<p>Every browser-use task follows a cyclical process:</p>
<p><strong>Step 1 — Perceive:</strong> browser-use captures two representations of the current page simultaneously. First, it extracts the <strong>DOM accessibility tree</strong> — a structured text representation of every interactive element on the page (buttons, links, input fields, text content) with semantic labels. Second, it optionally takes a <strong>screenshot</strong> for visual grounding. Both are sent to the LLM.</p>
<p><strong>Step 2 — Reason:</strong> The LLM analyzes the DOM text and (when enabled) the screenshot against the task objective. It decides what action to take next: click a button, type into a field, scroll down, extract data, or declare the task complete.</p>
<p><strong>Step 3 — Act:</strong> browser-use translates the LLM&#8217;s decision into a Playwright command and executes it in the real browser. The action registry maps LLM decisions to concrete operations — <code>click</code>, <code>type</code>, <code>scroll</code>, <code>go_to_url</code>, <code>extract_data</code>, <code>switch_tab</code>, and more.</p>
<p><strong>Step 4 — Loop:</strong> After execution, the system captures the new page state (DOM + optional screenshot) and sends it back to the LLM for the next decision. This loop continues until the task is complete or a maximum step count is reached.</p>
<h3>Core Components</h3>
<p>Under the hood, the architecture breaks into four services, each in its own module:</p>
<p><strong>Agent</strong> (<code>browser_use/agent/service.py</code>): The main orchestrator. It accepts a task string, initializes a browser session, and runs the perceive-act loop until completion. It manages conversation history, handles retries on failure, and enforces step limits.</p>
<p><strong>BrowserSession</strong> (<code>browser_use/browser/session.py</code>): Manages the browser lifecycle through Playwright — launching browsers (headless or headed), handling CDP (Chrome DevTools Protocol) connections, managing tabs, and coordinating multiple watchdog services through an event bus.</p>
<p><strong>DomService</strong> (<code>browser_use/dom/service.py</code>): The perception engine. It extracts the DOM content, generates the accessibility tree, handles element highlighting, and applies paint-order filtering to remove elements hidden behind others — a critical optimization that prevents the LLM from seeing (and being confused by) invisible overlays and hidden modals.</p>
<p><strong>Tools</strong> (<code>browser_use/tools/service.py</code>): The action registry that maps LLM outputs to executable Playwright operations. Each tool is a function the LLM can call — <code>click_element</code>, <code>input_text</code>, <code>scroll_down</code>, <code>go_back</code>, <code>open_tab</code>, etc.</p>
<h3>The Vision Strategy: When Screenshots Matter</h3>
<p>browser-use is <strong>DOM-first by design</strong> — the accessibility tree text representation is always the primary signal. But some pages have elements that lack text labels: icon-only buttons, image-based menus, CAPTCHAs (which browser-use doesn&#8217;t solve, by design). For these cases, browser-use implements an <strong>adaptive vision strategy</strong> with three levels:</p>
<p><strong>SKIP</strong> — DOM text is sufficient; no screenshot needed. This is the default for most well-structured pages and saves significant token cost.</p>
<p><strong>LIGHTWEIGHT</strong> — DOM text is ambiguous (e.g., unlabeled buttons, missing alt attributes). browser-use adds OCR-only visual analysis to supplement the text.</p>
<p><strong>FULL</strong> — DOM text is insufficient. Full OCR plus region detection kicks in, using Set-of-Mark (SoM) annotations to ground visual elements to clickable coordinates.</p>
<p>This adaptive approach is important for cost management. Sending a screenshot to the LLM on every step can cost 2-3x more in tokens than text-only DOM extraction. By defaulting to text and escalating to vision only when needed, browser-use keeps per-task costs manageable at scale.</p>
<h2>browser-use vs. Traditional RPA: The Paradigm Shift</h2>
<p>The comparison between browser-use and traditional RPA platforms (UiPath, Automation Anywhere, Blue Prism) isn&#8217;t about which tool is &#8220;better&#8221; — it&#8217;s about two fundamentally different approaches to the same problem. Understanding the trade-offs is essential for any automation architect planning a 2026-2027 automation strategy.</p>
<table>
<thead>
<tr>
<th>Dimension</th>
<th>Traditional RPA (UiPath, AA, Blue Prism)</th>
<th>browser-use (AI Browser Agent)</th>
</tr>
</thead>
<tbody>
<tr>
<td><strong>Element Targeting</strong></td>
<td>CSS selectors, XPath, UI descriptors, anchor-based selectors</td>
<td>LLM interprets DOM accessibility tree + optional vision</td>
</tr>
<tr>
<td><strong>Brittleness</strong></td>
<td>Breaks when UI changes selectors, class names, or layout</td>
<td>Adapts to layout changes by re-perceiving the page each step</td>
</tr>
<tr>
<td><strong>Development Speed</strong></td>
<td>Days to weeks per workflow (record → refine → test)</td>
<td>Minutes for simple tasks; hours for complex with prompt tuning</td>
</tr>
<tr>
<td><strong>Maintenance Cost</strong></td>
<td>High — selector updates, exception handling, re-testing</td>
<td>Low for UI changes; shifts to prompt and LLM cost management</td>
</tr>
<tr>
<td><strong>Determinism</strong></td>
<td>100% deterministic — same input, same output, every time</td>
<td>Probabilistic — LLM may choose different paths across runs</td>
</tr>
<tr>
<td><strong>Speed (per task)</strong></td>
<td>Fast — direct API calls to browser engine, no LLM latency</td>
<td>Slower — each step requires an LLM inference call (1-5 seconds)</td>
</tr>
<tr>
<td><strong>Cost per Execution</strong></td>
<td>Infrastructure only (VM, license); near-zero marginal cost</td>
<td>LLM token cost per step ($0.01-0.50+ per task depending on complexity)</td>
</tr>
<tr>
<td><strong>Governance &amp; Audit</strong></td>
<td>Mature — full audit trails, role-based access, SOC2-ready</td>
<td>Emerging — requires custom logging; no built-in governance framework</td>
</tr>
<tr>
<td><strong>Error Handling</strong></td>
<td>Explicit try/catch with defined recovery paths</td>
<td>LLM-driven self-correction; unpredictable on edge cases</td>
</tr>
<tr>
<td><strong>Enterprise Readiness</strong></td>
<td>Production-proven, vendor SLAs, compliance certifications</td>
<td>Early-stage; cloud offering launched 2025, enterprise tier in progress</td>
</tr>
</tbody>
</table>
<h3>When browser-use Wins</h3>
<p><strong>High-churn UIs:</strong> If the target application updates its interface frequently (SaaS platforms, third-party portals, government sites with unpredictable redesigns), browser-use&#8217;s ability to re-perceive and adapt on every step eliminates the #1 cause of RPA bot failure — selector breakage.</p>
<p><strong>Long-tail processes:</strong> Organizations typically have hundreds of low-frequency browser tasks that don&#8217;t justify the cost of building and maintaining a full RPA bot. A browser-use agent can handle these with a natural language prompt and no dedicated development time.</p>
<p><strong>Rapid prototyping:</strong> When you need a working browser automation in hours, not weeks — for a proof of concept, a one-off data extraction, or a time-sensitive migration — browser-use&#8217;s prompt-based approach eliminates the development cycle entirely.</p>
<h3>When Traditional RPA Still Wins</h3>
<p><strong>Deterministic compliance requirements:</strong> Financial services, healthcare, and regulated industries often require that automation produce identical outputs given identical inputs. The probabilistic nature of LLM-driven agents — where the model might click a slightly different path each run — is a non-starter for audit-critical processes.</p>
<p><strong>High-volume, stable processes:</strong> If you&#8217;re processing 50,000 invoices per day through an internal ERP that changes twice a year, the per-execution cost of an LLM call on every step makes browser-use uneconomical. Traditional RPA runs at near-zero marginal cost after development.</p>
<p><strong>Desktop application automation:</strong> browser-use is browser-only. It doesn&#8217;t interact with desktop apps (SAP GUI, Citrix, legacy Java applications). <a href="https://rpabotsworld.com/uipath-vs-automation-anywhere-vs-blue-prism-agentic-platforms-2026/" target="_blank">UiPath, Automation Anywhere, and Blue Prism</a> still dominate here and are investing heavily in agentic capabilities for desktop environments.</p>
<h2>browser-use vs. Competing AI Browser Agents</h2>
<p>browser-use isn&#8217;t the only player in the AI browser agent space. Three competitors deserve serious consideration, each with a different architectural philosophy.</p>
<table>
<thead>
<tr>
<th>Framework</th>
<th>Architecture</th>
<th>Language</th>
<th>WebVoyager Score</th>
<th>Best For</th>
</tr>
</thead>
<tbody>
<tr>
<td><strong>browser-use</strong></td>
<td>DOM-first perceive-act loop</td>
<td>Python / TypeScript</td>
<td>89.1%</td>
<td>Variable tasks where the model must interpret the page during the run</td>
</tr>
<tr>
<td><strong>Stagehand</strong> (Browserbase)</td>
<td>Code-first SDK with AI primitives (<code>act</code>, <code>extract</code>, <code>observe</code>)</td>
<td>TypeScript</td>
<td>~86%</td>
<td>TypeScript teams that want Playwright-level control with AI fallbacks</td>
</tr>
<tr>
<td><strong>Skyvern</strong></td>
<td>Computer vision + LLM reasoning</td>
<td>Python</td>
<td>85.85%</td>
<td>Complex multi-step enterprise workflows, especially form-filling</td>
</tr>
<tr>
<td><strong>AgentQL</strong></td>
<td>Semantic query layer</td>
<td>Python / TypeScript</td>
<td>Mid-tier</td>
<td>Structured data extraction from known page types</td>
</tr>
</tbody>
</table>
<p><strong>Stagehand</strong> takes a fundamentally different approach: instead of giving the LLM full autonomy, it provides three AI-powered primitives (<code>act</code>, <code>extract</code>, <code>observe</code>) that developers compose into deterministic Playwright scripts. You write the workflow logic; AI handles the element-finding. This makes it the natural pick for engineering teams that want AI assistance without giving up control — particularly TypeScript shops already using Playwright.</p>
<p><strong>Skyvern</strong> leads with computer vision rather than DOM extraction. Its strength is form-filling tasks where layout variations are extreme — insurance quote portals, government benefit applications, multi-step procurement forms. For these specific use cases, Skyvern&#8217;s vision-first approach handles layout shifts better than DOM-first tools.</p>
<p><strong>browser-use</strong> wins on generality. Its DOM-first approach with adaptive vision escalation covers the widest range of web tasks with the best overall accuracy. The Python-first ecosystem, 108K-star community, and MIT license make it the default starting point for most teams evaluating AI browser agents in 2026.</p>
<h2>Getting Started: A Practical Walkthrough</h2>
<p>Here&#8217;s what a minimal browser-use implementation looks like, from installation to running your first agent task.</p>
<h3>Installation</h3>
<pre><code># Create a virtual environment
python3 -m venv browser-agent-env
source browser-agent-env/bin/activate

# Install browser-use and dependencies
pip install browser-use python-dotenv

# Install Playwright browsers
playwright install chromium</code></pre>
<h3>Environment Setup</h3>
<pre><code># .env file
OPENAI_API_KEY=sk-your-key-here
# Or use Anthropic:
# ANTHROPIC_API_KEY=sk-ant-your-key-here</code></pre>
<h3>Your First Agent Task</h3>
<pre><code>import asyncio
from dotenv import load_dotenv
from browser_use import Agent
from langchain_openai import ChatOpenAI

load_dotenv()

async def main():
    agent = Agent(
        task="Go to rpabotsworld.com, find the latest article about UiPath, and extract the title and publication date.",
        llm=ChatOpenAI(model="gpt-4o"),
    )
    result = await agent.run()
    print(result)

asyncio.run(main())</code></pre>
<p>That&#8217;s eleven lines of functional code. The agent launches a Chromium browser, navigates to the site, locates the relevant article by reading the page&#8217;s DOM, extracts the requested data, and returns it as structured output.</p>
<h3>Adding Persistence and Multi-Step Workflows</h3>
<p>For production scenarios, you&#8217;ll want persistent browser sessions (so the agent can maintain login state across tasks), custom action registries, and structured output schemas:</p>
<pre><code>from browser_use import Agent, BrowserSession
from pydantic import BaseModel

class ExtractedData(BaseModel):
    title: str
    date: str
    author: str
    summary: str

async def production_workflow():
    # Persistent session — browser stays open across tasks
    session = BrowserSession(
        headless=True,
        keep_alive=True,
    )

    agent = Agent(
        task="""
        1. Go to the procurement portal at portal.example.com
        2. Log in with the credentials in the environment
        3. Navigate to 'Recent Orders'
        4. Extract all orders from the last 7 days
        5. For each order, capture: order ID, vendor, amount, status
        """,
        llm=ChatOpenAI(model="gpt-4o"),
        browser_session=session,
        max_steps=50,  # Safety limit
    )
    result = await agent.run()
    await session.close()
    return result</code></pre>
<h2>Production Deployment: What Enterprise Teams Need to Know</h2>
<p>Running browser-use in a demo is easy. Running it in production — reliably, at scale, with cost controls and governance — is a different problem. Here are the patterns that matter.</p>
<h3>Cost Management</h3>
<p>Every step in the perceive-act loop requires an LLM inference call. For a 15-step task using GPT-4o, expect roughly $0.10-0.30 in token costs per execution. At 1,000 executions per day, that&#8217;s $100-300/day in LLM costs alone — before infrastructure.</p>
<p>Cost reduction strategies:</p>
<p><strong>Use the cheapest model that works.</strong> For simple, well-structured pages, GPT-4o-mini or Claude 3.5 Haiku may be sufficient at 1/10th the cost. Reserve GPT-4o or Claude Sonnet for complex, dynamic pages.</p>
<p><strong>Disable vision by default.</strong> DOM-only mode uses dramatically fewer tokens. Enable adaptive vision only for tasks where you&#8217;ve confirmed DOM-only fails.</p>
<p><strong>Set aggressive step limits.</strong> A runaway agent burning through 100 LLM calls is an expensive failure mode. Set <code>max_steps</code> to the expected task length plus a 30% buffer.</p>
<p><strong>Cache DOM extractions.</strong> If your agent runs the same task repeatedly on pages that change slowly, cache the DOM snapshot and send it to the LLM only when it changes.</p>
<h3>Reliability and Error Handling</h3>
<p>LLM-driven agents are probabilistic. On the same task, an agent might succeed 89 times out of 100 — but fail 11 times in ways that are hard to predict. Production patterns to manage this:</p>
<p><strong>Retry with escalation:</strong> If a task fails with one model, retry with a more capable (and more expensive) model. Chain GPT-4o-mini → GPT-4o → Claude Sonnet as escalation tiers.</p>
<p><strong>Structured output validation:</strong> Use Pydantic models (as shown above) to validate agent output against an expected schema. If the output doesn&#8217;t match, the task failed — even if the agent thinks it succeeded.</p>
<p><strong>Human-in-the-loop checkpoints:</strong> For high-stakes workflows (financial data extraction, contract processing), add approval gates where a human reviews the agent&#8217;s intermediate output before proceeding.</p>
<p><strong>Deterministic fallbacks:</strong> For critical steps (login, final data submission), use traditional Playwright selectors as a fallback. browser-use supports custom actions — you can register a <code>deterministic_login</code> function that the agent calls by name instead of trying to figure out the login form via LLM.</p>
<h3>browser-use Cloud</h3>
<p>For teams that don&#8217;t want to manage browser infrastructure, <a href="https://browser-use.com/changelog/3-4-2026" target="_blank" rel="noopener nofollow">browser-use Cloud</a> offers hosted browser sessions with managed scaling:</p>
<table>
<thead>
<tr>
<th>Plan</th>
<th>Price</th>
<th>Includes</th>
</tr>
</thead>
<tbody>
<tr>
<td>Pay-As-You-Go</td>
<td>$0.06/hour per session + $10/GB proxy</td>
<td>3 concurrent sessions, no commitment</td>
</tr>
<tr>
<td>Business</td>
<td>$400/month (annual)</td>
<td>250 sessions, $5/GB proxy, priority support</td>
</tr>
<tr>
<td>Scaleup</td>
<td>From $2,000/month</td>
<td>Higher concurrency, dedicated infrastructure</td>
</tr>
<tr>
<td>Enterprise</td>
<td>Custom</td>
<td>Annual credit pool, SLAs, data retention terms</td>
</tr>
</tbody>
</table>
<p>The hosted V3 agent bills tokens at 1.2x provider rates, or you can bring your own API key and pay a 0.2x orchestration fee — making it cost-effective for teams that already have volume LLM contracts.</p>
<h2>The MCP Connection: browser-use in the Agentic Ecosystem</h2>
<p>browser-use doesn&#8217;t exist in isolation. It&#8217;s increasingly part of the broader <strong>Model Context Protocol (MCP)</strong> ecosystem — the open standard (now governed by the <a href="https://rpabotsworld.com/a2a-joins-mcp-aaif-agentic-ai-architects-guide/" target="_blank">Agentic AI Foundation</a>) that defines how AI agents connect to tools, data sources, and each other.</p>
<p>browser-use can function as an <strong>MCP server</strong>, exposing its browser automation capabilities as callable tools to any MCP-compatible agent. This means a LangGraph orchestration agent, a <a href="https://rpabotsworld.com/pydantic-ai-v2-capabilities-composable-agents-guide/" target="_blank">Pydantic AI composable agent</a>, or a <a href="https://rpabotsworld.com/microsoft-agent-framework-1-0-foundry-agentic-ai-architect-guide/" target="_blank">Microsoft Agent Framework</a> agent can invoke browser-use as a tool — &#8220;go to this URL and extract this data&#8221; — without knowing anything about how browser automation works under the hood.</p>
<p>This is architecturally significant for enterprise automation teams. It means browser-use becomes a <strong>capability layer</strong> in a larger agentic system, not a standalone tool. Your orchestration agent handles business logic and decision-making; browser-use handles the browser interaction; other MCP servers handle database queries, API calls, and email. Each component is independently deployable, testable, and replaceable.</p>
<h2>What This Means for RPA Professionals</h2>
<p>If you&#8217;re an RPA developer, solution architect, or automation consultant reading this, the natural question is: &#8220;Does this replace my job?&#8221;</p>
<p>The honest answer is nuanced.</p>
<p><strong>What&#8217;s going away:</strong> The value of knowing how to build a selector-based browser bot is declining. Tools like browser-use can accomplish the same browser automation task with dramatically less development time and zero maintenance. If your entire skill set is &#8220;I can record a UiPath sequence and fix broken selectors,&#8221; the next two years will be uncomfortable.</p>
<p><strong>What&#8217;s emerging:</strong> The demand for people who can <em>architect</em> automation systems — deciding which tasks get AI browser agents vs. traditional RPA vs. API integrations vs. human-in-the-loop workflows — is growing faster than the talent pool. The McKinsey &#8220;State of AI in 2026&#8221; survey found that large enterprises scaling AI agents in one or more functions rose from 27% to 40% year-over-year. Someone has to design, deploy, govern, and optimize these systems.</p>
<p><strong>The career play:</strong> Learn browser-use (and its competitors). Learn how to integrate it into MCP-based multi-agent architectures. Learn how to evaluate when AI browser agents are the right choice vs. when traditional RPA or direct API integration is better. The <a href="https://rpabotsworld.com/rpa-to-agentic-ai-transition-guide/" target="_blank">RPA-to-agentic-AI transition</a> isn&#8217;t about choosing one over the other — it&#8217;s about knowing which tool fits which problem, and building the governance framework to run both safely in production.</p>
<h2>FAQs</h2>
<h3>Is browser-use free to use?</h3>
<p>Yes. The core library is MIT-licensed and fully open source. You can self-host it at no cost beyond your own infrastructure and LLM API fees. browser-use Cloud is a paid hosted service for teams that want managed infrastructure, starting with a pay-as-you-go tier at $0.06/hour per session.</p>
<h3>Can browser-use replace UiPath or Automation Anywhere?</h3>
<p>For browser-only automation tasks — especially those involving dynamic, frequently-changing web UIs — browser-use can replace traditional RPA bots with less development time and lower maintenance cost. However, it cannot automate desktop applications, doesn&#8217;t offer built-in enterprise governance (audit trails, role-based access, SOC2 compliance), and its probabilistic nature makes it unsuitable for deterministic compliance-critical workflows. The realistic answer: it replaces some RPA bots, complements others, and creates entirely new automation possibilities that weren&#8217;t feasible with selector-based tools.</p>
<h3>Which LLM works best with browser-use?</h3>
<p>GPT-4o and Claude Sonnet deliver the best accuracy on complex tasks. For simpler, well-structured pages, GPT-4o-mini or Claude Haiku offer 80-90% of the accuracy at a fraction of the cost. OpenAI&#8217;s new GPT-6 Astra (released September 3, 2026) includes state-of-the-art computer use capabilities and is expected to push browser agent accuracy even higher.</p>
<h3>How does browser-use handle authentication and login?</h3>
<p>browser-use supports persistent browser sessions that maintain cookies and login state across tasks. For initial login, you can either let the LLM agent handle it (it can read login forms and type credentials) or register a deterministic custom action for the login step — recommended for security-sensitive environments to avoid passing credentials through the LLM.</p>
<h3>What&#8217;s the latency compared to traditional RPA?</h3>
<p>Each step in the perceive-act loop takes 1-5 seconds (dominated by LLM inference time). A 15-step task takes 20-75 seconds. Traditional RPA completes the same task in 5-15 seconds because it executes direct Playwright/Selenium commands without LLM overhead. For batch processing of thousands of identical items, traditional RPA is faster and cheaper. For variable, adaptive tasks, the latency trade-off is worthwhile.</p>
<h2>Key Takeaways</h2>
<ul>
<li><strong>browser-use is the leading open-source AI browser agent</strong> — 108K GitHub stars, $17M funding (Felicis/YC), 89.1% WebVoyager benchmark accuracy, MIT license.</li>
<li><strong>The DOM-first perceive-act loop</strong> is the core architectural innovation: the LLM reads the page&#8217;s accessibility tree, decides what to do, executes via Playwright, and repeats — adapting to any UI layout without hardcoded selectors.</li>
<li><strong>It doesn&#8217;t replace all RPA</strong> — desktop automation, deterministic compliance workflows, and high-volume stable processes still favor traditional platforms. But for browser automation on dynamic UIs, long-tail processes, and rapid prototyping, it&#8217;s a generational improvement.</li>
<li><strong>Production deployment requires cost management</strong> — model tier selection, vision mode control, step limits, and deterministic fallbacks are essential for running browser-use at enterprise scale.</li>
<li><strong>MCP integration</strong> positions browser-use as a capability layer in multi-agent architectures, not a standalone tool — this is the pattern enterprise automation is converging on.</li>
<li><strong>For RPA professionals</strong>, learning AI browser agent architecture is not optional — it&#8217;s the skill that distinguishes automation architects from bot builders in 2026-2027.</li>
</ul>
<h2>References</h2>
<ol>
<li>browser-use GitHub Repository — <a href="https://github.com/browser-use/browser-use" target="_blank" rel="noopener nofollow">github.com/browser-use/browser-use</a></li>
<li>browser-use Official Documentation — <a href="https://docs.browser-use.com/open-source/quickstart" target="_blank" rel="noopener nofollow">docs.browser-use.com</a></li>
<li>browser-use Seed Round Announcement — <a href="https://browser-use.com/posts/seed-round" target="_blank" rel="noopener nofollow">browser-use.com/posts/seed-round</a></li>
<li>Production Architecture for browser-use — <a href="https://browser-use.com/posts/production-architecture-browser-use" target="_blank" rel="noopener nofollow">browser-use.com/posts/production-architecture-browser-use</a></li>
<li>&#8220;11 Best AI Browser Agents in 2026&#8221; — <a href="https://www.firecrawl.dev/blog/best-browser-agents" target="_blank" rel="noopener nofollow">Firecrawl Blog</a></li>
<li>Browser Agent Framework Comparison — <a href="https://bytetunnels.com/posts/browser-agent-frameworks-compared-browser-use-vs-stagehand-vs-skyvern/" target="_blank" rel="noopener nofollow">ByteTunnels</a></li>
<li>&#8220;9 Browser Use Alternatives Compared for 2026&#8221; — <a href="https://www.skyvern.com/blog/browser-use-alternatives/" target="_blank" rel="noopener nofollow">Skyvern Blog</a></li>
<li>&#8220;Browser Use secures $17M in seed funding&#8221; — <a href="https://dataphoenix.info/browser-use-secures-17m-in-seed-funding-to-help-ai-agents-navigate-the-web/" target="_blank" rel="noopener nofollow">DataPhoenix</a></li>
<li>browser-use Cloud Pricing — <a href="https://browser-use.com/changelog/3-4-2026" target="_blank" rel="noopener nofollow">browser-use.com/changelog</a></li>
<li>McKinsey &#8220;State of AI in 2026&#8221; Survey — Referenced via AI Agent News, September 2026</li>
<li>WebVoyager and Odysseys Benchmark Results — <a href="https://www.firecrawl.dev/blog/best-browser-agents" target="_blank" rel="noopener nofollow">Firecrawl Benchmark Analysis</a></li>
</ol>
]]></content:encoded>
					
					<wfw:commentRss>https://rpabotsworld.com/browser-use-open-source-ai-browser-agent-rpa-guide/feed/</wfw:commentRss>
			<slash:comments>1</slash:comments>
		
		
			</item>
		<item>
		<title>CUA: The Open-Source Computer-Use Agent Infrastructure That&#8217;s Replacing RPA Scripts — Complete Guide for Agentic AI Architects (2026)</title>
		<link>https://rpabotsworld.com/cua-open-source-computer-use-agent-infrastructure-guide/</link>
					<comments>https://rpabotsworld.com/cua-open-source-computer-use-agent-infrastructure-guide/#respond</comments>
		
		<dc:creator><![CDATA[Satish Prasad]]></dc:creator>
		<pubDate>Thu, 22 Oct 2026 02:22:50 +0000</pubDate>
				<category><![CDATA[Agentic AI & AI Automation]]></category>
		<category><![CDATA[AI Agents & Frameworks]]></category>
		<category><![CDATA[Open-Source Agents]]></category>
		<guid isPermaLink="false">https://rpabotsworld.com/?p=32440</guid>

					<description><![CDATA[CUA gives AI agents full desktops across macOS, Linux, and Windows. Architecture breakdown, RPA comparison, enterprise evaluation, and decision framework…]]></description>
										<content:encoded><![CDATA[
<p class="wp-block-paragraph">A UiPath bot breaks because someone moved a button three pixels to the left. A Blue Prism workflow fails because the target app pushed a minor UI update over the weekend. A Power Automate desktop flow stalls on a new consent dialog that didn&#8217;t exist when the flow was recorded.</p>



<p class="wp-block-paragraph">If you&#8217;ve spent any time in enterprise RPA, you&#8217;ve lived this loop: build, deploy, babysit, rebuild. The fundamental problem isn&#8217;t the tools — it&#8217;s the paradigm. Traditional RPA records fixed coordinates, fixed element selectors, and fixed sequences. The moment the UI changes, the script shatters.</p>



<p class="wp-block-paragraph">Computer-use agents (CUAs) take a different approach entirely. Instead of following a recorded script, an AI agent <em>looks</em> at the screen, <em>reasons</em> about what it sees, and <em>decides</em> what to click, type, or scroll — the same way a human operator would. And the open-source project leading this infrastructure shift is <strong>CUA</strong> (trycua/cua): a MIT-licensed platform that gives AI agents full desktop environments across macOS, Linux, Windows, and Android, complete with sandboxing, benchmarking, and an MCP-native SDK.</p>



<p class="wp-block-paragraph">With roughly 29,000 GitHub stars, backing from Y Combinator (X25 batch), and a release cadence that ships multiple updates per week, CUA has become the default substrate for teams building production computer-use agents in 2026. This guide breaks down what it is, how it works, why it matters for RPA and automation teams, and how to evaluate it against the proprietary alternatives from Anthropic, OpenAI, Google, and the traditional RPA vendors.</p>



<h2 class="wp-block-heading">What Is CUA and Why Should RPA Teams Care?</h2>



<p class="wp-block-paragraph">CUA — short for Computer Use Agents — is open-source infrastructure that gives AI agents full, sandboxed desktop environments they can operate. It is <em>not</em> an agent itself. It&#8217;s the substrate: the virtual machines, the drivers, the SDKs, and the benchmarks that let you plug in any vision-capable language model (Claude, GPT-4o, Gemini, open-weight models like UI-TARS) and have it control a real operating system.</p>



<p class="wp-block-paragraph">Think of it this way: if Anthropic&#8217;s Computer Use API is the engine, CUA is the chassis, wheels, and test track. You bring the engine; CUA provides everything else needed to put it on the road.</p>



<p class="wp-block-paragraph">For RPA teams, this distinction matters enormously. Traditional RPA platforms bundle the runtime, the recorder, the orchestrator, and the execution environment into a single licensed product. CUA unbundles the execution environment and makes it open, composable, and model-agnostic — meaning your automation isn&#8217;t locked to one vendor&#8217;s AI capabilities or pricing structure.</p>



<h3 class="wp-block-heading">The Core Problem CUA Solves</h3>



<p class="wp-block-paragraph">Enterprise desktops are messy. Legacy ERP systems, thick-client insurance applications, government portals built in the early 2000s, CAD tools, healthcare record systems — these applications have no APIs, no webhooks, and no integration layer. The only interface is the screen.</p>



<p class="wp-block-paragraph">Traditional RPA handles this with pixel-matching, selector-based automation, and recorded click sequences. It works — until it doesn&#8217;t. According to <a href="https://rpabotsworld.com/automation-anywhere-vs-uipath-agentic-procure-to-pay-2026/">industry analyses of RPA platform deployments</a>, maintenance overhead from UI changes is one of the largest hidden costs of enterprise RPA programs.</p>



<p class="wp-block-paragraph">Computer-use agents solve this by replacing brittle selectors with vision-based reasoning. The agent receives a screenshot, interprets the UI elements using a vision-language model, and decides on the next action. When a button moves or a dialog changes, the agent adapts — because it&#8217;s reading the screen the way a human does, not following a hardcoded path.</p>



<p class="wp-block-paragraph">CUA provides the infrastructure to run these agents safely: isolated virtual machines so the agent can&#8217;t damage the host, cross-platform drivers so the same code works on macOS, Windows, and Linux, and benchmarking tools so you can measure how well your agent actually performs before deploying it to production.</p>



<h2 class="wp-block-heading">CUA Architecture: The Five-Layer Stack</h2>



<p class="wp-block-paragraph">CUA is not a single tool — it&#8217;s a modular stack with five distinct components, each solving a different part of the computer-use problem. Understanding the architecture is critical for evaluating where CUA fits in your automation strategy.</p>



<h3 class="wp-block-heading">1. Cua Sandbox — Isolated Desktop Environments</h3>



<p class="wp-block-paragraph">The Sandbox SDK provides a single Python API for launching ephemeral desktop environments across Linux, macOS, Windows, and Android. A typical invocation looks like this:</p>



<pre class="wp-block-code"><code>from cua import Sandbox, Image

async with Sandbox.ephemeral(Image.linux()) as box:
    await box.shell.run("apt-get install -y firefox")
    screenshot = await box.screenshot()
    await box.mouse.click(x=500, y=300)
    await box.keyboard.type("search query")</code></pre>



<p class="wp-block-paragraph">Key architectural decisions in the Sandbox layer:</p>



<ul class="wp-block-list">
<li><strong>Ephemeral by default:</strong> Every run starts from a clean image, ensuring reproducibility. This is critical for benchmarking and for production deployments where you need deterministic starting states.</li>



<li><strong>BYOI (Bring Your Own Image):</strong> You can supply custom <code>.qcow2</code> or <code>.iso</code> images — essential for enterprise teams that need to test against their actual desktop environment, not a generic Linux install.</li>



<li><strong>Cross-OS from one API:</strong> The same <code>mouse.click</code>, <code>keyboard.type</code>, and <code>screenshot</code> methods work whether the sandbox is running Ubuntu, macOS Sequoia, or Windows 11.</li>



<li><strong>Near-native performance:</strong> On Apple Silicon, macOS VMs run via Apple&#8217;s Virtualization.Framework at up to 97% native CPU speed according to the project&#8217;s benchmarks. Linux and Windows run via QEMU on any host.</li>
</ul>



<p class="wp-block-paragraph">The sandbox daemon (<code>cua-spacesd</code>) runs inside each virtual environment on port 3211, exposing process management, filesystem access, desktop control, and screen streaming over gRPC. This is the communication bridge between your agent code and the virtual desktop.</p>



<h3 class="wp-block-heading">2. Cua Driver — Background Desktop Automation</h3>



<p class="wp-block-paragraph">While the Sandbox runs agents in isolated VMs, the Driver takes a fundamentally different approach: it runs agents <em>on the user&#8217;s actual machine</em>, in the background, without taking over the mouse cursor or window focus.</p>



<p class="wp-block-paragraph">This is CUA&#8217;s most distinctive capability. Traditional RPA tools like UiPath&#8217;s attended robots seize control of the desktop — you can&#8217;t use your computer while the bot runs. CUA Driver operates in the background by reading accessibility trees, intercepting screen buffers, and injecting input events at the system level without moving the visible pointer.</p>



<p class="wp-block-paragraph">The Driver ships as:</p>



<ul class="wp-block-list">
<li>A <strong>CLI</strong> for scripting and automation pipelines</li>



<li>An <strong>MCP server</strong> for integration with Claude Code, Cursor, Codex, and other MCP-compatible tools (a direct connection to the <a href="https://rpabotsworld.com/a2a-joins-mcp-aaif-agentic-ai-architects-guide/">Model Context Protocol ecosystem</a>)</li>



<li>Typed <strong>SDKs</strong> in Python, TypeScript, Swift, and Kotlin</li>
</ul>



<p class="wp-block-paragraph">The Driver also records sessions as replayable trajectories — structured logs of every screenshot, action, and outcome — which feed directly into Cua Bench for evaluation and into training pipelines for fine-tuning custom models.</p>



<h3 class="wp-block-heading">3. Lume — Lightweight VM Management</h3>



<p class="wp-block-paragraph">Lume is the virtual machine layer underneath the Sandbox. Originally the founding project of the company (before the broader CUA vision took shape), Lume is a CLI that creates and manages macOS and Linux VMs on Apple Silicon using Apple&#8217;s Virtualization.Framework.</p>



<p class="wp-block-paragraph">For RPA architects evaluating CUA, Lume matters because it determines deployment topology. You can run Lume locally (a developer testing agents on their laptop), on dedicated Mac hardware in a data center (an RPA Center of Excellence running agent fleets), or through CUA&#8217;s cloud offering on AWS, Google Cloud, or Modal (teams that want managed infrastructure).</p>



<h3 class="wp-block-heading">4. CuaBot — Multi-Player Computer Use</h3>



<p class="wp-block-paragraph">Launched at ClawCon San Francisco in February 2026 (which drew 700+ in-person attendees and 20,000 livestream viewers), CuaBot introduced what the team calls &#8220;multi-player computer use.&#8221; It runs coding agents — Claude Code, OpenClaw, and others — inside sandboxed desktops, with the desktop stream visible to the human operator via H.265 video, shared clipboard, and audio.</p>



<p class="wp-block-paragraph">The multi-player aspect means both the human and the agent have cursors on the same desktop simultaneously. The human can watch, intervene, take over, and hand back control. This maps directly to the &#8220;human-in-the-loop&#8221; pattern that enterprise automation teams require for compliance-sensitive workflows — a pattern that <a href="https://rpabotsworld.com/forrester-wave-adaptive-process-orchestration-q3-2026-guide/">Forrester&#8217;s Q3 2026 Adaptive Process Orchestration Wave</a> identified as a key differentiator for mature automation platforms.</p>



<h3 class="wp-block-heading">5. Cua Bench — Evaluation and Training Infrastructure</h3>



<p class="wp-block-paragraph">You can&#8217;t improve what you can&#8217;t measure. Cua Bench provides a standardized harness for evaluating computer-use agents across established benchmarks:</p>



<ul class="wp-block-list">
<li><strong>OSWorld:</strong> The de facto benchmark for desktop agent tasks, where state-of-the-art models currently achieve 30–50% accuracy (compared to a human baseline of approximately 72%)</li>



<li><strong>ScreenSpot:</strong> Visual grounding accuracy — can the model correctly identify which UI element to interact with?</li>



<li><strong>Windows Arena:</strong> Multi-step Windows desktop tasks</li>



<li><strong>Custom task definitions:</strong> Define your own evaluation scenarios for domain-specific testing</li>
</ul>



<p class="wp-block-paragraph">Cua Bench supports parallel execution (<code>--max-parallel 4</code>) for running evaluations at scale, and exports trajectories in a structured format suitable for fine-tuning or reinforcement learning. This is the bridge between &#8220;we built an agent&#8221; and &#8220;we know how well our agent actually works&#8221; — a gap that most enterprise RPA deployments never close.</p>



<h2 class="wp-block-heading">CUA vs. the Competitive Landscape: Where Does It Fit?</h2>



<p class="wp-block-paragraph">The computer-use agent space has exploded in 2026, with offerings from frontier labs, startups, and traditional RPA vendors all converging on the same problem. Here&#8217;s how CUA stacks up.</p>



<h3 class="wp-block-heading">CUA vs. Anthropic Computer Use API</h3>



<p class="wp-block-paragraph">Anthropic&#8217;s Claude Computer Use API provides a model capability: Claude sees a screenshot, returns the next mouse/keyboard action, and your code executes it. It is the engine without a car.</p>



<p class="wp-block-paragraph">CUA provides the car. In practice, most teams building with Anthropic&#8217;s Computer Use API end up needing exactly what CUA offers: sandboxed environments, cross-platform drivers, trajectory recording, and evaluation tooling. The two are complementary, not competitive. You run Claude&#8217;s Computer Use inside a CUA Sandbox, with Cua Bench measuring accuracy, and the Cua Driver handling background execution on production machines.</p>



<h3 class="wp-block-heading">CUA vs. OpenAI ChatGPT Agent (Operator)</h3>



<p class="wp-block-paragraph">OpenAI folded its Operator product into the broader ChatGPT Agent offering — a hosted cloud VM with browser, terminal, and file access. It&#8217;s powerful for consumer and knowledge-worker tasks, but it runs entirely in OpenAI&#8217;s cloud. You can&#8217;t deploy it on-premises, can&#8217;t connect it to internal applications behind a firewall, and can&#8217;t customize the execution environment.</p>



<p class="wp-block-paragraph">For enterprise RPA teams, this is a dealbreaker. The applications you need to automate — SAP, Epic, Oracle E-Business Suite, in-house legacy systems — aren&#8217;t accessible from a datacenter VM with a public IP. CUA runs locally or in your own cloud account, with full network access to your internal environment. OpenAI&#8217;s approach works well for personal productivity tasks (as explored in the <a href="https://rpabotsworld.com/openai-devday-2026-dots-agents-gpt-6-1-sol-guide/">OpenAI DevDay 2026 coverage</a>); CUA works for enterprise process automation.</p>



<h3 class="wp-block-heading">CUA vs. Google Mariner / Gemini Computer Use</h3>



<p class="wp-block-paragraph">Google&#8217;s Mariner and the broader <a href="https://rpabotsworld.com/google-gemini-enterprise-agent-platform-guide/">Gemini enterprise agent platform</a> remain primarily browser-scoped. For organizations whose automation targets are web applications, Mariner is compelling. For desktop automation — which represents the bulk of legacy enterprise RPA workloads — it&#8217;s out of scope. CUA covers both web (via browser instances inside sandboxes) and native desktop applications.</p>



<h3 class="wp-block-heading">CUA vs. Traditional RPA (UiPath, Automation Anywhere, Blue Prism)</h3>



<p class="wp-block-paragraph">This is the comparison that matters most for this site&#8217;s audience. Here&#8217;s the honest assessment:</p>



<figure class="wp-block-table"><table class="has-fixed-layout"><thead><tr><th>Dimension</th><th>Traditional RPA</th><th>CUA + Vision Model</th></tr></thead><tbody><tr><td><strong>Resilience to UI changes</strong></td><td>Breaks on selector/coordinate changes; requires manual maintenance</td><td>Adapts via vision reasoning; self-heals for minor UI drift</td></tr><tr><td><strong>Development speed</strong></td><td>Point-and-click recorders; fast for simple flows</td><td>Requires prompt engineering and model selection; steeper initial curve</td></tr><tr><td><strong>Cost per execution</strong></td><td>Low marginal cost once built (license fees aside)</td><td>Higher: each step sends a screenshot through an LLM (token-heavy)</td></tr><tr><td><strong>Determinism</strong></td><td>High — same inputs produce same outputs every time</td><td>Lower — LLM reasoning introduces variability; requires guardrails</td></tr><tr><td><strong>Audit trail</strong></td><td>Mature; meets SOX/HIPAA requirements out of the box</td><td>Trajectory recording provides raw data; compliance tooling is emerging</td></tr><tr><td><strong>Maintenance overhead</strong></td><td>High — UI changes require workflow updates</td><td>Low — agent adapts; retraining needed only for major redesigns</td></tr><tr><td><strong>Vendor lock-in</strong></td><td>High — proprietary runtimes, licensing, orchestrators</td><td>Low — MIT license, model-agnostic, self-hostable</td></tr><tr><td><strong>Legacy app coverage</strong></td><td>Excellent for apps with stable UIs</td><td>Excellent for apps with dynamic UIs; may struggle with pixel-perfect precision tasks</td></tr></tbody></table></figure>



<p class="wp-block-paragraph">The honest verdict: CUA + a vision model is not a wholesale replacement for traditional RPA today. It&#8217;s a <em>complement</em> that excels where RPA struggles — dynamic UIs, cross-application workflows that span unintegrated systems, and scenarios where maintenance costs exceed development costs. The smart architecture is a hybrid: deterministic RPA for stable, high-volume, precision-critical processes; computer-use agents for everything that traditional bots keep breaking on.</p>



<h3 class="wp-block-heading">CUA vs. Other Open-Source CUA Infrastructure</h3>



<p class="wp-block-paragraph">CUA isn&#8217;t the only open-source player. Here&#8217;s how it compares to the closest alternatives:</p>



<ul class="wp-block-list">
<li><strong>Browser-Use</strong> (~14K+ stars): MIT-licensed, built on Playwright, excellent for web-only automation. If your targets are all web applications, Browser-Use is lighter and simpler. CUA wins when you need desktop scope — and most enterprise RPA workloads involve at least some thick-client applications.</li>



<li><strong>E2B Desktop / Daytona:</strong> Cloud sandbox competitors. CUA has broader OS coverage (especially macOS, which matters for design, creative, and Mac-first enterprise environments) and the Bench/Driver components that E2B lacks.</li>



<li><strong>OpenCUA (xlang-ai):</strong> A research-focused project with the AgentNet dataset and fine-tuned 7B/32B/72B models that achieve state-of-the-art OSWorld results. OpenCUA is for training and research; CUA is for production infrastructure. They complement each other — you could train a model with OpenCUA&#8217;s data and deploy it on CUA&#8217;s infrastructure.</li>



<li><strong>Simular (Agent S/S2):</strong> A proprietary startup (ex-DeepMind team) offering a commercial computer-use agent priced at $500/month per seat for enterprise. Closest competitor in terms of ambition, but closed-source and vendor-locked.</li>
</ul>



<h2 class="wp-block-heading">How CUA Works: A Practitioner&#8217;s Walkthrough</h2>



<p class="wp-block-paragraph">Understanding CUA&#8217;s architecture conceptually is one thing. Seeing the actual workflow — from installation to a running agent — reveals where the developer experience stands today.</p>



<h3 class="wp-block-heading">Installation</h3>



<p class="wp-block-paragraph">CUA provides platform-specific installers:</p>



<pre class="wp-block-code"><code># macOS / Linux
curl -fsSL https://cua.ai/install.sh | sh

# Windows (PowerShell)
# Separate installer script available from cua.ai

# Python SDK only
pip install cua

# Cua Driver (for background automation on native desktop)
# Separate install script from cua.ai</code></pre>



<p class="wp-block-paragraph">The full Cua Spaces application (the desktop GUI for managing sandboxes) requires macOS 26 or later. The Python SDK and CLI work on macOS, Linux, and Windows. Lume (VM management) requires Apple Silicon for macOS VMs; Linux VMs run on any host via QEMU.</p>



<h3 class="wp-block-heading">The Agent Loop: Vision → Reason → Act</h3>



<p class="wp-block-paragraph">At its core, a computer-use agent built on CUA follows a simple loop:</p>



<ol class="wp-block-list">
<li><strong>Screenshot:</strong> Capture the current state of the desktop</li>



<li><strong>Send to VLM:</strong> Pass the screenshot to a vision-language model with a task description</li>



<li><strong>Parse action:</strong> The model returns a structured action (click at coordinates, type text, scroll, or &#8220;done&#8221;)</li>



<li><strong>Execute:</strong> CUA&#8217;s Sandbox or Driver executes the action on the virtual or real desktop</li>



<li><strong>Repeat:</strong> Take a new screenshot and continue until the task is complete or a step limit is reached</li>
</ol>



<p class="wp-block-paragraph">CUA provides a reference <code>cua-agent</code> package that implements a ReAct-style loop as a baseline. Production teams typically customize this with domain-specific guardrails: maximum step counts, action validation (preventing the agent from clicking &#8220;Delete&#8221; on certain screens), checkpoint-and-rollback logic, and human-in-the-loop escalation triggers.</p>



<h3 class="wp-block-heading">MCP Integration: The Connector to the Agentic Ecosystem</h3>



<p class="wp-block-paragraph">CUA Driver ships as an MCP server, which means it plugs directly into the <a href="https://rpabotsworld.com/a2a-joins-mcp-aaif-agentic-ai-architects-guide/">Model Context Protocol ecosystem</a>. Practically, this means:</p>



<ul class="wp-block-list">
<li>Claude Code users can add CUA Driver as an MCP tool and have Claude operate their desktop applications from within the coding assistant</li>



<li>Cursor and Codex users get the same integration via their MCP configurations</li>



<li>Custom agentic workflows built on MCP-compatible frameworks can incorporate desktop automation as a first-class capability</li>
</ul>



<p class="wp-block-paragraph">This MCP-native approach is strategically significant. As the agentic AI ecosystem consolidates around MCP as the standard protocol for tool integration, CUA&#8217;s position as an MCP server means desktop automation becomes a composable capability that any MCP-compatible agent can invoke — not a siloed tool requiring its own orchestrator.</p>



<h2 class="wp-block-heading">The Team and Backing Behind CUA</h2>



<p class="wp-block-paragraph">CUA was founded in March 2025 by <strong>Francesco Bonacci</strong> (product, previously at Microsoft) and <strong>Dillon DuPont</strong> (research, also ex-Microsoft, where the two co-authored the Windows Agent Arena benchmark). The company is headquartered in San Francisco with a distributed team spanning Vancouver, Toronto, New York, and New Jersey.</p>



<p class="wp-block-paragraph">The project was accepted into Y Combinator&#8217;s X25 batch and received $500K in seed funding from 468 Capital, Orange Collective, and Script Capital. The original project — Lume, the lightweight VM manager — launched on Hacker News in March 2025 and grew into the broader CUA platform.</p>



<p class="wp-block-paragraph">Key milestones that demonstrate community traction:</p>



<ul class="wp-block-list">
<li><strong>July 2025:</strong> Presented Windows Agent Arena at ICML with Ollama</li>



<li><strong>September 2025:</strong> Sponsored the first Computer-Use Agents track at Hack the North (1,778 participants)</li>



<li><strong>November 2025:</strong> Windows GA, macOS preview, CLI, VLM Router, and Playground shipped in one week; presented at NeurIPS with Ollama</li>



<li><strong>December 2025:</strong> Launched Cua-Bench; hosted hackathon with CodeRabbit and Factory</li>



<li><strong>February 2026:</strong> ClawCon San Francisco (700+ attendees, 20K livestream viewers) — launched CuaBot multi-player computer use</li>



<li><strong>September 2026:</strong> Latest releases include cua-driver-rs v0.28.x with modern MCP support, sandbox v0.7.0 with shared Driver MCP client, and Cua Fleet for managing agent clusters</li>
</ul>



<p class="wp-block-paragraph">The release cadence is aggressive — multiple updates per week, with nightly builds available for early adopters. This velocity signals active development but also means production teams should pin versions carefully, as breaking changes are possible between minor releases.</p>



<h2 class="wp-block-heading">CUA-S1: The Specialized Models</h2>



<p class="wp-block-paragraph">In addition to the infrastructure layer, CUA has begun releasing <strong>CUA-S1</strong> — a family of small, specialized models trained for fast, bounded computer-use decisions. The first research profile focuses on form-filling tasks, with weights hosted on Hugging Face.</p>



<p class="wp-block-paragraph">This is significant for RPA teams evaluating cost. Running GPT-4o or Claude on every screenshot in a long automation workflow gets expensive fast — each step sends a full image through the model. CUA-S1 models are designed for the simple, repetitive decisions (clicking a &#8220;Next&#8221; button, filling a text field, selecting a dropdown value) where a small specialized model is both faster and cheaper than a frontier model, reserving the expensive model calls for complex reasoning steps.</p>



<p class="wp-block-paragraph">This tiered-model approach mirrors what mature RPA orchestration looks like: simple rules for simple tasks, complex logic for complex decisions. CUA-S1 brings this pattern to computer-use agents.</p>



<h2 class="wp-block-heading">Enterprise Considerations: What RPA Teams Need to Evaluate</h2>



<p class="wp-block-paragraph">Before adding CUA to your automation stack, these are the practical questions every RPA architect should work through.</p>



<h3 class="wp-block-heading">Licensing and Compliance</h3>



<p class="wp-block-paragraph">CUA uses a layered licensing model:</p>



<ul class="wp-block-list">
<li><strong>MIT License:</strong> The SDK, CLI, Cua Driver, and Lume — the core components you&#8217;d deploy in production</li>



<li><strong>FSL-1.1-MIT:</strong> Cua Spaces (the desktop app) and Cua Driver Bench — source-available, becomes MIT two years after each release ships</li>



<li><strong>AGPL-3.0:</strong> The optional <code>cua-som</code> perception extension and <code>cua-perception</code> — important to evaluate if your legal team has AGPL restrictions</li>
</ul>



<p class="wp-block-paragraph">For most enterprise deployments, the MIT-licensed core is what matters. The SDK and Driver can be deployed, modified, and embedded in proprietary systems without copyleft concerns.</p>



<h3 class="wp-block-heading">Deployment Topology</h3>



<p class="wp-block-paragraph">CUA supports three deployment models:</p>



<ol class="wp-block-list">
<li><strong>Local development:</strong> Developers run Lume and the Sandbox on their laptops (requires Apple Silicon for macOS VMs). Low cost, good for prototyping and testing.</li>



<li><strong>Self-hosted infrastructure:</strong> Run CUA on dedicated hardware in your data center or private cloud. Cua Fleet manages clusters of agent-running sandboxes. This is the model for enterprise teams with on-premises requirements.</li>



<li><strong>CUA Cloud:</strong> Managed infrastructure through cua.ai, with deployment to AWS, Google Cloud, or Modal. Usage-based pricing. Fastest path to production for teams without infrastructure expertise.</li>
</ol>



<h3 class="wp-block-heading">Security and Isolation</h3>



<p class="wp-block-paragraph">Sandboxing is CUA&#8217;s primary security model. Each agent runs in an ephemeral VM that is destroyed after the task completes. The host machine is never exposed to the agent&#8217;s actions. For the Driver (which runs on the actual machine), the risk profile is different — the agent can see and interact with real applications, which requires careful access scoping and human oversight.</p>



<p class="wp-block-paragraph">Teams deploying the Driver in production should implement:</p>



<ul class="wp-block-list">
<li>Application allow-lists (restrict which apps the agent can interact with)</li>



<li>Action validation layers (prevent destructive actions like &#8220;Delete All&#8221;)</li>



<li>Session recording with audit trails (CUA&#8217;s trajectory export provides the raw data; you build the compliance wrapper)</li>



<li>Human-in-the-loop escalation for high-risk actions</li>
</ul>



<h3 class="wp-block-heading">Current Limitations</h3>



<p class="wp-block-paragraph">Transparency about limitations is essential for realistic planning:</p>



<ul class="wp-block-list">
<li><strong>macOS VM sandboxes require Apple Silicon.</strong> If your enterprise is Windows-only, you&#8217;re limited to Linux and Windows sandboxes via QEMU (which works fine, but lacks the Virtualization.Framework performance optimization).</li>



<li><strong>OSWorld accuracy is still 30–50% for the best models.</strong> Human accuracy on the same benchmark is approximately 72%. Computer-use agents are not yet reliable enough for fully unattended, mission-critical processes without guardrails.</li>



<li><strong>Cost per task is higher than traditional RPA.</strong> Each step involves an LLM inference call with an image — expect $0.01–0.10 per step depending on the model. For high-volume processes (thousands of transactions per day), this may not compete with a well-maintained RPA bot.</li>



<li><strong>The ecosystem is fast-moving.</strong> APIs change between releases. Pin your CUA dependency versions and test before upgrading.</li>



<li><strong>Linux Driver is newer and less mature than macOS.</strong> Production deployments on Linux should expect some rough edges.</li>
</ul>



<h2 class="wp-block-heading">Where CUA Fits in the 2026 Automation Stack</h2>



<p class="wp-block-paragraph">The most productive way to think about CUA is not as an RPA replacement but as a new layer in the automation stack — one that handles the workflows traditional RPA can&#8217;t reach or can&#8217;t maintain cost-effectively.</p>



<p class="wp-block-paragraph">A mature 2026 automation architecture might look like this:</p>



<ul class="wp-block-list">
<li><strong>API integrations</strong> for systems with modern APIs (Salesforce, ServiceNow, Workday REST APIs) — cheapest, fastest, most reliable</li>



<li><strong>Traditional RPA</strong> for high-volume, stable-UI processes where determinism matters (invoice processing against a stable SAP GUI, for example)</li>



<li><strong>Computer-use agents on CUA</strong> for dynamic-UI processes, cross-application workflows spanning unintegrated systems, and long-tail automations where the maintenance cost of a traditional RPA bot exceeds the value delivered</li>



<li><strong>Agentic orchestration</strong> tying all three layers together — platforms like <a href="https://rpabotsworld.com/pydantic-ai-v2-capabilities-composable-agents-guide/">Pydantic AI</a> for composable agent architecture, or enterprise orchestrators from UiPath Maestro and Automation Anywhere</li>
</ul>



<p class="wp-block-paragraph">CUA&#8217;s position as open-source infrastructure — not a competing product — means it integrates into existing stacks rather than replacing them. A UiPath shop can run CUA alongside its existing bots, using CUA for the automations that keep breaking and UiPath for the ones that run reliably. This is pragmatic, not ideological.</p>



<h2 class="wp-block-heading">Getting Started: A Decision Framework</h2>



<p class="wp-block-paragraph">If you&#8217;re evaluating CUA for your organization, here&#8217;s a practical decision tree:</p>



<ol class="wp-block-list">
<li><strong>Start with Cua Bench.</strong> Before building anything, benchmark your target model (Claude Computer Use, GPT-4o, UI-TARS-2, or your fine-tuned model) on OSWorld and ScreenSpot. If accuracy on your target task type is below 40%, you need a better model before you need better infrastructure.</li>



<li><strong>Prototype with the Sandbox SDK.</strong> Build a proof-of-concept for one specific workflow — ideally a process that&#8217;s causing the most RPA maintenance pain. Use ephemeral Linux sandboxes (no Apple Silicon required).</li>



<li><strong>Evaluate the Driver for attended scenarios.</strong> If your use case involves human-in-the-loop workflows (compliance review, exception handling), test the Driver on macOS to see if background operation meets your requirements.</li>



<li><strong>Run a cost model.</strong> Calculate the per-task cost of the CUA approach (model inference + infrastructure) versus the total cost of ownership of your current RPA solution (licenses + development + maintenance). CUA wins on maintenance-heavy, low-volume processes. Traditional RPA wins on stable, high-volume processes.</li>



<li><strong>Evaluate the MCP integration path.</strong> If your organization is building an MCP-based agentic infrastructure, CUA Driver as an MCP server fits naturally. If you&#8217;re committed to a specific RPA vendor&#8217;s orchestration layer, evaluate whether CUA can be invoked from that orchestrator.</li>
</ol>



<h2 class="wp-block-heading">What&#8217;s Coming Next</h2>



<p class="wp-block-paragraph">Based on the project&#8217;s trajectory and public roadmap signals:</p>



<ul class="wp-block-list">
<li><strong>CUA-S1 model expansion:</strong> More specialized models for specific task types beyond form-filling — navigation, data extraction, and multi-step reasoning</li>



<li><strong>Fleet management maturity:</strong> Cua Fleet is in early releases (v0.1.x). Expect orchestration features for managing dozens or hundreds of concurrent agent sandboxes</li>



<li><strong>Enterprise compliance tooling:</strong> Trajectory recording provides raw data, but SOC 2 and HIPAA-ready compliance features (immutable audit logs, role-based access, data residency controls) are likely on the roadmap given the project&#8217;s enterprise ambitions</li>



<li><strong>Deeper Windows support:</strong> Windows went GA in November 2025, but macOS has received more recent development attention. Expect Windows parity as the enterprise market demands it</li>
</ul>



<h2 class="wp-block-heading">FAQs</h2>



<h3 class="wp-block-heading">Is CUA a replacement for UiPath, Automation Anywhere, or Blue Prism?</h3>



<p class="wp-block-paragraph">No — CUA is infrastructure for computer-use agents, not a full RPA platform. It lacks the orchestrator, recorder, credential vault, queue management, and enterprise administration features that RPA platforms provide. It complements RPA by handling workflows that traditional bots can&#8217;t maintain cost-effectively, particularly those involving dynamic UIs or cross-application processes without API integrations.</p>



<h3 class="wp-block-heading">What models work best with CUA?</h3>



<p class="wp-block-paragraph">CUA is model-agnostic. In practice, the best-performing models for computer use tasks in 2026 are Anthropic&#8217;s Claude (with Computer Use API) and ByteDance&#8217;s UI-TARS-2 (open-weight, approximately 53% on OSWorld-Verified). GPT-4o and Gemini also work. CUA&#8217;s own CUA-S1 models are designed for fast, cheap decisions on simple tasks, with frontier models reserved for complex reasoning.</p>



<h3 class="wp-block-heading">How much does it cost to run CUA in production?</h3>



<p class="wp-block-paragraph">CUA itself is free (MIT license). Costs come from three sources: infrastructure (VMs to run sandboxes — varies by cloud provider), model inference (each screenshot-to-action step costs $0.01–0.10 depending on the model and provider), and development time. For a typical 20-step workflow running 100 times per day with Claude, expect roughly $20–200/day in model inference costs. Compare this to your current RPA license and maintenance costs for the same process.</p>



<h3 class="wp-block-heading">Can CUA handle multi-application workflows that span SAP, Excel, and a custom web portal?</h3>



<p class="wp-block-paragraph">Yes — this is one of its primary advantages. A CUA sandbox runs a full desktop environment, so the agent can open SAP GUI, switch to Excel, and navigate a browser-based portal within a single session. Traditional RPA does this too, but CUA&#8217;s vision-based approach handles the transitions between applications more gracefully when UI layouts change.</p>



<h3 class="wp-block-heading">Is CUA production-ready for mission-critical processes?</h3>



<p class="wp-block-paragraph">With guardrails, yes — for the right processes. CUA is actively used in production by teams building computer-use agent products. However, the 30–50% accuracy ceiling on general benchmarks means fully unattended, zero-tolerance-for-error processes are not yet viable without human oversight. Use it for attended automation, supervised batch processing, and processes where occasional errors are recoverable.</p>



<h2 class="wp-block-heading">Key Takeaways</h2>



<ul class="wp-block-list">
<li><strong>CUA is infrastructure, not an agent.</strong> It provides the sandboxes, drivers, SDKs, and benchmarks that let you build computer-use agents with any vision-capable model. Think of it as &#8220;the Kubernetes of desktop automation.&#8221;</li>



<li><strong>~29K GitHub stars, Y Combinator-backed, MIT-licensed.</strong> One of the fastest-growing open-source projects in the agentic AI infrastructure space in 2026, with aggressive release cadence and a growing community.</li>



<li><strong>Five-layer stack:</strong> Sandbox (isolated VMs), Driver (background desktop automation), Lume (VM management), CuaBot (multi-player computer use), and Cua Bench (evaluation and training).</li>



<li><strong>MCP-native integration</strong> connects CUA to the broader agentic AI ecosystem — Claude Code, Cursor, and any MCP-compatible tool can invoke desktop automation through CUA Driver.</li>



<li><strong>Complements, doesn&#8217;t replace, traditional RPA.</strong> Best suited for dynamic-UI processes, cross-application workflows, and high-maintenance automations where traditional bots keep breaking. Use alongside UiPath/AA/Blue Prism, not instead of them.</li>



<li><strong>Current limitations are real:</strong> 30–50% OSWorld accuracy, higher cost per task than scripted RPA, Apple Silicon required for macOS sandboxes, and a fast-moving codebase that requires version pinning.</li>



<li><strong>The hybrid stack is the pragmatic architecture:</strong> APIs for integrated systems, traditional RPA for stable high-volume processes, CUA for everything else, tied together by an agentic orchestrator.</li>
</ul>



<h2 class="wp-block-heading">References</h2>



<ol class="wp-block-list">
<li>CUA GitHub Repository — <a href="https://github.com/trycua/cua" rel="nofollow noopener" target="_blank">github.com/trycua/cua</a></li>



<li>CUA Official Website — <a href="https://cua.ai/about" rel="nofollow noopener" target="_blank">cua.ai/about</a></li>



<li>Flowtivity, &#8220;Cua: The Open-Source Framework Giving AI Agents Full Computer Access&#8221; (June 2026) — <a href="https://flowtivity.ai/blog/cua-open-source-computer-use-agent/" rel="nofollow noopener" target="_blank">flowtivity.ai</a></li>



<li>Simular AI, &#8220;The Best Computer Use Agents in 2026&#8221; — <a href="https://www.simular.ai/alternatives/computer-use-agents" rel="nofollow noopener" target="_blank">simular.ai</a></li>



<li>Chakra Labs, &#8220;CUA Market Map&#8221; — <a href="https://www.chakra.dev/publications/cua-market-map" rel="nofollow noopener" target="_blank">chakra.dev</a></li>



<li>Y Combinator, CUA Company Profile — <a href="https://www.ycombinator.com/companies/cua" rel="nofollow noopener" target="_blank">ycombinator.com</a></li>



<li>CUA GitHub Releases — <a href="https://github.com/trycua/cua/releases" rel="nofollow noopener" target="_blank">github.com/trycua/cua/releases</a></li>



<li>Clauday, &#8220;trycua/cua — The Computer-Use Stack Goes Open Source&#8221; — <a href="https://clauday.com/article/f093a8c7-8f75-46a3-89e6-990852ebcb48" rel="nofollow noopener" target="_blank">clauday.com</a></li>



<li>andrew.ooo, &#8220;trycua/cua Review: Open-Source Computer-Use Agents&#8221; — <a href="https://andrew.ooo/posts/trycua-cua-open-source-computer-use-agents/" rel="nofollow noopener" target="_blank">andrew.ooo</a></li>



<li>Coddykit, &#8220;GitHub Trending October 2026&#8221; — <a href="https://www.coddykit.com/pages/blog-detail?id=5129963" rel="nofollow noopener" target="_blank">coddykit.com</a></li>
</ol>



<p class="wp-block-paragraph"></p>
]]></content:encoded>
					
					<wfw:commentRss>https://rpabotsworld.com/cua-open-source-computer-use-agent-infrastructure-guide/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>Orca ADE: The Open-Source Parallel Agent Orchestrator Reshaping How Teams Ship Code</title>
		<link>https://rpabotsworld.com/orca-ade-open-source-parallel-agent-orchestrator-guide/</link>
					<comments>https://rpabotsworld.com/orca-ade-open-source-parallel-agent-orchestrator-guide/#comments</comments>
		
		<dc:creator><![CDATA[Satish Prasad]]></dc:creator>
		<pubDate>Sat, 12 Sep 2026 16:02:42 +0000</pubDate>
				<category><![CDATA[RPA & Bot Automation]]></category>
		<category><![CDATA[Open-Source Agents]]></category>
		<guid isPermaLink="false">https://rpabotsworld.com/?p=32375</guid>

					<description><![CDATA[Orca ADE lets you run Claude Code, Codex, and 30+ coding agents in parallel Git worktrees. Architecture deep-dive, setup guide, and why RPA teams should care.]]></description>
										<content:encoded><![CDATA[
<p class="wp-block-paragraph">Five months after its first commit on March 17, 2026, stablyai/orca crossed 43,000 GitHub stars, topped GitHub Trending for consecutive weeks, and introduced a term the industry is still absorbing: <strong>Agent Development Environment</strong> (ADE). The concept is deceptively simple — run Claude Code, Codex, Gemini CLI, and any other terminal-based coding agent side by side, each pinned to its own isolated Git worktree, tracked and reviewed in one window. In practice, it represents a paradigm shift as significant for AI-assisted development as the original IDE was for manual coding.</p>



<p class="wp-block-paragraph">If you build automations for a living — whether in UiPath Studio, Power Automate, or Python-based agent frameworks — the implications of Orca&#8217;s architecture deserve your attention. The same orchestration principles that make RPA Orchestrator indispensable for managing bot fleets now apply to managing fleets of AI coding agents. This guide breaks down what Orca ADE actually does, how its architecture works under the hood, how to set it up, and why agentic AI architects should be watching this space closely.</p>



<h2 class="wp-block-heading">What Is Orca ADE?</h2>



<p class="wp-block-paragraph">Orca is a free, MIT-licensed desktop application built by <strong>Stably AI</strong>, a Y Combinator Winter 2022 company founded by Jinjing Liang (who previously built the testing and release infrastructure that ships Google Chrome to billions of users) and Neil Parker (one of Uber&#8217;s youngest Tech Leads, who led multiple large-scale ML projects on Uber&#8217;s Safety team). The founding team includes PhD graduates specializing in AI&#8217;s application in software reliability plus ex-founders who have previously built and sold an AI startup.</p>



<p class="wp-block-paragraph">At its core, Orca is an <strong>Agent Development Environment</strong> — a new category of tooling that sits above individual AI coding agents and below your project management workflow. Think of it as the control plane for your agent fleet. Instead of the sequential prompt → wait → review → prompt loop that defines working with a single coding agent, Orca lets you fan one prompt across five agents simultaneously, each operating in its own isolated Git worktree, then compare the results and merge the winner.</p>



<p class="wp-block-paragraph">The &#8220;ADE&#8221; framing is deliberate. Just as IDEs (Integrated Development Environments) unified editing, compiling, and debugging into one interface in the 1990s, Orca argues that the 2026 developer workflow needs a unified environment for orchestrating, reviewing, and managing the output of multiple AI coding agents. The project describes itself as built &#8220;for 100x builders&#8221; — engineers who run 10 to 100 coding agents at once.</p>



<h2 class="wp-block-heading">Why Orca Matters: The Shift from Sequential to Parallel Agent Work</h2>



<p class="wp-block-paragraph">To understand why Orca crossed 43,000 stars in five months, you need to understand the problem it solves.</p>



<p class="wp-block-paragraph">By mid-2026, the AI coding agent market has exploded. Claude Code, OpenAI Codex, Google&#8217;s Antigravity, Cursor CLI, GitHub Copilot CLI, Devin, Cline, and dozens more all compete for developer attention. A McKinsey research report found that nearly one-third of surveyed organizations had decided against purchasing at least one software product because they could build the functionality internally using AI-powered coding agents. Gartner predicts that 40% of enterprise applications will feature task-specific AI agents by end of 2026, up from less than 5% in 2025.</p>



<p class="wp-block-paragraph">But here is the bottleneck: most developers use these agents one at a time, in a sequential loop. You prompt Claude Code, wait for it to finish, review the output, then prompt again. If you want to try a different agent on the same task — say, comparing Codex&#8217;s approach to Claude Code&#8217;s — you need to switch tools, contexts, and often branches manually. Scale this across a team of five developers, each running agents on different features, and the coordination overhead becomes the new bottleneck.</p>



<p class="wp-block-paragraph">Orca eliminates this bottleneck through three architectural decisions:</p>



<ol class="wp-block-list">
<li><strong>Git worktree isolation</strong> — every agent session gets its own genuine <code>git checkout</code> in a separate worktree. Agents cannot overwrite each other&#8217;s work mid-task. There is zero shared mutable state between concurrent sessions.</li>



<li><strong>Agent-agnostic orchestration</strong> — Orca does not wrap, proxy, or modify agent traffic. If a tool runs in a terminal, it runs in Orca. Your existing Claude Code or Codex subscriptions work unchanged; Orca just runs them in parallel.</li>



<li><strong>Unified review surface</strong> — annotated diffs, inline comments, and branch comparison happen in one window, so the human reviewer (still essential) can evaluate multiple agent outputs without context-switching between tools.</li>
</ol>



<p class="wp-block-paragraph">This is not incremental improvement. It is a categorical change in how software gets built — from one-human-one-agent to one-human-many-agents. The <a href="https://rpabotsworld.com/rpa-to-agentic-ai-transition-guide/">RPA-to-agentic-AI transition</a> that many teams are navigating involves exactly this kind of paradigm shift.</p>



<h2 class="wp-block-heading">Architecture Deep-Dive: How Orca Actually Works</h2>



<figure class="wp-block-image size-full is-resized"><img fetchpriority="high" decoding="async" width="1200" height="800" src="https://rpabotsworld.com/wp-content/uploads/2026/09/orca-ade-open-source-parallel-agent-orchestrator-guide-architecture-diagram.svg" alt="Orca ADE three-process architecture diagram showing Main, Preload, and Renderer processes with Git worktree isolation layer" class="wp-image-32377" style="width:806px;height:auto" title="Orca ADE: The Open-Source Parallel Agent Orchestrator Reshaping How Teams Ship Code 1"></figure>



<p class="wp-block-paragraph">Orca employs a <strong>three-process Electron architecture</strong> — Main, Preload, and Renderer — to separate system-level operations from the UI and maintain responsiveness while handling heavy background tasks.</p>



<h3 class="wp-block-heading">Process Architecture</h3>



<p class="wp-block-paragraph">The <strong>Main process</strong> handles all system-level operations: Git operations (clone, checkout, worktree creation), PTY (pseudo-terminal) session management for running agent CLIs, SSH tunnel establishment and maintenance, file system watchers, and IPC (inter-process communication) with the renderer. It runs on Node.js and has full access to native APIs.</p>



<p class="wp-block-paragraph">The <strong>Preload process</strong> acts as a security bridge between Main and Renderer. It exposes a carefully scoped API surface to the renderer via Electron&#8217;s <code>contextBridge</code>, preventing the UI from directly accessing system resources — a security design pattern that matters when you are running untrusted agent output.</p>



<p class="wp-block-paragraph">The <strong>Renderer process</strong> runs the UI, built with React and TypeScript. It handles the workspace layout (terminal splits, editor panes, diff viewers, browser previews), state management for active worktree sessions, and the visual diff annotation system.</p>



<h3 class="wp-block-heading">Git Worktree Isolation — The Core Innovation</h3>



<p class="wp-block-paragraph">The heart of Orca&#8217;s architecture is its use of Git worktrees. A Git worktree is a linked working tree attached to a repository that lets you check out a different branch without cloning the entire repo. Orca creates one worktree per agent session, each on its own branch, checked out from the same base ref.</p>



<p class="wp-block-paragraph">This means:</p>



<ul class="wp-block-list">
<li>Agent A (Claude Code) works on <code>feature-auth-claude</code> in <code>/worktrees/auth-claude/</code></li>



<li>Agent B (Codex) works on <code>feature-auth-codex</code> in <code>/worktrees/auth-codex/</code></li>



<li>Agent C (Gemini) works on <code>feature-auth-gemini</code> in <code>/worktrees/auth-gemini/</code></li>
</ul>



<p class="wp-block-paragraph">All three share the same Git object store (so history and refs are shared), but each has its own working directory and index. There is no file-level contention. No merge conflicts mid-task. No race conditions on <code>.git/index</code>. This is filesystem-level concurrency, not application-level locking.</p>



<p class="wp-block-paragraph">For RPA practitioners familiar with <a href="https://rpabotsworld.com/uipath-autopilot-coding-agent-ga-guide-2/">UiPath Orchestrator&#8217;s</a> queue-based job isolation — where each robot gets its own transaction and its own process execution context — the parallel is striking. Orca achieves for coding agents what Orchestrator achieves for RPA robots: deterministic isolation with centralized review.</p>



<h3 class="wp-block-heading">Terminal Layer: Ghostty-Class WebGL Rendering</h3>



<p class="wp-block-paragraph">Each agent runs inside a PTY session rendered through a WebGL-accelerated terminal emulator. Orca&#8217;s terminal layer supports infinite splits (arrange agents, terminals, browsers, diffs, and files into split panes that match the shape of the task), persistent scrollback that survives application restarts, and session restoration on crash or reconnect. The rendering performance matters because coding agents produce substantial terminal output — watching five agents work simultaneously requires a terminal layer that does not bottleneck on rendering.</p>



<h2 class="wp-block-heading">Supported Agents: 30+ CLI Agents and Counting</h2>



<p class="wp-block-paragraph">Orca&#8217;s agent-agnostic design means it works with any CLI agent. As of September 2026, the officially tested list includes over 30 agents:</p>



<figure class="wp-block-table"><table class="has-fixed-layout"><thead><tr><th>Category</th><th>Agents</th></tr></thead><tbody><tr><td><strong>Tier 1 (most popular)</strong></td><td>Claude Code, OpenAI Codex, Cursor CLI, GitHub Copilot CLI</td></tr><tr><td><strong>Major vendors</strong></td><td>Antigravity (Google), Pi, Grok (xAI), Kiro (AWS), Devin, Kimi (Moonshot)</td></tr><tr><td><strong>Open source</strong></td><td>OpenCode, OpenClaude, Hermes Agent (Nous Research), Goose (Block), Cline</td></tr><tr><td><strong>Specialized</strong></td><td>Amp, Auggie, Autohand Code, Codebuff, Command Code, Continue, Droid (Factory), Kilocode, MiMo Code (Xiaomi), Mistral Vibe, Qwen Code, Rovo Dev (Atlassian)</td></tr><tr><td><strong>Meta-orchestrators</strong></td><td>oh-my-pi (Pi wrapper)</td></tr></tbody></table></figure>



<p class="wp-block-paragraph">The key architectural point: Orca does not proxy agent traffic through its own servers. Your API keys, subscriptions, and agent sessions remain between you and the agent provider. Orca is a local orchestration and review layer, not a middleman. This is a deliberate privacy and security decision — and one that enterprise teams evaluating the tool will appreciate.</p>



<h2 class="wp-block-heading">Key Features That Set Orca Apart</h2>



<h3 class="wp-block-heading">1. Parallel Worktrees with Competitive Evaluation</h3>



<p class="wp-block-paragraph">Fan one prompt across multiple agents, each in its own isolated Git worktree. When all agents complete, compare their diffs side by side. Merge the winner. This is not theoretical — it is the primary workflow Orca was built around. For complex implementation tasks where the &#8220;right&#8221; approach is uncertain, running three agents in parallel and picking the best result is faster than running one agent, reviewing, deciding it is suboptimal, and starting over.</p>



<h3 class="wp-block-heading">2. Mobile Companion App</h3>



<p class="wp-block-paragraph">Monitor and steer agents from your phone. Get notified when an agent finishes and send follow-ups from anywhere. Available on iOS (App Store and TestFlight) and Android (APK). For team leads managing agent workloads across a distributed team, this is a force multiplier — you can review and redirect agent work during commute or between meetings.</p>



<h3 class="wp-block-heading">3. Design Mode</h3>



<p class="wp-block-paragraph">Click any UI element in a real Chromium window embedded in Orca to send its HTML, CSS, and a cropped screenshot straight into your agent&#8217;s prompt. This bridges the gap between visual design intent and code generation — instead of describing a UI element in text, you point at it.</p>



<h3 class="wp-block-heading">4. Annotated AI Diffs</h3>



<p class="wp-block-paragraph">Drop inline comments on any diff line generated by an agent and ship those comments back to the agent as follow-up instructions. This creates a tight human-in-the-loop review cycle without leaving the tool. Review, edit, and commit without context-switching.</p>



<h3 class="wp-block-heading">5. SSH Remote Worktrees</h3>



<p class="wp-block-paragraph">Run agents on a remote server with full file editing, Git, and terminal access. Auto-reconnect and port forwarding included. For teams with beefy cloud build machines, this means you can run compute-intensive agent workloads on powerful hardware while controlling them from a lightweight laptop.</p>



<h3 class="wp-block-heading">6. GitHub and Linear Integration</h3>



<p class="wp-block-paragraph">Browse PRs, issues, and project boards in-app. Open a worktree directly from a task and review without context-switching. This connects agent work to your existing project management workflow.</p>



<h3 class="wp-block-heading">7. Orca CLI</h3>



<p class="wp-block-paragraph">Agents can drive Orca too. Script every workflow with <code>orca worktree create</code>, <code>snapshot</code>, <code>click</code>, and <code>fill</code>. This enables automation of the agent orchestration itself — a meta-automation layer that will feel familiar to anyone who has written UiPath coded workflows or Power Automate desktop flows to orchestrate other automations.</p>



<h3 class="wp-block-heading">8. Computer Use</h3>



<p class="wp-block-paragraph">Let agents operate desktop apps and visible UI when a workflow needs real interaction. This is the bridge between terminal-based coding agents and GUI automation — precisely the intersection where RPA meets agentic AI.</p>



<h2 class="wp-block-heading">Getting Started: Installation and First Run</h2>



<h3 class="wp-block-heading">Step 1: Download and Install</h3>



<p class="wp-block-paragraph">Orca is available for macOS (Apple Silicon and Intel), Windows, and Linux.</p>



<pre class="wp-block-code"><code># macOS (Homebrew)
brew install --cask stablyai/orca/orca

# Arch Linux (AUR)
yay -S stably-orca-bin

# Or download directly from https://onorca.dev/download
# Windows: .exe installer
# Linux: AppImage
# macOS: .dmg</code></pre>



<h3 class="wp-block-heading">Step 2: Open a Repository</h3>



<p class="wp-block-paragraph">Launch Orca and open your project repository. Orca will detect the Git configuration and prepare its worktree infrastructure.</p>



<h3 class="wp-block-heading">Step 3: Create Your First Parallel Session</h3>



<p class="wp-block-paragraph">Create a new worktree from the workspace panel. Select which agent(s) to run — Claude Code, Codex, or any other CLI agent you have installed. Each agent gets its own branch and working directory.</p>



<h3 class="wp-block-heading">Step 4: Fan a Prompt</h3>



<p class="wp-block-paragraph">Write your prompt once, then fan it across multiple agents. Orca creates isolated worktrees for each, starts the agent sessions, and shows you real-time output in split terminal panes.</p>



<h3 class="wp-block-heading">Step 5: Review, Annotate, Merge</h3>



<p class="wp-block-paragraph">When agents complete, use the built-in diff viewer to compare outputs. Annotate lines with feedback. Merge the best result back to your main branch.</p>



<h3 class="wp-block-heading">Production Considerations</h3>



<ul class="wp-block-list">
<li><strong>Cost:</strong> Orca itself is free. Your real bill is the agent subscriptions and model credits you already pay for. Running five agents in parallel means five times the token consumption. Budget accordingly.</li>



<li><strong>Disk space:</strong> Git worktrees share the object store but each gets its own working tree checkout. Large monorepos will consume proportionally more disk space per concurrent worktree.</li>



<li><strong>Network:</strong> Parallel agent sessions mean parallel API calls. Ensure your network and API rate limits can handle the concurrency.</li>
</ul>



<h2 class="wp-block-heading">Orca vs. the Alternatives: Where It Fits in the 2026 Landscape</h2>



<p class="wp-block-paragraph">Orca occupies a distinct niche in the 2026 AI coding tool ecosystem. To understand where it fits, consider the three dominant philosophies:</p>



<figure class="wp-block-table"><table class="has-fixed-layout"><thead><tr><th>Tool</th><th>Category</th><th>Philosophy</th><th>Best For</th></tr></thead><tbody><tr><td><strong>Cursor</strong></td><td>AI IDE</td><td>Polished IDE with the best inline autocomplete; model-swapping per task</td><td>Routine coding with AI assistance (the 80%)</td></tr><tr><td><strong>Claude Code / Codex</strong></td><td>Terminal Agent</td><td>Deep agentic reasoning, end-to-end feature shipping from the terminal</td><td>Complex multi-file tasks requiring deep reasoning (the 20%)</td></tr><tr><td><strong>Windsurf</strong></td><td>Agentic IDE</td><td>IDE that drives itself — Cascade plans across files, runs commands, maintains context</td><td>Product engineers who want fewer prompts, more flow</td></tr><tr><td><strong>Orca ADE</strong></td><td>Agent Orchestrator</td><td>Run any/all of the above in parallel, in isolated worktrees, with unified review</td><td>Engineers running 5-100 agents simultaneously on complex projects</td></tr></tbody></table></figure>



<p class="wp-block-paragraph">The key distinction: <strong>Orca does not compete with Claude Code, Codex, or Cursor. It orchestrates them.</strong> The most popular developer stack in 2026 — Claude Code + Cursor — works inside Orca. You are not choosing between them; you are adding an orchestration layer on top.</p>



<p class="wp-block-paragraph">This is analogous to the relationship between an RPA robot and an RPA Orchestrator. The robot (agent) does the work. The orchestrator (Orca) manages the fleet, assigns tasks, isolates execution contexts, and provides the review and merge surface.</p>



<h2 class="wp-block-heading">The RPA Connection: Why Automation Teams Should Care</h2>



<p class="wp-block-paragraph">If you are reading this on rpabotsworld.com, you likely build automations for a living. Here is why Orca matters to you specifically:</p>



<h3 class="wp-block-heading">The Orchestration Pattern Is Identical</h3>



<p class="wp-block-paragraph">UiPath Orchestrator manages a fleet of robots. Each robot gets an isolated execution context (its own machine or container). Jobs are assigned, monitored, and their outputs reviewed centrally. Orca does the same thing for coding agents — isolated worktrees instead of isolated VMs, diff review instead of job logs, branch merging instead of queue completion.</p>



<p class="wp-block-paragraph">If you understand <a href="https://rpabotsworld.com/why-agentic-automation-fails/">why agentic automation programs fail</a>, you understand why unmanaged agent fleets are equally dangerous. Without orchestration, parallel agents create merge conflicts, duplicate work, inconsistent code styles, and review bottlenecks. Orca&#8217;s worktree isolation solves the same class of problems that Orchestrator&#8217;s queue-based transaction isolation solves.</p>



<h3 class="wp-block-heading">RPA Teams Are Already Writing More Code</h3>



<p class="wp-block-paragraph">The transition from low-code RPA (drag-and-drop XAML workflows) to coded automations (C# coded workflows in UiPath, Python-based agents, LangGraph pipelines) means RPA teams are spending more time in code. As the <a href="https://rpabotsworld.com/uipath-vs-automation-anywhere-vs-blue-prism-agentic-platforms-2026/">2026 agentic platform comparison</a> shows, every major RPA vendor is adding agent capabilities, and those capabilities increasingly involve writing and reviewing code. A tool that makes code review of AI-generated output faster and more reliable is directly relevant.</p>



<h3 class="wp-block-heading">The Agent Sprawl Problem</h3>



<p class="wp-block-paragraph">Enterprise teams that have adopted AI coding agents often face the same &#8220;bot sprawl&#8221; problem that plagued early RPA programs — too many agents, too little governance, no centralized visibility. Orca provides a single pane of glass for agent activity, which is the first step toward the kind of <a href="https://rpabotsworld.com/a2a-joins-mcp-aaif-agentic-ai-architects-guide/">agent governance frameworks</a> that enterprise IT departments are starting to demand.</p>



<h3 class="wp-block-heading">Computer Use Bridges RPA and Coding Agents</h3>



<p class="wp-block-paragraph">Orca&#8217;s Computer Use feature — letting agents operate desktop apps and visible UI — sits precisely at the intersection of RPA (automate GUI interactions) and coding agents (automate code generation). For hybrid automation workflows that involve both code generation and GUI interaction, this is a natural convergence point.</p>



<h2 class="wp-block-heading">Limitations and What to Watch</h2>



<p class="wp-block-paragraph">No tool review is complete without an honest assessment of limitations:</p>



<ul class="wp-block-list">
<li><strong>Electron-based:</strong> Orca is an Electron app, which means higher memory consumption than native alternatives. Running five concurrent agent terminals with WebGL rendering in an Electron wrapper will consume significant RAM. Teams on memory-constrained machines should monitor resource usage.</li>



<li><strong>Cost multiplication:</strong> Running agents in parallel multiplies your API costs proportionally. Five agents working for 30 minutes each costs the same as one agent working for 150 minutes. The value proposition depends on whether parallel speed is worth the cost.</li>



<li><strong>Source-available, not fully open governance (yet):</strong> While MIT-licensed, the project is still primarily driven by Stably AI. Community governance structures are evolving. Compare this to projects like n8n (which has a mature community contribution model) or LangChain (which has a formal RFC process).</li>



<li><strong>No built-in agent evaluation:</strong> Orca shows you diffs but does not automatically evaluate code quality, run tests on agent output, or score agent performance. The human reviewer remains the quality gate. Future integration with automated testing pipelines would strengthen the platform significantly.</li>



<li><strong>Early Windows and Linux support:</strong> While officially cross-platform, the project&#8217;s roots are on macOS. Windows and Linux users should expect a slightly less polished experience in the current version, with rapid improvement expected given the project&#8217;s daily ship cadence.</li>
</ul>



<h2 class="wp-block-heading">Frequently Asked Questions</h2>



<h3 class="wp-block-heading">Is Orca ADE free?</h3>



<p class="wp-block-paragraph">Yes. Orca itself is completely free and MIT-licensed. There is no subscription, no per-seat pricing, and no premium tier. Your only costs are the AI coding agent subscriptions (Claude Code, Codex, etc.) and model API credits you already pay for. Orca is an orchestration layer, not a model provider.</p>



<h3 class="wp-block-heading">Does Orca ADE proxy my agent traffic through its servers?</h3>



<p class="wp-block-paragraph">No. Orca runs entirely locally. Your API keys, agent sessions, and code stay on your machine. The only network component is the optional mobile companion relay (for phone notifications), which is also open source and available in the repository&#8217;s <code>cloud/</code> directory if you want to self-host it.</p>



<h3 class="wp-block-heading">Can I use Orca with UiPath coded workflows or Power Automate scripts?</h3>



<p class="wp-block-paragraph">Yes, if you use CLI-based coding agents to write those workflows. For example, you could run Claude Code in Orca to generate UiPath C# coded workflows, while simultaneously running Codex to generate unit tests for those workflows, each in its own worktree. Orca orchestrates the coding agents; it does not care what language or framework the agents are writing in.</p>



<h3 class="wp-block-heading">How does Orca compare to multi-agent frameworks like CrewAI or LangGraph?</h3>



<p class="wp-block-paragraph">Different category entirely. CrewAI and LangGraph orchestrate AI agents at the application layer — defining roles, tools, and communication patterns for agents that perform tasks within a running application. Orca orchestrates coding agents at the development layer — managing the environments where agents write code. You might use LangGraph to build a multi-agent system, and use Orca to run the coding agents that write that LangGraph code.</p>



<h3 class="wp-block-heading">What is an Agent Development Environment (ADE)?</h3>



<p class="wp-block-paragraph">An ADE is a new category of developer tooling that provides a unified environment for running, monitoring, reviewing, and managing the output of multiple AI coding agents. Just as an IDE unified editing, compiling, and debugging in one tool, an ADE unifies agent orchestration, output review, and code merging. Orca coined the term in 2026 and is the leading implementation of the concept.</p>



<h2 class="wp-block-heading">Key Takeaways</h2>



<ul class="wp-block-list">
<li><strong>Orca ADE introduces a new category</strong> — the Agent Development Environment — that orchestrates parallel coding agents the way an RPA Orchestrator manages a bot fleet.</li>



<li><strong>Git worktree isolation</strong> is the core architectural innovation: each agent gets its own branch and working directory with zero shared mutable state, enabling true parallel execution without merge conflicts.</li>



<li><strong>Agent-agnostic by design:</strong> Orca works with 30+ CLI agents (Claude Code, Codex, Gemini, Cursor, and more) without proxying traffic or requiring vendor lock-in.</li>



<li><strong>43,000+ stars in 5 months</strong> signals genuine developer demand for multi-agent orchestration tooling — this is not a niche project.</li>



<li><strong>Free and MIT-licensed</strong> with no per-seat cost. Your bill is your existing agent subscriptions.</li>



<li><strong>For RPA teams moving into agentic AI:</strong> Orca&#8217;s orchestration patterns directly mirror the bot-fleet management principles you already know. The paradigm shift is from sequential single-agent work to parallel multi-agent orchestration.</li>



<li><strong>Watch for:</strong> automated agent output evaluation, deeper CI/CD integration, and enterprise governance features as the project matures.</li>
</ul>



<h2 class="wp-block-heading">References</h2>



<ol class="wp-block-list">
<li>Stably AI. &#8220;Orca — The Agent Development Environment.&#8221; <a href="https://www.onorca.dev/" target="_blank" rel="noopener nofollow">onorca.dev</a>. Accessed September 2026.</li>



<li>stablyai/orca GitHub Repository. <a href="https://github.com/stablyai/orca" target="_blank" rel="noopener nofollow">github.com/stablyai/orca</a>. MIT License. Accessed September 2026.</li>



<li>Y Combinator. &#8220;Stably AI (Orca): We make Orca, MIT open source terminal-based agent orchestrator.&#8221; <a href="https://www.ycombinator.com/companies/stably-ai-orca" target="_blank" rel="noopener nofollow">ycombinator.com</a>. Accessed September 2026.</li>



<li>AgentConn. &#8220;Orca Built an IDE for Agent Fleets. Is the ADE Real?&#8221; <a href="https://agentconn.com/blog/orca-ade-agent-fleet-parallel-coding-agents-2026/" target="_blank" rel="noopener nofollow">agentconn.com</a>. 2026.</li>



<li>CoddyKit Blog. &#8220;Orca: The Open-Source ADE With 43,000+ GitHub Stars That Orchestrates Your AI Coding Agents in Parallel.&#8221; <a href="https://www.coddykit.com/pages/blog-detail?id=513010" target="_blank" rel="noopener nofollow">coddykit.com</a>. 2026.</li>



<li>Yeyupiaoling. &#8220;Orca: An ADE Running Five Coding Agents Simultaneously, A New Parallel Orchestration Paradigm.&#8221; <a href="https://blog.yeyupiaoling.cn/article/1785373066543?lang=en" target="_blank" rel="noopener nofollow">blog.yeyupiaoling.cn</a>. 2026.</li>



<li>McKinsey &amp; Company. Research on AI coding agents&#8217; impact on enterprise software purchasing decisions. Referenced via multiple industry sources, 2026.</li>



<li>Gartner. Prediction: 40% of enterprise applications will feature task-specific AI agents by end of 2026. Referenced via <a href="https://www.firecrawl.dev/blog/best-open-source-agent-frameworks" target="_blank" rel="noopener nofollow">Firecrawl</a>.</li>



<li>DeepWiki. &#8220;stablyai/orca — Architecture and Technical Documentation.&#8221; <a href="https://deepwiki.com/stablyai/orca" target="_blank" rel="noopener nofollow">deepwiki.com</a>. 2026.</li>



<li>Vibecodinghub. &#8220;Orca Review: MIT-licensed agent development environment.&#8221; <a href="https://vibecodinghub.org/tools/orca" target="_blank" rel="noopener nofollow">vibecodinghub.org</a>. 2026.</li>
</ol>
]]></content:encoded>
					
					<wfw:commentRss>https://rpabotsworld.com/orca-ade-open-source-parallel-agent-orchestrator-guide/feed/</wfw:commentRss>
			<slash:comments>1</slash:comments>
		
		
		<media:thumbnail url="https://rpabotsworld.com/wp-content/uploads/2026/09/Gemini_Generated_Image_k28l7ik28l7ik28l.png" />	</item>
		<item>
		<title>Cloudflare OS: The Open-Source Agent Platform Rewriting Enterprise AI Security</title>
		<link>https://rpabotsworld.com/cloudflare-os-open-source-agent-platform-guide/</link>
					<comments>https://rpabotsworld.com/cloudflare-os-open-source-agent-platform-guide/#respond</comments>
		
		<dc:creator><![CDATA[Satish Prasad]]></dc:creator>
		<pubDate>Fri, 14 Aug 2026 16:25:24 +0000</pubDate>
				<category><![CDATA[RPA & Bot Automation]]></category>
		<category><![CDATA[Open-Source Agents]]></category>
		<guid isPermaLink="false">https://rpabotsworld.com/?p=32291</guid>

					<description><![CDATA[Cloudflare OS open-sources an agent workspace with Gatekeepers, Gadgets, and a hybrid isolate-container runtime.]]></description>
										<content:encoded><![CDATA[
<p class="wp-block-paragraph">On August 5, 2026, Cloudflare did something no other infrastructure company has attempted at this scale: it open-sourced the entire agent workspace it had been running internally since May, complete with a capability-based security model that tracks what every agent has <em>seen</em>, not just what it&#8217;s <em>allowed to call</em>. Within 24 hours, the repository cleared 3,900 GitHub stars. Two days earlier, Cloudflare had shipped a companion project — <code>@cloudflare/computer</code> — an MIT-licensed runtime that gives any agent its own virtual machine by dynamically splitting work between V8 isolates and Linux containers.</p>



<p class="wp-block-paragraph">These are not incremental improvements to existing agent frameworks. They represent a fundamentally different answer to the question every enterprise automation team is asking right now: <strong>how do we give agents real access to production systems without handing them the keys to the kingdom?</strong></p>



<p class="wp-block-paragraph">If you&#8217;ve been following the <a href="https://rpabotsworld.com/ai-agent-control-planes-enterprise-governance-guide/">AI agent control plane conversation</a>, Cloudflare OS is the first open-source project to ship a working implementation of the governance patterns that analysts have been describing in theory. And if you&#8217;ve been tracking <a href="https://rpabotsworld.com/top-trending-open-source-agentic-ai-repos/">trending open-source agentic AI repos</a>, this is the one that matters most this month — not because of star count, but because it solves a problem that LangGraph, CrewAI, and AutoGen deliberately leave to the deployer.</p>



<p class="wp-block-paragraph">This guide breaks down the architecture, security model, and runtime design of Cloudflare OS and <code>@cloudflare/computer</code> so you can evaluate whether they belong in your enterprise automation stack.</p>



<h2 class="wp-block-heading">What Cloudflare OS Actually Is (and What It Is Not)</h2>



<p class="wp-block-paragraph">The name is deliberately provocative, and it has caused confusion. Cloudflare OS is <strong>not</strong> a traditional operating system like Linux or Windows. It is an open-source agent workspace platform released under the Apache 2.0 license. Think of it as an &#8220;operating system for organizational AI work&#8221; — it manages agent sessions, enforces security policies, provides an isolated code execution environment, and ships a library of organizational context and skills.</p>



<p class="wp-block-paragraph">The platform combines three components:</p>



<p class="wp-block-paragraph"><strong>An agent workspace</strong> grounded in company-curated context and skills, with an isolated runtime where agents can write and execute code. Every person in the organization gets a browser-based workspace — no terminal required, no developer tooling prerequisite. The workspace comes preloaded with shared knowledge: terminology, procedures, and documented best practices that the organization has codified as reusable agent instructions.</p>



<p class="wp-block-paragraph"><strong>A security and governance framework</strong> called Gatekeepers — capability-based access objects that sit between agents and external services. This is the architectural decision that separates Cloudflare OS from every other agent platform on the market.</p>



<p class="wp-block-paragraph"><strong>A platform for personal, modifiable apps</strong> called Gadgets — full-stack applications (client code, server code, API, and durable state) that agents build for individual users and that run as sandboxed Cloudflare Workers. Each Gadget is a separate, isolated instance — when you create a slide deck, the system spins up a private instance of the slide-deck application just for you, sandboxed from every other instance.</p>



<p class="wp-block-paragraph">The repository lives at <a href="https://github.com/cloudflare/cloudflare-os" target="_blank" rel="noopener nofollow">github.com/cloudflare/cloudflare-os</a>, with a companion starter kit at <a href="https://github.com/cloudflare/cloudflare-os-starter" target="_blank" rel="noopener nofollow">github.com/cloudflare/cloudflare-os-starter</a> for customizing deployments.</p>



<h2 class="wp-block-heading">The Backstory: 3 Months of Internal Dogfooding</h2>



<p class="wp-block-paragraph">Cloudflare didn&#8217;t build this in a vacuum. In May 2026, the company deployed the first version of Cloudflare OS to every employee — engineering, sales, legal, marketing, HR, every function. By the time of the open-source announcement, &#8220;thousands&#8221; of employees across the company were using it daily, many of them non-engineers, to create documents and presentations, automate repeatable tasks, and build small internal apps to visualize data.</p>



<p class="wp-block-paragraph">The first version exposed critical problems that shaped the v2 architecture:</p>



<p class="wp-block-paragraph"><strong>Collaboration broke the security model.</strong> MCP servers told the platform which <em>tools</em> an agent could call, but not which <em>underlying resources</em> the agent had observed. Once people began sharing workspaces, apps, and outputs, there was no mechanism to prevent an agent from combining data across systems and exposing it to someone who shouldn&#8217;t see the original sources. The example from Cloudflare&#8217;s own blog post is instructive: an agent reads a sensitive data-warehouse table and builds a live dashboard from it. If someone shares that dashboard, it becomes an unaudited back-door into the restricted table.</p>



<p class="wp-block-paragraph"><strong>Static apps wasted tokens.</strong> Apps in the first version were deterministic rather than live software connected to internal systems. Running the same job again required spinning up a full agent session and consuming model tokens for work that should have been handled by deterministic code.</p>



<p class="wp-block-paragraph">The v2 rewrite solved both problems at the platform level, which is why the security model is the most interesting part of the architecture.</p>



<h2 class="wp-block-heading">Gatekeepers: Capability-Based Security for AI Agents</h2>



<p class="wp-block-paragraph">This is the core innovation of Cloudflare OS and the reason automation architects should pay attention. Most agent platforms implement security at the <em>tool level</em>: the agent can or cannot call a specific API. Gatekeepers implement security at the <em>resource level</em>, with policy that follows <em>what the agent has observed</em>.</p>



<h3 class="wp-block-heading">How Gatekeepers Work</h3>



<p class="wp-block-paragraph">A Gatekeeper is a service-specific Cloudflare Worker that sits between Cloudflare OS and an external service (GitHub, Jira, Salesforce, a data warehouse — anything with an API). It understands the service&#8217;s API, its resources, and the operations that can be performed on them.</p>



<p class="wp-block-paragraph">Every agent and every app starts with access to <em>nothing</em>. When an agent needs to access a resource, it requests permission. If granted, the agent receives a <strong>typed capability binding</strong> — not an API key, not an OAuth token, but a scoped object representing permission to use a specific resource under a specific policy:</p>



<pre class="wp-block-code"><code>const issues = await env.PROJECT.listIssues({
  teamId: "ENG",
  state: "open",
});
</code></pre>



<p class="wp-block-paragraph">In this example, <code>env.PROJECT</code> is a capability. The actual credential (OAuth token, API key, service account) never touches the agent&#8217;s code or context window. The Gatekeeper holds the credential, handles OAuth flows, enforces policy, records what was read, and mediates anything with an externally visible side effect.</p>



<h3 class="wp-block-heading">The Observation Log: Security That Follows the Data</h3>



<p class="wp-block-paragraph">This is where Cloudflare OS diverges sharply from the <a href="https://rpabotsworld.com/mcp-2026-07-28-stateless-spec-agentic-ai-guide/">MCP-only approach to agent security</a>. MCP controls which tools an agent can call. Gatekeepers go further: they record every resource the agent <em>observes</em>. These observations remain attached to the agent session and everything it produces.</p>



<p class="wp-block-paragraph">When another person tries to open the workspace, interact with the agent, or view what it produced, Gatekeepers verify that person&#8217;s access to every observed resource. If the agent read a restricted data-warehouse table to build a dashboard, only people with access to that table can see the dashboard.</p>



<p class="wp-block-paragraph">The observation log also informs egress policies: a read of sensitive data can prevent the agent from writing data to certain destinations, inviting new collaborators, handing work to another agent, or making outbound requests. This is <strong>taint tracking for AI agents</strong> — the same concept that operating systems use to prevent data exfiltration, applied at the agent-workspace level.</p>



<h3 class="wp-block-heading">What a Gatekeeper Can Enforce</h3>



<p class="wp-block-paragraph">Using the GitHub Gatekeeper as an example, the administrator can configure policies that:</p>



<ul class="wp-block-list">
<li>Allow an agent to read issues on a specific repository while blocking access to source code</li>



<li>Mask specific fields in returned data (e.g., strip email addresses from issue comments)</li>



<li>Rate-limit how many API requests the agent can make per hour</li>



<li>Require human approval before a pull request is merged</li>



<li>Block the agent from creating public repositories</li>
</ul>



<p class="wp-block-paragraph">For enterprise automation teams accustomed to building these guardrails manually around every RPA bot and API integration, Gatekeepers represent a significant reduction in governance overhead. The security is in the platform, not in every individual automation.</p>



<h2 class="wp-block-heading">Gadgets: Every App Is a Worker</h2>



<p class="wp-block-paragraph">Most AI agent platforms produce outputs — documents, code, data files. Cloudflare OS produces <strong>running applications</strong>.</p>



<p class="wp-block-paragraph">When you ask a workspace to build something, the agent writes two parts: client code that renders a UI in the browser, and server code that stores state and implements behavior. The server is loaded on demand as a <strong>Dynamic Worker</strong> — a feature Cloudflare built specifically for this project — and instantiated as a <strong>Durable Object Facet</strong>, giving each app its own SQLite database, separate from the Cloudflare OS runtime managing it.</p>



<p class="wp-block-paragraph">Dynamic Workers use lightweight V8 isolates, so every Gadget gets its own isolated runtime without needing a dedicated server or container. The browser client communicates with the server using <a href="https://github.com/cloudflare/capnweb" target="_blank" rel="noopener nofollow">Cap&#8217;n Web</a>, Cloudflare&#8217;s open-source object-capability RPC system.</p>



<p class="wp-block-paragraph">The critical design decision: a server method can be called by both the user and the agent using the same interface. If you build a tool to do a job yourself, agents can use that same tool to do the job when you&#8217;re not there. This collapses the distinction between &#8220;human-facing app&#8221; and &#8220;agent-facing tool&#8221; — a Gadget is both.</p>



<h3 class="wp-block-heading">Two Sharing Models</h3>



<p class="wp-block-paragraph">Gadgets support two sharing modes:</p>



<p class="wp-block-paragraph"><strong>Share the app itself</strong> — other people collaborate in real time using the same state, like a shared Google Doc. The Gatekeeper observation log ensures that collaborators can only access what they&#8217;re authorized to see.</p>



<p class="wp-block-paragraph"><strong>Share the Blueprint</strong> — other people get the app&#8217;s source code and can deploy their own instance, connected to their own data and resources. This is how teams scale internal tooling: one person (or agent) builds a useful app, publishes the Blueprint, and everyone else gets their own copy.</p>



<h2 class="wp-block-heading">@cloudflare/computer: The Hybrid Agent Runtime</h2>



<p class="wp-block-paragraph">Shipped two days before the Cloudflare OS announcement on August 3, 2026, <code>@cloudflare/computer</code> is an MIT-licensed agent runtime that takes a fundamentally different approach to agent execution than the container-first model used by most platforms.</p>



<p class="wp-block-paragraph">The core thesis: <strong>an agent should need a container for less than 10% of its work</strong>. Most agent tasks — text generation, data transformation, API calls, file manipulation — don&#8217;t need a full Linux userland. They need fast, cheap, isolated compute. Containers are the right tool only for tasks that require native binaries, real filesystem operations, or full networking.</p>



<h3 class="wp-block-heading">Three Execution Backends</h3>



<p class="wp-block-paragraph"><code>@cloudflare/computer</code> sits on top of a virtual filesystem backed by SQLite inside a Durable Object. That filesystem is the single source of truth. The runtime then exposes one pluggable execution surface — <code>workspace.runtime</code> — with three backends that ship today:</p>



<p class="wp-block-paragraph"><strong>1. Container backend:</strong> Projects the SQLite state into a sandbox container as a real FUSE mount. A sandbox-side daemon called <code>computerd</code> mounts the state as a filesystem and syncs changes back over a Cap&#8217;n Web RPC channel. This gives you the full Linux userland — real binaries, real package managers, real networking. Use it for coding tasks, audio/video processing, or anything that needs <code>apt-get install</code>.</p>



<p class="wp-block-paragraph"><strong>2. Isolate shell backend:</strong> Runs bash in a Dynamic Worker, reaching the authoritative Workspace over Workers RPC. No second store, no sync round trip — the shell reads and writes the SQLite-backed filesystem directly. Suitable for lightweight scripting tasks that don&#8217;t need native binaries.</p>



<p class="wp-block-paragraph"><strong>3. Isolate JavaScript backend:</strong> Runs an ECMAScript module in a fresh Dynamic Worker with structured input/results, durable relative imports, configured libraries, Workspace-backed <code>node:fs/promises</code>, and trusted <code>ws:git</code> and <code>ws:artifacts</code> modules. The fastest backend — cold-start in single-digit milliseconds — for pure computation and data transformation.</p>



<p class="wp-block-paragraph">The runtime dynamically selects the right backend for each task. A single agent session might use the JavaScript isolate for data analysis, the shell isolate for a quick file transformation, and a container for installing and running a Python package — all sharing the same virtual filesystem.</p>



<h3 class="wp-block-heading">Why This Matters for Automation Teams</h3>



<p class="wp-block-paragraph">If you&#8217;re running agent workloads at scale — and most enterprise automation teams will be within the next 12 months — the cost and latency difference between isolates and containers is substantial. V8 isolates have near-zero cold-start time and consume a fraction of the memory. Containers take seconds to spin up and hold a full OS image in memory. A runtime that routes 90%+ of work through isolates and falls back to containers only when necessary can reduce both cost and latency by an order of magnitude.</p>



<p class="wp-block-paragraph">For teams already operating <a href="https://rpabotsworld.com/uipath-vs-automation-anywhere-vs-blue-prism-agentic-platforms-2026/">enterprise RPA platforms like UiPath, Automation Anywhere, or Blue Prism</a>, this is directly comparable to how those platforms handle attended vs. unattended robot execution — but at a different layer of the stack and with finer-grained resource isolation.</p>



<h2 class="wp-block-heading">Architecture Deep Dive: How the Pieces Fit Together</h2>



<p class="wp-block-paragraph">The full Cloudflare OS architecture maps traditional operating-system concepts to cloud-native equivalents:</p>



<figure class="wp-block-table"><table class="has-fixed-layout"><thead><tr><th>Traditional OS Concept</th><th>Cloudflare OS Equivalent</th><th>Implementation</th></tr></thead><tbody><tr><td>Kernel</td><td>Workshop Backend</td><td><code>packages/workshop-backend</code> — manages agent sessions, enforces policies, orchestrates execution</td></tr><tr><td>Device Drivers</td><td>Gatekeepers</td><td><code>packages/gatekeeper-*</code> — service-specific Workers mediating access to external APIs</td></tr><tr><td>User Shell</td><td>Workshop Frontend</td><td><code>packages/workshop-frontend</code> — browser-based workspace UI</td></tr><tr><td>Processes</td><td>Gadgets</td><td>Dynamic Workers + Durable Object Facets — per-app isolated runtimes with SQLite state</td></tr><tr><td>Executables</td><td>Blueprints</td><td>Shareable app templates that spawn new Gadget instances</td></tr><tr><td>Access Control Lists</td><td>Capability Objects</td><td>Typed bindings representing scoped permissions, enforced at the Gatekeeper layer</td></tr></tbody></table></figure>



<p class="wp-block-paragraph">Identity is handled by <a href="https://developers.cloudflare.com/cloudflare-one/access-controls/" target="_blank" rel="noopener nofollow">Cloudflare Access</a>, which verifies who can enter the platform. Inside the platform, the Gatekeeper layer handles authorization — what resources each agent and user can access, and under what conditions.</p>



<p class="wp-block-paragraph">Generated code (both Gadget server code and agent-authored scripts) runs in Dynamic Workers with <strong>global outbound networking disabled by default</strong>. Client code runs in sandboxed iframes in the browser. Neither can reach the internet except through capabilities explicitly granted via Gatekeepers. This is the zero-trust principle applied at the agent runtime level.</p>



<h3 class="wp-block-heading">MCP Integration</h3>



<p class="wp-block-paragraph">Cloudflare OS supports existing Model Context Protocol servers through <a href="https://developers.cloudflare.com/cloudflare-one/access-controls/ai-controls/mcp-portals/" target="_blank" rel="noopener nofollow">MCP Server Portals</a>. If your organization already uses MCP servers for agent tooling, they plug into Cloudflare OS without modification. The Gatekeeper layer adds the observation-tracking and policy-enforcement capabilities on top of whatever the MCP server already provides.</p>



<p class="wp-block-paragraph">This is a pragmatic design decision: rather than asking organizations to rewrite all their agent integrations as Gatekeepers, Cloudflare OS accepts MCP servers as-is and layers additional governance on top. Organizations can then migrate high-value integrations to full Gatekeepers over time to get the richer security model.</p>



<h2 class="wp-block-heading">Self-Hosting and Deployment</h2>



<p class="wp-block-paragraph">The official deployment path uses Cloudflare&#8217;s own infrastructure — Workers, Durable Objects, KV, and R2. The starter kit (<a href="https://github.com/cloudflare/cloudflare-os-starter" target="_blank" rel="noopener nofollow">cloudflare-os-starter</a>) provides a customization guide that handles DNS, TLS, and resource provisioning through Wrangler. With resource values left as <code>null</code>, Wrangler automatically creates the required KV namespaces and R2 bucket.</p>



<p class="wp-block-paragraph">Sign-in uses Cloudflare Access, so any identity provider that Access supports (Okta, Azure AD, Google Workspace, GitHub, OneLogin, and others) works out of the box.</p>



<p class="wp-block-paragraph">The community has already produced unofficial self-hosting alternatives, including a Docker Compose setup using LiteLLM and Tailscale (<a href="https://github.com/Sunwood-ai-labs/cloudflare-os-home" target="_blank" rel="noopener nofollow">cloudflare-os-home</a>) for teams that want to run the platform on their own infrastructure without depending on Cloudflare&#8217;s managed services. However, the container and isolate runtime backends depend heavily on Cloudflare Workers internals, so full feature parity on non-Cloudflare infrastructure remains a work in progress.</p>



<h2 class="wp-block-heading">How Cloudflare OS Compares to Other Agent Platforms</h2>



<p class="wp-block-paragraph">Cloudflare OS occupies a different layer of the stack than most agent frameworks. Here&#8217;s how it fits into the August 2026 landscape:</p>



<figure class="wp-block-table"><table class="has-fixed-layout"><thead><tr><th>Platform</th><th>Primary Function</th><th>Security Model</th><th>Runtime</th><th>License</th></tr></thead><tbody><tr><td><strong>Cloudflare OS</strong></td><td>Agent workspace + app platform</td><td>Capability-based Gatekeepers with observation tracking</td><td>Hybrid isolate/container (via @cloudflare/computer)</td><td>Apache 2.0</td></tr><tr><td><strong>LangGraph</strong></td><td>Agent orchestration framework</td><td>None (delegated to deployer)</td><td>Python process</td><td>MIT</td></tr><tr><td><strong>CrewAI</strong></td><td>Multi-agent orchestration</td><td>None (delegated to deployer)</td><td>Python process</td><td>MIT</td></tr><tr><td><strong>Microsoft Agent Framework</strong></td><td>Agent runtime + orchestration</td><td>Agent Governance Toolkit (separate project)</td><td>.NET / Python process</td><td>MIT</td></tr><tr><td><strong>OpenClaw</strong></td><td>Self-hosted AI assistant</td><td>API key scoping</td><td>Container</td><td>MIT</td></tr><tr><td><strong>Claude Agent SDK</strong></td><td>Agent orchestration SDK</td><td>Sandbox + tool permissions</td><td>Managed sandbox</td><td>Proprietary (SDK open)</td></tr></tbody></table></figure>



<p class="wp-block-paragraph">The key distinction: LangGraph, CrewAI, and the <a href="https://rpabotsworld.com/microsoft-agent-framework-harness-hosted-agents-ga-guide/">Microsoft Agent Framework</a> are <em>orchestration</em> tools — they manage how agents plan, execute, and coordinate. Cloudflare OS is a <em>workspace</em> tool — it manages what agents can access, what they&#8217;ve seen, and where their outputs can go. These are complementary, not competitive. You could run a LangGraph agent inside a Cloudflare OS workspace and get the orchestration from LangGraph with the security and governance from Cloudflare OS.</p>



<p class="wp-block-paragraph">Microsoft&#8217;s <a href="https://github.com/microsoft/agent-governance-toolkit" target="_blank" rel="noopener nofollow">Agent Governance Toolkit</a> is the closest competitor in the security/governance space — it covers all 10 OWASP Agentic Top 10 risks with sub-millisecond policy enforcement. But it&#8217;s a governance <em>library</em> you integrate into your own runtime, not a complete workspace platform. Cloudflare OS bundles governance into the platform itself, which is an easier adoption path for organizations that don&#8217;t want to build their own agent infrastructure.</p>



<h2 class="wp-block-heading">What This Means for RPA and Automation Teams</h2>



<p class="wp-block-paragraph">If you&#8217;re an automation architect evaluating whether Cloudflare OS belongs on your radar, here&#8217;s the practical assessment:</p>



<p class="wp-block-paragraph"><strong>The governance model is production-ready for sensitive environments.</strong> The capability-based security, observation logging, and taint-tracking approach directly address the concerns that CISOs raise when automation teams request API access for agents. If your <a href="https://rpabotsworld.com/uipath-vs-automation-anywhere-vs-blue-prism-agentic-platforms-2026/">existing RPA platform</a> struggles with credential management at scale, Gatekeepers offer a fundamentally better pattern.</p>



<p class="wp-block-paragraph"><strong>The hybrid runtime reduces agent infrastructure cost.</strong> Enterprise automation teams running hundreds of attended and unattended agents will see meaningful cost savings from isolate-first execution. The 90/10 split between isolates and containers is realistic for most business-process automation workloads that don&#8217;t involve heavy document processing or desktop interaction.</p>



<p class="wp-block-paragraph"><strong>The Blueprint/Gadget model is citizen-developer-friendly.</strong> Non-technical users can build and share internal apps without deploying infrastructure. This directly competes with Microsoft Power Platform&#8217;s citizen-developer story, but with agent-native security built in rather than bolted on.</p>



<p class="wp-block-paragraph"><strong>The rough edges are real.</strong> The project launched 9 days ago. The v2 architecture is sound, but the ecosystem of pre-built Gatekeepers is limited, the self-hosting story outside Cloudflare&#8217;s own infrastructure is incomplete, and the documentation reflects an internal tool being open-sourced rather than a product designed for external adoption from day one. Early adopters should budget time for integration work.</p>



<h2 class="wp-block-heading">Getting Started: A Minimal Deployment</h2>



<p class="wp-block-paragraph">For teams that want to evaluate Cloudflare OS, the fastest path is through the official starter kit:</p>



<pre class="wp-block-code"><code># Clone the starter
git clone https://github.com/cloudflare/cloudflare-os-starter.git
cd cloudflare-os-starter

# Configure your deployment
# Edit wrangler.toml with your Cloudflare account details
# Set identity provider in Cloudflare Access

# Deploy — Wrangler creates KV namespaces and R2 bucket automatically
npx wrangler deploy
</code></pre>



<p class="wp-block-paragraph">The starter deploys Cloudflare Access mode for identity verification. You&#8217;ll need a Cloudflare account (free tier supports initial experimentation, but production workloads will require Workers Paid plan for Durable Objects and Dynamic Workers).</p>



<p class="wp-block-paragraph">For the <code>@cloudflare/computer</code> runtime specifically:</p>



<pre class="wp-block-code"><code>npm install @cloudflare/computer
</code></pre>



<p class="wp-block-paragraph">The package provides the virtual filesystem, workspace management, and all three execution backends. Documentation and examples are available in the <a href="https://github.com/cloudflare/computer" target="_blank" rel="noopener nofollow">GitHub repository</a>.</p>



<h2 class="wp-block-heading">Frequently Asked Questions</h2>



<h3 class="wp-block-heading">Is Cloudflare OS free to use?</h3>



<p class="wp-block-paragraph">The source code is free under Apache 2.0. However, running it requires Cloudflare infrastructure (Workers, Durable Objects, KV, R2), which has its own pricing. The free tier covers experimentation, but production deployments will incur Cloudflare platform costs. Community-built alternatives using Docker Compose exist for self-hosting on your own infrastructure, though with reduced feature parity.</p>



<h3 class="wp-block-heading">Can I use Cloudflare OS with models other than Cloudflare&#8217;s Workers AI?</h3>



<p class="wp-block-paragraph">Yes. Cloudflare OS is model-agnostic. The workspace connects to any LLM provider via API — Claude, GPT-4o, Gemini, DeepSeek, or any model accessible through a standard API endpoint. The community self-hosting project uses LiteLLM as a model proxy for multi-provider support.</p>



<h3 class="wp-block-heading">How does Cloudflare OS relate to MCP (Model Context Protocol)?</h3>



<p class="wp-block-paragraph">Cloudflare OS supports existing MCP servers through MCP Server Portals. It&#8217;s not a replacement for MCP — it&#8217;s a governance layer on top. Gatekeepers add observation tracking and policy enforcement that MCP&#8217;s current specification (including the <a href="https://rpabotsworld.com/mcp-2026-07-28-stateless-spec-agentic-ai-guide/">2026-07-28 stateless spec</a>) doesn&#8217;t cover. Organizations can use MCP servers inside Cloudflare OS without modification.</p>



<h3 class="wp-block-heading">Can I run existing RPA bots inside Cloudflare OS?</h3>



<p class="wp-block-paragraph">Not directly. Cloudflare OS is an agent workspace for LLM-based agents, not a traditional RPA runtime. However, Gatekeepers can connect to the same enterprise systems (SAP, Salesforce, ServiceNow) that RPA bots access, and the container backend in <code>@cloudflare/computer</code> can run any Linux-compatible automation tooling. Integration with existing RPA platforms would require building a Gatekeeper for the RPA platform&#8217;s API.</p>



<h3 class="wp-block-heading">What happened to the Cloudflare Agents SDK and Workers AI?</h3>



<p class="wp-block-paragraph">Cloudflare OS builds on top of Cloudflare&#8217;s existing developer platform — Workers, Durable Objects, Workers AI, and the Agents SDK are all underlying technologies. Cloudflare OS is the application layer that brings them together into a unified workspace with security governance. Think of it as the &#8220;finished product&#8221; that the underlying platform components enable.</p>



<h2 class="wp-block-heading">Key Takeaways</h2>



<ul class="wp-block-list">
<li><strong>Cloudflare OS is the first open-source agent platform to ship capability-based security with observation tracking</strong> — a fundamentally different approach than tool-level permissions that tracks what agents see, not just what they call.</li>



<li><strong>Gatekeepers solve the credential-management problem at scale</strong> by holding credentials, enforcing fine-grained policies, and logging every resource observation for downstream access control.</li>



<li><strong>@cloudflare/computer&#8217;s hybrid isolate/container runtime</strong> targets a 90/10 split that can dramatically reduce agent infrastructure costs compared to container-only approaches.</li>



<li><strong>Gadgets and Blueprints make agents productive for non-developers</strong> — every output can be a running application with its own state, shareable and modifiable without touching code.</li>



<li><strong>The platform is complementary to existing agent frameworks</strong> — you can run LangGraph, CrewAI, or any MCP-compatible agent inside Cloudflare OS and layer governance on top.</li>



<li><strong>It&#8217;s early.</strong> The architecture is sound and battle-tested internally at Cloudflare, but the open-source release is 9 days old. Budget for integration work and expect the Gatekeeper ecosystem to mature over the coming months.</li>
</ul>



<h2 class="wp-block-heading">External References</h2>



<ol class="wp-block-list">
<li>Cloudflare Blog — <a href="https://blog.cloudflare.com/cloudflare-os/" target="_blank" rel="noopener nofollow">&#8220;Cloudflare OS: an open platform for agents, apps, and work&#8221;</a> (August 5, 2026)</li>



<li>Cloudflare Blog — <a href="https://blog.cloudflare.com/cloudflare-computer/" target="_blank" rel="noopener nofollow">&#8220;Your agent needs a computer, not a container — introducing @cloudflare/computer&#8221;</a> (August 3, 2026)</li>



<li>GitHub — <a href="https://github.com/cloudflare/cloudflare-os" target="_blank" rel="noopener nofollow">cloudflare/cloudflare-os</a> (Apache 2.0)</li>



<li>GitHub — <a href="https://github.com/cloudflare/computer" target="_blank" rel="noopener nofollow">cloudflare/computer</a> (MIT)</li>



<li>InfoQ — <a href="https://www.infoq.com/news/2026/08/cloudflare-computer-agents/" target="_blank" rel="noopener nofollow">&#8220;Cloudflare Launches Persistent, Stateful, Computer-Like Environments for Agents&#8221;</a> (August 2026)</li>



<li>Cloudflare Developers — <a href="https://developers.cloudflare.com/changelog/post/2026-08-03-cloudflare-computer/" target="_blank" rel="noopener nofollow">@cloudflare/computer agent runtime changelog</a></li>



<li>Decrypt — <a href="https://decrypt.co/374997/cloudflare-os-inside-open-source-ai-agent-platform" target="_blank" rel="noopener nofollow">&#8220;Cloudflare OS: Here&#8217;s What&#8217;s Inside the Open-Source AI Agent Platform&#8221;</a></li>



<li>Help Net Security — <a href="https://www.helpnetsecurity.com/2026/08/06/cloudflare-os-open-source/" target="_blank" rel="noopener nofollow">&#8220;Cloudflare OS goes open source with a record of everything its agents read&#8221;</a></li>



<li>Microsoft Open Source Blog — <a href="https://opensource.microsoft.com/blog/2026/04/02/introducing-the-agent-governance-toolkit-open-source-runtime-security-for-ai-agents/" target="_blank" rel="noopener nofollow">&#8220;Introducing the Agent Governance Toolkit&#8221;</a> (April 2, 2026)</li>



<li>Hacker News Discussion — <a href="https://news.ycombinator.com/item?id=49182996" target="_blank" rel="noopener nofollow">Cloudflare OS announcement thread</a></li>
</ol>



<p class="wp-block-paragraph"><em>Next steps: Run the <a href="https://rpabotsworld.com/top-trending-open-source-agentic-ai-repos/">full open-source agentic AI landscape</a> alongside this deep dive to see where Cloudflare OS fits in the broader ecosystem. For teams already running agentic workloads on <a href="https://rpabotsworld.com/microsoft-agent-framework-harness-hosted-agents-ga-guide/">Microsoft&#8217;s Agent Framework</a> or exploring <a href="https://rpabotsworld.com/meta-muse-glimmer-30b-local-agentic-ai-guide/">self-hosted models like Meta Muse Glimmer</a>, Cloudflare OS adds the missing governance layer that those frameworks leave to the deployer.</em></p>



<p class="wp-block-paragraph"></p>
]]></content:encoded>
					
					<wfw:commentRss>https://rpabotsworld.com/cloudflare-os-open-source-agent-platform-guide/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>Y Combinator QM: The Open-Source Multiplayer Agent Harness That Runs YC Itself (2026 Deep Dive)</title>
		<link>https://rpabotsworld.com/yc-qm-open-source-multiplayer-agent-harness-guide/</link>
					<comments>https://rpabotsworld.com/yc-qm-open-source-multiplayer-agent-harness-guide/#respond</comments>
		
		<dc:creator><![CDATA[Satish Prasad]]></dc:creator>
		<pubDate>Fri, 14 Aug 2026 16:23:15 +0000</pubDate>
				<category><![CDATA[Agentic AI & AI Automation]]></category>
		<category><![CDATA[Multi-Agent Systems]]></category>
		<category><![CDATA[Open-Source Agents]]></category>
		<guid isPermaLink="false">https://rpabotsworld.com/?p=32295</guid>

					<description><![CDATA[Y Combinator open-sourced QM, the multiplayer agent harness it runs internally. Architecture, security model, deployment guide, and how it compares to…]]></description>
										<content:encoded><![CDATA[
<p class="wp-block-paragraph">On July 31, 2026, Y Combinator did something unusual: it open-sourced the internal AI system it uses to run its own company. <a href="https://github.com/yc-software/qm" target="_blank" rel="noopener nofollow">QM</a> (short for Quartermaster) is not another chatbot wrapper or prompt-chaining library. It is a <strong>multiplayer agent harness</strong> — a production runtime that gives every employee in an organization their own isolated AI workspace with scoped memory, files, credentials, scheduled jobs, and a durable sandbox, while still letting them collaborate with the same agent in Slack channels, group messages, and projects.</p>



<p class="wp-block-paragraph">The repository hit 650+ points on Hacker News the day it dropped, crossed 7,000 GitHub stars inside three days, and sits above 13,000 stars two weeks later. YC says it runs QM across accounting, legal, events, and engineering — including building QM itself — and calls the release &#8220;early and buggy,&#8221; which, in YC tradition, means production-tested enough to ship.</p>



<p class="wp-block-paragraph">For RPA professionals and agentic AI architects, QM matters because it occupies a category most enterprise platforms have not clearly addressed: <strong>company-wide agent orchestration with per-user isolation</strong>. UiPath, Automation Anywhere, and Power Automate all offer attended and unattended bot infrastructure, but none of them ship a Slack-native, harness-agnostic runtime where each employee&#8217;s agent context is scoped and sandboxed by default. QM fills that gap — and it does so under the MIT license.</p>



<p class="wp-block-paragraph">This guide breaks down QM&#8217;s architecture, security model, deployment mechanics, and where it fits in the broader landscape of <a href="https://rpabotsworld.com/rpa-to-agentic-ai-transition-guide/">RPA-to-agentic-AI transitions</a> — with enough technical depth that you can decide whether to deploy it, fork it, or steal its design patterns for your own automation platform.</p>



<h2 class="wp-block-heading">What Problem Does QM Actually Solve?</h2>



<p class="wp-block-paragraph">Most AI agents are designed as personal assistants. You prompt them, they respond, and the context window resets or leaks depending on the vendor. When organizations try to scale a single assistant across an entire company, complexity explodes. Different departments need different tools, different credentials, different memory, and different permission boundaries — but they also need to collaborate through the same agent in shared channels.</p>



<p class="wp-block-paragraph">QM&#8217;s README frames this directly: &#8220;You can make one work for a whole company, but it quickly gets complex.&#8221; The solution is a harness that treats <strong>scope isolation</strong> as a first-class primitive. Every person and every Slack room gets its own:</p>



<ul class="wp-block-list">
<li><strong>Scoped memory</strong> — the agent remembers context per user and per room, not globally</li>



<li><strong>Files</strong> — each scope has its own file store that other scopes cannot access</li>



<li><strong>Keychain view</strong> — credentials are scoped so the legal team&#8217;s API keys never leak into the engineering agent&#8217;s context</li>



<li><strong>Permissions</strong> — admins set org-level defaults; narrower scopes can only tighten them, never loosen</li>



<li><strong>Crons and watches</strong> — scheduled background jobs per scope, not per organization</li>



<li><strong>Web apps</strong> — the agent can spin up custom internal apps scoped to the right people</li>



<li><strong>Durable sandbox</strong> — an isolated compute environment where installed tools persist between sessions</li>
</ul>



<p class="wp-block-paragraph">This is fundamentally different from both personal coding agents (Claude Code, Codex, OpenCode) and enterprise RPA bots. A personal coding agent is a single-player tool. An <a href="https://rpabotsworld.com/uipath-vs-automation-anywhere-vs-blue-prism-agentic-platforms-2026/">enterprise RPA platform</a> manages unattended bots at scale but does not give each human employee a persistent, memory-rich AI workspace. QM sits between these worlds.</p>



<figure class="wp-block-image size-full"><img decoding="async" width="2200" height="1467" src="https://rpabotsworld.com/wp-content/uploads/2026/08/yc-qm-open-source-multiplayer-agent-harness-guide-architecture-diagram.png" alt="Y Combinator QM: The Open-Source Multiplayer Agent Harness That Runs YC Itself (2026 Deep Dive) 1" class="wp-image-32301" title="Y Combinator QM: The Open-Source Multiplayer Agent Harness That Runs YC Itself (2026 Deep Dive) 2"></figure>



<h2 class="wp-block-heading">Architecture: How QM Works Under the Hood</h2>



<p class="wp-block-paragraph">QM&#8217;s architecture is clean enough to diagram in one frame. Every turn runs through a <strong>headless core</strong> that handles four concerns: API routing, identity resolution, policy enforcement, and job scheduling. The core drives an <strong>agent loop</strong> that can use any supported harness — Pi, OpenCode, Codex, or Claude Code — to generate responses.</p>



<h3 class="wp-block-heading">The Core</h3>



<p class="wp-block-paragraph">The core is a TypeScript application running directly on Node.js with <a href="https://fastify.dev/" target="_blank" rel="noopener nofollow">Fastify</a> for HTTP. It is intentionally generic: everything specific to a particular organization — config, custom tools, sandbox images, infrastructure wiring — lives in a separate <strong>deployment directory</strong> that the <code>qm</code> CLI validates and deploys. This separation means the core can evolve upstream without breaking org-specific customizations.</p>



<p class="wp-block-paragraph">Every substrate (harness, session store, sandbox, memory) sits behind an interface. Production implementations swap in via one wiring file. This is the same dependency-inversion pattern that enterprise Java developers have used for decades, but applied to AI agent infrastructure — and it is what makes QM harness-agnostic.</p>



<h3 class="wp-block-heading">Persistence Layer</h3>



<p class="wp-block-paragraph">A <strong>PostgreSQL</strong> database holds sessions, memory, user data, and a durable job queue. This is a deliberate choice: Postgres is battle-tested, widely hosted, and its transactional guarantees matter when you are managing per-scope state that the agent modifies during execution. There is no vector database in the core architecture — memory is scope-isolated and session-based, not a global RAG index.</p>



<h3 class="wp-block-heading">The Agent Loop</h3>



<p class="wp-block-paragraph">The agent has a small, fixed tool surface. One of those tools is <code>execute</code>, which runs commands in the scope&#8217;s own isolated sandbox. The sandbox is durable: installed tools stay installed between sessions. This means an accounting agent can have <code>csvkit</code> and custom Python scripts permanently available, while an engineering agent has <code>git</code>, <code>npm</code>, and a full build toolchain — without either scope polluting the other.</p>



<h3 class="wp-block-heading">Plugins</h3>



<p class="wp-block-paragraph">The web UI, admin panel, and public portal are <strong>optional plugins</strong> over the core&#8217;s HTTP API. Slack integration uses the Bolt framework and runs as an in-process plugin that the core starts and supervises through a direct service client. The web UI builds with Vite and renders with <a href="https://lit.dev/" target="_blank" rel="noopener nofollow">Lit</a> (not React — an uncommon but deliberate choice for performance and bundle size).</p>



<p class="wp-block-paragraph">This plugin architecture means you can run QM as a Slack-only agent, a web-only agent, or both — and add custom surfaces without touching the core.</p>



<h2 class="wp-block-heading">Harness Agnosticism: Why It Matters</h2>



<p class="wp-block-paragraph">A May 2026 study by MBZUAI, analyzing Claude Code&#8217;s source code, quantified that approximately 98.4% of a production agent is harness infrastructure — permissions, context management, sandboxing, tool routing, recovery — and only about 1.6% is AI decision logic. Google&#8217;s Addy Osmani further noted that harness design alone can create up to 6x performance variation on the same model.</p>



<p class="wp-block-paragraph">These findings explain QM&#8217;s design philosophy. By abstracting the harness behind an interface, QM lets organizations swap between Pi, OpenCode, Codex, and Claude Code without rewriting their agent infrastructure. A deployment is not tied to any single vendor, which matters enormously for enterprises evaluating cost, latency, and capability trade-offs across rapidly evolving model providers.</p>



<p class="wp-block-paragraph">For RPA teams accustomed to vendor lock-in — where migrating from UiPath to Automation Anywhere means rewriting every workflow — this is a radical departure. QM&#8217;s harness-agnostic architecture is conceptually closer to what the <a href="https://rpabotsworld.com/what-is-mcp-server-ai-agents/">Model Context Protocol (MCP)</a> aims to do for tool connectivity: establish a standard interface so that the infrastructure layer outlives any individual model or vendor.</p>



<h2 class="wp-block-heading">Security Model: Three Postures, One Hard Floor</h2>



<p class="wp-block-paragraph">QM follows the security pattern of local coding agents: the agent acts as the person it works for, with their credentials and permissions, and everything it does is audited. But it adds org-level governance that personal agents lack.</p>



<p class="wp-block-paragraph">An organization picks one of three security postures, which narrower scopes can only tighten:</p>



<figure class="wp-block-table"><table class="has-fixed-layout"><thead><tr><th>Posture</th><th>Behavior</th><th>Best For</th></tr></thead><tbody><tr><td><strong>Strict</strong></td><td>Every harness tool call pauses for human approval, except two no-effect turn enders</td><td>Regulated industries, early deployments, compliance-sensitive teams</td></tr><tr><td><strong>Auto</strong> (default)</td><td>A classifier screens provenance-labeled external data and tool results before they reach the model; deployments can point the classifier at their own screening proxy</td><td>Most organizations — balances productivity with safety</td></tr><tr><td><strong>Dangerous</strong></td><td>No content screening, no pauses between tool calls</td><td>Development sandboxes, internal tooling teams with high trust</td></tr></tbody></table></figure>



<p class="wp-block-paragraph">Critically, a <strong>predeclared command policy</strong> applies in every posture, including Dangerous. This policy enforces approval rules and hard denials for destructive operations — recursive deletes, destructive SQL, and similar irreversible actions. Think of it as the guardrails that never come off, regardless of how much autonomy you grant the agent.</p>



<p class="wp-block-paragraph">For agentic AI architects coming from an RPA background, this model will feel familiar. UiPath Orchestrator separates robot permissions from process-level governance. QM does something analogous but at the agent-turn level rather than the process-execution level: every tool call is evaluated against the posture and the command policy before it runs.</p>



<h2 class="wp-block-heading">Skills System: Org-Wide Knowledge, Scope-Level Control</h2>



<p class="wp-block-paragraph">QM&#8217;s <strong>skills</strong> are reusable capabilities that can be authored per scope, shared by explicit grant, and promoted org-wide through admin approval. Skill packs can also be imported from git repositories, which means an organization can maintain a curated library of approved agent capabilities versioned in source control.</p>



<p class="wp-block-paragraph">This is where QM overlaps most directly with enterprise RPA concepts. In UiPath, reusable automation components live in libraries published to Orchestrator. In Automation Anywhere, they are <em>bot packages</em> in the Control Room. QM&#8217;s skill system serves the same purpose — standardizing and governing reusable agent capabilities — but operates at the LLM-agent level rather than the RPA-workflow level.</p>



<p class="wp-block-paragraph">The skill lifecycle follows a deliberate escalation path:</p>



<ol class="wp-block-list">
<li>An individual creates a skill in their personal scope</li>



<li>They share it with specific colleagues by grant</li>



<li>An admin reviews and promotes it to the entire organization</li>



<li>External skill packs from git repos can be imported and governed through the same flow</li>
</ol>



<p class="wp-block-paragraph">This mirrors the governance patterns that mature RPA Centers of Excellence have built over years — review, approve, publish, version — applied to a fundamentally different kind of automation primitive.</p>



<h2 class="wp-block-heading">Deployment: Your Cloud, Your Data</h2>



<p class="wp-block-paragraph">QM deploys to the operator&#8217;s own cloud account. There is no hosted SaaS tier. The <code>qm init</code> CLI command scaffolds a deployment repository targeting either Fly.io or AWS, then walks through infrastructure setup, web sign-in configuration, connector credentials, optional Slack access, and live verification.</p>



<p class="wp-block-paragraph">Sign-in defaults to a built-in broker that emails a one-time link. An external identity provider (Okta, Azure AD, Google Workspace) can replace it. Each deployment runs in isolation — QM does not phone home, and Y Combinator does not see your data.</p>



<p class="wp-block-paragraph">For organizations that want deeper customization, QM supports a <strong>private fork</strong> pattern: a plain clone (not a GitHub Fork) of the repo that keeps the core byte-identical to upstream while allowing org-specific customizations in <code>deploy/layers/&lt;org&gt;/</code>. Two built-in skills maintain the boundary: <code>update-qm</code> merges upstream changes in, and <code>upstream-pr</code> sends org-agnostic fixes back — checking outgoing diffs for org identifiers before pushing.</p>



<p class="wp-block-paragraph">The realistic deployment target is a startup or mid-sized company (roughly 10–500 people) with at least one platform engineer comfortable with infrastructure. Larger enterprises can run it but should audit the security model first — the <a href="https://github.com/yc-software/qm/blob/main/SECURITY.md" target="_blank" rel="noopener nofollow">SECURITY.md</a> file lays out the threat model, operator assumptions, and known limitations.</p>



<h2 class="wp-block-heading">QM vs. the Landscape: Where Does It Fit?</h2>



<p class="wp-block-paragraph">The agent tooling ecosystem in 2026 has three distinct layers, and QM occupies a specific spot in each.</p>



<h3 class="wp-block-heading">Agent Harness vs. Agent Framework</h3>



<p class="wp-block-paragraph">An <strong>agent framework</strong> (LangGraph, CrewAI, AutoGen/AG2, Mastra) defines agent logic, routing, and tool wiring. An <strong>agent harness</strong> (Claude Code, OpenCode, Codex, QM) is the production runtime that wraps a model to add tool execution, state management, guardrails, and observability. You can combine both — a framework-built agent can use a harness for infrastructure — but they solve different problems at different stages.</p>



<h3 class="wp-block-heading">Single-Player vs. Multiplayer Harnesses</h3>



<p class="wp-block-paragraph">Claude Code, OpenCode, and Codex are single-player harnesses: one developer, one session, one sandbox. QM is a <strong>multiplayer harness</strong>: many users, many scoped sessions, shared collaboration surfaces, org-level governance. The closest comparator is <a href="https://en.wikipedia.org/wiki/OpenClaw" target="_blank" rel="noopener nofollow">OpenClaw</a> (382k+ stars), which also provides company-wide agent capabilities — but OpenClaw&#8217;s architecture is more personal-assistant-oriented, while QM&#8217;s scope isolation and Slack-native design target team-level workflows.</p>



<h3 class="wp-block-heading">QM vs. Enterprise RPA Platforms</h3>



<figure class="wp-block-table"><table class="has-fixed-layout"><thead><tr><th>Capability</th><th>QM</th><th>UiPath Orchestrator</th><th>Automation Anywhere Control Room</th></tr></thead><tbody><tr><td>Primary automation type</td><td>LLM agent (text/code)</td><td>RPA bots (UI/API)</td><td>RPA bots (UI/API)</td></tr><tr><td>Per-user isolation</td><td>Scoped memory, files, sandbox per person/room</td><td>Robot accounts with folder-level access</td><td>Bot Runner with role-based access</td></tr><tr><td>Model/harness flexibility</td><td>Pi, OpenCode, Codex, Claude Code (swap freely)</td><td>UiPath Autopilot (tied to UiPath AI)</td><td>AA AI Agent Studio (tied to AA models)</td></tr><tr><td>Collaboration surface</td><td>Slack channels, web UI, projects</td><td>Orchestrator dashboard, Action Center</td><td>Control Room, AARI</td></tr><tr><td>Background jobs</td><td>Per-scope crons and watches</td><td>Scheduled triggers, queue-based</td><td>Scheduled triggers, queue-based</td></tr><tr><td>Governance</td><td>Three security postures + command policy</td><td>Role-based access + governance policies</td><td>Role-based access + governance policies</td></tr><tr><td>Deployment</td><td>Self-hosted (Fly.io / AWS), MIT license</td><td>Cloud/on-prem, commercial license</td><td>Cloud/on-prem, commercial license</td></tr><tr><td>Cost</td><td>Free (MIT) + infrastructure + model API costs</td><td>Commercial licensing per robot</td><td>Commercial licensing per runner</td></tr></tbody></table></figure>



<p class="wp-block-paragraph">The key insight: QM is not a replacement for UiPath or Automation Anywhere. It operates in a different layer. RPA platforms excel at deterministic, high-volume process automation — invoice processing, data entry, system migrations. QM excels at <strong>knowledge work augmentation</strong> — searching documents, drafting communications, triaging inboxes, tracking projects, building internal tools. The most capable organizations will run both: RPA for structured processes, QM (or a similar harness) for unstructured agent work.</p>



<h2 class="wp-block-heading">Real-World Use Cases YC Runs on QM</h2>



<p class="wp-block-paragraph">Y Combinator&#8217;s own usage provides concrete examples of what company-wide agent deployment looks like in practice:</p>



<h3 class="wp-block-heading">Accounting and Legal</h3>



<p class="wp-block-paragraph">Financial teams search internal notes, email, documents, and databases together through the agent. Legal operations use scoped memory to maintain case context across sessions without leaking privileged information between matters. The keychain-per-scope model means financial API credentials never surface in an engineering channel.</p>



<h3 class="wp-block-heading">Events and Operations</h3>



<p class="wp-block-paragraph">QM tracks projects in shared Slack channels, posting updates and follow-ups automatically. Crons run background monitoring — checking event logistics, vendor status, and deadlines — and surface issues before humans need to ask.</p>



<h3 class="wp-block-heading">Engineering</h3>



<p class="wp-block-paragraph">Engineering teams work in existing repositories: running tests, opening PRs, monitoring CI, and checking system logs. The durable sandbox means a developer&#8217;s agent remembers their project setup, installed tools, and environment configuration between sessions. YC builds QM itself using QM.</p>



<h3 class="wp-block-heading">Inbox Triage</h3>



<p class="wp-block-paragraph">QM learns a user&#8217;s writing voice from past sends, then triages their inbox on a schedule — applying labels and drafting replies. This runs as a per-user cron, not a shared process, so each person&#8217;s triage rules and voice model are private.</p>



<h2 class="wp-block-heading">How to Evaluate QM for Your Organization</h2>



<p class="wp-block-paragraph">Before deploying QM, run through this checklist:</p>



<figure class="wp-block-table"><table class="has-fixed-layout"><thead><tr><th>Question</th><th>If Yes</th><th>If No</th></tr></thead><tbody><tr><td>Do you have a platform engineer who can manage Postgres + Fly.io/AWS?</td><td>Proceed</td><td>QM is not turnkey — consider a managed alternative</td></tr><tr><td>Do 10+ employees need AI agent access with different contexts?</td><td>QM&#8217;s multiplayer model pays off</td><td>A single-player harness may suffice</td></tr><tr><td>Is Slack your primary collaboration tool?</td><td>QM&#8217;s Slack-native design is a natural fit</td><td>Web-only mode works, but you lose the collaboration surface</td></tr><tr><td>Do you need to control which models/harnesses are available?</td><td>QM&#8217;s admin controls and harness agnosticism help</td><td>Any personal agent will work</td></tr><tr><td>Are you in a regulated industry requiring audit trails?</td><td>QM&#8217;s security postures and auditing are designed for this</td><td>Still useful, but less differentiating</td></tr><tr><td>Do you already run RPA for structured processes?</td><td>QM complements RPA for unstructured knowledge work</td><td>QM alone can handle agent-level automation</td></tr></tbody></table></figure>



<h2 class="wp-block-heading">Getting Started: The Minimum Viable Deployment</h2>



<p class="wp-block-paragraph">The fastest path to a running QM instance does not require cloning the repository:</p>



<pre class="wp-block-code"><code># Create an org-owned deployment repo
npm exec --yes --package=@yc-software/qm@latest -- \
  qm init . --org your-company --target fly

# Install dependencies
npm install

# The init command materializes a deployment skill that walks through:
# 1. Infrastructure setup (Postgres, compute)
# 2. Web sign-in configuration (built-in broker or external IdP)
# 3. Connector credentials (for services the agent will access)
# 4. Optional Slack app access
# 5. Deployment and live verification</code></pre>



<p class="wp-block-paragraph">The <code>qm init</code> command scaffolds a deployment directory with all the configuration needed. The deployment skill then guides you through each step interactively. For the full walkthrough, see the official <a href="https://github.com/yc-software/qm/blob/main/docs/getting-started.md" target="_blank" rel="noopener nofollow">getting-started.md</a> and <a href="https://github.com/yc-software/qm/blob/main/deployment.md" target="_blank" rel="noopener nofollow">deployment.md</a> in the repository.</p>



<h2 class="wp-block-heading">What QM Gets Right — and Where It Falls Short</h2>



<h3 class="wp-block-heading">Strengths</h3>



<p class="wp-block-paragraph"><strong>Scope isolation is the right default.</strong> Most organizations that have tried deploying a shared AI agent hit the same wall: context pollution. One team&#8217;s instructions bleed into another team&#8217;s sessions. QM solves this architecturally, not through prompting tricks.</p>



<p class="wp-block-paragraph"><strong>Harness agnosticism protects your investment.</strong> The AI model landscape shifts quarterly. Being locked to one vendor&#8217;s agent runtime is the 2026 equivalent of being locked to one RPA vendor&#8217;s workflow engine in 2018. QM&#8217;s interface-based substrate design means you can swap harnesses as the market evolves.</p>



<p class="wp-block-paragraph"><strong>The skill system mirrors enterprise governance patterns.</strong> Create → share → review → promote is the same lifecycle that RPA Centers of Excellence built for bot libraries. QM applies it to agent capabilities with git-backed skill packs as a bonus.</p>



<p class="wp-block-paragraph"><strong>Self-hosted by design.</strong> No data leaves your infrastructure. For healthcare, legal, financial services, and defense organizations, this is not a feature — it is a requirement.</p>



<h3 class="wp-block-heading">Limitations</h3>



<p class="wp-block-paragraph"><strong>YC calls it &#8220;early and buggy.&#8221;</strong> This is production software at YC, but it has not been battle-tested across thousands of organizations. Expect rough edges, incomplete documentation for advanced scenarios, and breaking changes as the project matures.</p>



<p class="wp-block-paragraph"><strong>Contributions must be human-written text, not code.</strong> QM&#8217;s CONTRIBUTING.md explicitly requires that contributions come as informal descriptions in <code>.txt</code> or <code>.md</code> files — the YC team handles implementation. This is an unusual model that may slow community-driven development.</p>



<p class="wp-block-paragraph"><strong>No GUI workflow builder.</strong> RPA platforms provide visual workflow designers. QM is entirely code-and-prompt-driven. If your automation team relies on low-code/no-code tooling, QM requires a mindset shift.</p>



<p class="wp-block-paragraph"><strong>Slack dependency for the best experience.</strong> QM works without Slack via the web UI, but the multiplayer collaboration features are designed around Slack channels and messages. Teams on Microsoft Teams or Discord would need to build their own surface plugin.</p>



<h2 class="wp-block-heading">The Bigger Picture: Agent Harnesses as Enterprise Infrastructure</h2>



<p class="wp-block-paragraph">QM&#8217;s release signals a broader trend. In 2024, the agentic AI conversation centered on frameworks — LangChain, AutoGen, CrewAI. By mid-2026, the conversation has shifted to <strong>harnesses</strong>: the production infrastructure that makes agents safe, observable, and manageable at organizational scale.</p>



<p class="wp-block-paragraph">The emerging stack looks like this:</p>



<ol class="wp-block-list">
<li><strong>Models</strong> (GPT-5.x, Claude Opus/Sonnet 5, Gemini 3.x, open-weight models like Muse Glimmer) provide the reasoning engine</li>



<li><strong>Frameworks</strong> (LangGraph, CrewAI, Mastra) define multi-agent logic and routing</li>



<li><strong>Harnesses</strong> (QM, Claude Code, OpenCode, Codex, OpenClaw) provide the production runtime — sandboxing, permissions, state, observability</li>



<li><strong>Connectivity standards</strong> (<a href="https://rpabotsworld.com/mcp-2026-07-28-stateless-spec-agentic-ai-guide/">MCP</a>, A2A) standardize how agents discover and call tools</li>



<li><strong>Observability</strong> (Langfuse, LangSmith, OpenTelemetry) provide the monitoring layer</li>
</ol>



<p class="wp-block-paragraph">For organizations already running RPA, the practical implication is clear: your existing RPA infrastructure handles deterministic, high-volume process automation. Agent harnesses like QM handle the unstructured, judgment-intensive knowledge work that RPA was never designed for. The two are complementary, not competitive.</p>



<p class="wp-block-paragraph">The organizations that move fastest will be those that treat agent harness selection with the same rigor they applied to RPA platform selection five years ago: evaluating security models, governance capabilities, vendor independence, deployment flexibility, and total cost of ownership. QM&#8217;s open-source, self-hosted, harness-agnostic design gives it a structural advantage on most of those criteria — at the cost of requiring more engineering investment to deploy and maintain.</p>



<h2 class="wp-block-heading">Frequently Asked Questions</h2>



<h3 class="wp-block-heading">Is QM free to use?</h3>



<p class="wp-block-paragraph">QM&#8217;s source code is MIT-licensed and free. You pay for your own cloud infrastructure (Fly.io or AWS), Postgres hosting, and model API costs (OpenAI, Anthropic, etc., depending on which harness and model you configure). There is no per-seat or per-agent license fee from Y Combinator.</p>



<h3 class="wp-block-heading">Can QM replace our existing RPA platform?</h3>



<p class="wp-block-paragraph">No — and it is not designed to. QM handles knowledge work augmentation (document search, inbox triage, project tracking, internal app generation). RPA platforms handle deterministic process automation (data entry, invoice processing, system integration). Most organizations will run both, with QM covering the unstructured work that RPA cannot reach.</p>



<h3 class="wp-block-heading">Which LLM models does QM support?</h3>



<p class="wp-block-paragraph">QM is harness-agnostic. It supports any model accessible through its supported harnesses: Pi, OpenCode, Codex, and Claude Code. Through these harnesses, you can use OpenAI (GPT-5.x), Anthropic (Claude), Google (Gemini), DeepSeek, Kimi, or custom local models. Swapping between them does not require rewriting your agent configuration.</p>



<h3 class="wp-block-heading">How does QM compare to OpenClaw?</h3>



<p class="wp-block-paragraph">OpenClaw (382k+ GitHub stars) is the most popular open-source agent platform, but it is architecturally a personal assistant that connects to 50+ tools. QM is a multiplayer harness designed for company-wide deployment with per-user/per-room isolation, admin governance, and Slack-native collaboration. Choose OpenClaw for individual productivity; choose QM for team-level agent infrastructure.</p>



<h3 class="wp-block-heading">Is QM production-ready for enterprise deployment?</h3>



<p class="wp-block-paragraph">QM is production-tested at Y Combinator, but YC itself describes it as &#8220;early and buggy.&#8221; It is mature enough for startups and mid-sized companies (10–500 people) with engineering support. Large enterprises should pilot it in a limited scope and audit the security model (documented in SECURITY.md) before broad deployment.</p>



<h2 class="wp-block-heading">Key Takeaways</h2>



<ul class="wp-block-list">
<li><strong>QM is the first open-source multiplayer agent harness</strong> designed for company-wide deployment, not personal use. Every user and every Slack room gets isolated memory, files, credentials, crons, and a durable sandbox.</li>



<li><strong>Harness agnosticism prevents vendor lock-in.</strong> Pi, OpenCode, Codex, and Claude Code all plug into the same core, so organizations can swap models and harnesses without rewriting infrastructure.</li>



<li><strong>The security model adds enterprise governance</strong> that personal coding agents lack: three postures (Strict, Auto, Dangerous) with a hard floor of command-policy denials that apply in all modes.</li>



<li><strong>QM complements RPA, it does not replace it.</strong> Use QM for unstructured knowledge work (search, triage, drafting, project tracking). Use RPA for deterministic process automation (data entry, invoice processing, system integration).</li>



<li><strong>MIT-licensed and self-hosted.</strong> No data leaves your infrastructure, no per-seat fees, no vendor lock-in — but you need at least one platform engineer to deploy and maintain it.</li>



<li><strong>The skill system mirrors RPA Center of Excellence governance</strong>: create, share by grant, admin-promote to org, import skill packs from git. Mature RPA teams will recognize the pattern instantly.</li>



<li><strong>Best fit today:</strong> startups and mid-sized companies (10–500 people) using Slack, with at least one engineer comfortable managing Postgres and cloud infrastructure.</li>
</ul>



<h2 class="wp-block-heading">External References</h2>



<ol class="wp-block-list">
<li><a href="https://github.com/yc-software/qm" target="_blank" rel="noopener nofollow">QM GitHub Repository</a> — MIT-licensed source code, README, and documentation</li>



<li><a href="https://qm.ycombinator.com/" target="_blank" rel="noopener nofollow">QM Official Project Page</a> — Y Combinator&#8217;s landing page for QM</li>



<li><a href="https://github.com/yc-software/qm/blob/main/SECURITY.md" target="_blank" rel="noopener nofollow">QM SECURITY.md</a> — Threat model, operator assumptions, and known limitations</li>



<li><a href="https://github.com/yc-software/qm/blob/main/docs/getting-started.md" target="_blank" rel="noopener nofollow">QM Getting Started Guide</a> — End-to-end first run documentation</li>



<li><a href="https://www.marktechpost.com/2026/08/03/y-combinator-open-sources-qm-multiplayer-ai-agent-harness/" target="_blank" rel="noopener nofollow">MarkTechPost: Y Combinator Open-Sources QM</a> — Coverage of the QM release (August 3, 2026)</li>



<li><a href="https://startupfortune.com/y-combinator-open-sources-qm-the-ai-agent-harness-it-uses-to-run-itself/" target="_blank" rel="noopener nofollow">Startup Fortune: Y Combinator Open-Sources QM</a> — Analysis of QM&#8217;s deployability and target audience</li>



<li><a href="https://the-agent-report.com/2026/08/yc-qm-open-source-multiplayer-agent-harness/" target="_blank" rel="noopener nofollow">The Agent Report: YC Open-Sources QM</a> — Deep analysis of QM&#8217;s architecture and reception</li>



<li><a href="https://www.explainx.ai/blog/y-combinator-qm-open-source-multi-agent-harness-august-2026" target="_blank" rel="noopener nofollow">ExplainX: YC QM Open-Source Multi-Agent Harness</a> — Technical overview and deployment guide</li>



<li><a href="https://atlan.com/know/ai-agent/agent-harness-vs-agent-framework/" target="_blank" rel="noopener nofollow">Atlan: Agent Harness vs Agent Framework</a> — The distinction between harnesses and frameworks (2026)</li>



<li><a href="https://www.mindstudio.ai/blog/agent-harness-vs-framework-difference" target="_blank" rel="noopener nofollow">MindStudio: Agent Harness vs Framework</a> — Framework for understanding where harnesses fit in the agent stack</li>
</ol>
]]></content:encoded>
					
					<wfw:commentRss>https://rpabotsworld.com/yc-qm-open-source-multiplayer-agent-harness-guide/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>The Universal Commerce Protocol: Google&#8217;s Open-Source Standard for the Agentic Commerce Era</title>
		<link>https://rpabotsworld.com/universal-commerce-protocol/</link>
					<comments>https://rpabotsworld.com/universal-commerce-protocol/#respond</comments>
		
		<dc:creator><![CDATA[Satish Prasad]]></dc:creator>
		<pubDate>Sun, 18 Jan 2026 16:00:59 +0000</pubDate>
				<category><![CDATA[Agentic AI & AI Automation]]></category>
		<category><![CDATA[Open-Source Agents]]></category>
		<guid isPermaLink="false">https://rpabotsworld.com/?p=31939</guid>

					<description><![CDATA[Solving Commerce&#8217;s N x N Problem Picture every retailer trying to connect with every potential sales channel individually—Walmart building custom integrations for Google&#8217;s AI, Shopify for Amazon&#8217;s Alexa, Target for whatever comes next. This &#8220;N x N&#8221; integration bottleneck has stifled innovation for years, forcing businesses to choose between supporting new technologies and maintaining existing [&#8230;]]]></description>
										<content:encoded><![CDATA[
<h2 class="wp-block-heading">Solving Commerce&#8217;s N x N Problem</h2>



<p class="wp-block-paragraph">Picture every retailer trying to connect with every potential sales channel individually—Walmart building custom integrations for Google&#8217;s AI, Shopify for Amazon&#8217;s Alexa, Target for whatever comes next. This &#8220;N x N&#8221; integration bottleneck has stifled innovation for years, forcing businesses to choose between supporting new technologies and maintaining existing infrastructure. Today, <strong>Google&#8217;s Universal Commerce Protocol (UCP)</strong> emerges as the solution to this fundamental challenge, providing the missing connective tissue for the next generation of commerce.</p>



<p class="wp-block-paragraph">Developed collaboratively with industry leaders including <strong>Shopify, Etsy, Wayfair, Target, and Walmart</strong>, and endorsed by over 20 global partners from <strong>Adyen to Zalando</strong>, UCP represents a paradigm shift in how commerce systems communicate. It&#8217;s not just another API—it&#8217;s an <strong>open-source standard</strong> designed to create a common language for the entire commerce ecosystem as we transition into the agentic era.</p>



<h2 class="wp-block-heading">What Exactly Is the Universal Commerce Protocol?</h2>



<p class="wp-block-paragraph">At its core, UCP is a <strong>functional primitive framework</strong> that enables seamless commerce journeys between consumer surfaces (like AI assistants), businesses, and payment providers. Think of it as the <strong>&#8220;HTML for commerce&#8221;</strong>—a standardized way for different systems to understand products, inventory, pricing, and transactions without requiring custom integrations for every new platform.</p>



<h3 class="wp-block-heading">The Protocol&#8217;s Revolutionary Architecture</h3>



<p class="wp-block-paragraph">Unlike legacy systems that treat commerce as a series of disconnected transactions, UCP standardizes the <strong>entire commerce lifecycle</strong> through a single, secure abstraction layer built on three key principles:</p>



<p class="wp-block-paragraph"><strong>1. Unified Integration Framework</strong><br>Instead of businesses building bespoke connections for every new AI platform or shopping surface, UCP collapses complexity into a <strong>single integration point</strong>. A retailer integrates once with UCP and automatically becomes discoverable and transactable across all UCP-compatible surfaces—from Google&#8217;s AI Mode in Search to future platforms we haven&#8217;t even imagined yet.</p>



<p class="wp-block-paragraph"><strong>2. Capability-Based Communication</strong><br>UCP introduces a sophisticated capabilities model where businesses expose what they can do—not just what they have. These capabilities include:</p>



<ul class="wp-block-list">
<li><strong>Core Building Blocks:</strong> Product discovery, checkout, order management</li>



<li><strong>Extensions:</strong> Specialized functionality like discounts, fulfillment options, or loyalty programs</li>



<li><strong>Dynamic Discovery:</strong> Agents can discover available capabilities through standardized JSON manifests</li>
</ul>



<p class="wp-block-paragraph"><strong>3. Payment-Agnostic Design</strong><br>UCP&#8217;s most innovative feature might be its <strong>modular payment handler architecture</strong>, which separates payment instruments (what consumers use to pay) from payment handlers (the processors). This enables true payment interoperability while maintaining cryptographic proof of user consent for every transaction—a security-first approach that builds trust into the protocol&#8217;s DNA.</p>



<h2 class="wp-block-heading">Why the Ecosystem Is Rallying Around UCP</h2>



<p class="wp-block-paragraph">The protocol represents a rare win-win-win scenario across the commerce landscape:</p>



<p class="wp-block-paragraph"><strong>For Businesses: Control Meets Accessibility</strong></p>



<ul class="wp-block-list">
<li><strong>Merchant of Record Retention:</strong> You maintain full control over your business logic and remain the merchant of record</li>



<li><strong>Flexible Integration Options:</strong> Choose between APIs, Agent2Agent (A2A) communication, or the Model Context Protocol (MCP) based on your technical stack</li>



<li><strong>Embedded Checkout:</strong> Maintain fully customized checkout experiences from day one while participating in the broader ecosystem</li>



<li><strong>Future-Proofing:</strong> The extensible architecture scales as new agentic experiences emerge</li>
</ul>



<p class="wp-block-paragraph"><strong>For AI Platforms &amp; Developers: Simplicity at Scale</strong></p>



<ul class="wp-block-list">
<li><strong>Standardized Onboarding:</strong> Simplify business integration using consistent APIs while allowing flexibility in implementation</li>



<li><strong>Open-Source Foundation:</strong> Built to be community-driven with transparent evolution</li>



<li><strong>Reduced Development Burden:</strong> Focus on creating innovative experiences rather than building endless custom integrations</li>
</ul>



<p class="wp-block-paragraph"><strong>For Payment Providers: Interoperability Without Compromise</strong></p>



<ul class="wp-block-list">
<li><strong>Open, Modular Design:</strong> Enables choice of payment methods while maintaining security</li>



<li><strong>Provable Transactions:</strong> Every authorization includes cryptographic proof of user consent</li>



<li><strong>Universal Compatibility:</strong> Works alongside existing systems like the Agent Payments Protocol (AP2)</li>
</ul>



<p class="wp-block-paragraph"><strong>For Consumers: Frictionless Discovery to Decision</strong></p>



<ul class="wp-block-list">
<li><strong>Seamless Experiences:</strong> Move from brainstorming to purchase without changing contexts</li>



<li><strong>Peace of Mind:</strong> Cryptographic security and clear consent mechanisms</li>



<li><strong>Best Value Recognition:</strong> Member benefits and loyalty programs travel with you across surfaces</li>
</ul>



<h2 class="wp-block-heading">How UCP Works in Practice: A Technical Walkthrough</h2>



<p class="wp-block-paragraph">Let&#8217;s trace a practical implementation using the example of a flower shop integrating with UCP:</p>



<p class="wp-block-paragraph"><strong>Step 1: Business Server Setup</strong><br>The retailer sets up a UCP-compatible server that exposes their products and capabilities. Using the open-source UCP SDK, they can quickly stand up a server that understands the protocol&#8217;s language for product data, inventory, and transactions.</p>



<p class="wp-block-paragraph"><strong>Step 2: Capability Exposure</strong><br>The business publishes a standardized manifest at <code>/.well-known/ucp</code> that declares:</p>



<ul class="wp-block-list">
<li>Available services (like shopping or food delivery)</li>



<li>Supported capabilities (checkout, discount application, fulfillment options)</li>



<li>Payment handler configurations</li>



<li>Communication endpoints</li>
</ul>



<p class="wp-block-paragraph"><strong>Step 3: Agent Discovery</strong><br>When an AI agent (like one in Google&#8217;s Gemini) wants to help a user buy flowers, it queries the business&#8217;s UCP endpoint. The response might look like:</p>



<pre class="wp-block-code"><code>{
  "ucp": {
    "version": "2026-01-11",
    "services": { 
      "dev.ucp.shopping": {
        "version": "2026-01-11",
        "endpoint": "https://flowershop.example/ucp/"
      }
    },
    "capabilities": &#91;
      { "name": "dev.ucp.shopping.checkout" },
      { "name": "dev.ucp.shopping.discount" },
      { "name": "dev.ucp.shopping.fulfillment" }
    ]
  }
}</code></pre>



<p class="wp-block-paragraph"><strong>Step 4: Transaction Execution</strong><br>The agent can then invoke capabilities—creating a checkout session, applying discounts, or selecting fulfillment options—all through standardized UCP calls. The entire process maintains security through request signatures and idempotency keys while giving the business full control over pricing, inventory, and fulfillment logic.</p>



<h2 class="wp-block-heading">Google&#8217;s Reference Implementation: Bringing UCP to Life</h2>



<p class="wp-block-paragraph">While UCP is designed as a vendor-agnostic standard, Google has built the <strong>first reference implementation</strong> to demonstrate its potential. This implementation powers new buying experiences in <strong>AI Mode in Search and the Gemini app</strong>, allowing consumers to move seamlessly from discovery to purchase.</p>



<p class="wp-block-paragraph"><strong>The Google Integration Path:</strong></p>



<ol class="wp-block-list">
<li><strong>Merchant Center Foundation:</strong> Businesses need an active Google Merchant Center account with eligible products</li>



<li><strong>UCP Compliance:</strong> Implement the UCP specification for product discovery and checkout capabilities</li>



<li><strong>Checkout Experience:</strong> Enable consumers to purchase using saved payment and shipping information from Google Wallet</li>
</ol>



<p class="wp-block-paragraph"><strong>Example Query Flow:</strong><br>When a user asks Gemini, &#8220;Find a lightweight suitcase for my trip to Japan,&#8221; the AI can:</p>



<ul class="wp-block-list">
<li>Discover products from UCP-enabled retailers</li>



<li>Check real-time inventory and pricing</li>



<li>Initiate checkout through the user&#8217;s preferred payment method</li>



<li>Complete the purchase without leaving the conversational context</li>
</ul>



<h2 class="wp-block-heading">The Collaborative Future of Commerce</h2>



<p class="wp-block-paragraph">What makes UCP truly revolutionary isn&#8217;t just its technical design but its <strong>open-source, collaborative development model</strong>. By inviting the entire ecosystem—from global retailers to independent developers—to contribute to the specification, Google is fostering a community-driven approach to solving commerce&#8217;s most persistent challenges.</p>



<p class="wp-block-paragraph"><strong>Getting Involved:</strong></p>



<ul class="wp-block-list">
<li><strong>Explore the Specification:</strong> Available on GitHub with complete documentation</li>



<li><strong>Participate in Discussions:</strong> Shape the protocol&#8217;s evolution through GitHub Discussions</li>



<li><strong>Contribute Code:</strong> Submit pull requests and help build the next generation of commerce infrastructure</li>



<li><strong>Integrate and Experiment:</strong> Use the provided SDKs and samples to prototype UCP-enabled experiences</li>
</ul>



<h2 class="wp-block-heading">The Big Picture: Why This Matters Now</h2>



<p class="wp-block-paragraph">As consumers increasingly embrace conversational interfaces and AI assistants, they expect commerce to work like natural conversation—fluid, contextual, and complete. UCP provides the technical foundation to make this possible at scale, transforming how businesses connect with customers in the agentic era.</p>



<p class="wp-block-paragraph">The protocol represents more than just a technical standard; it&#8217;s a <strong>philosophical shift</strong> toward interoperability, user control, and ecosystem collaboration. By solving the N x N integration problem, UCP frees businesses to focus on what they do best—creating great products and experiences—while giving AI platforms the tools to deliver truly helpful commerce assistance.</p>



<p class="wp-block-paragraph">As the first wave of implementations rolls out from Google and its partners, we&#8217;re witnessing the early stages of a commerce revolution that promises to make shopping more intuitive, accessible, and human-centered than ever before. The universal language of commerce has arrived, and it&#8217;s open for everyone to speak.</p>



<p class="wp-block-paragraph">References </p>



<p class="wp-block-paragraph"><a href="https://developers.googleblog.com/under-the-hood-universal-commerce-protocol-ucp/" rel="nofollow noopener" target="_blank">Under the Hood: Universal Commerce Protocol (UCP) &#8211; Google Developers Blog</a></p>



<p class="wp-block-paragraph"></p>
]]></content:encoded>
					
					<wfw:commentRss>https://rpabotsworld.com/universal-commerce-protocol/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
	</channel>
</rss>

<!--
Performance optimized by W3 Total Cache. Learn more: https://www.boldgrid.com/w3-total-cache/?utm_source=w3tc&utm_medium=footer_comment&utm_campaign=free_plugin

Page Caching using Disk: Enhanced 

Served from: rpabotsworld.com @ 2026-11-20 11:23:52 by W3 Total Cache
-->