Today's GitHub Trending tells a clear story. Three repos, three different approaches, one shared problem:

  • NVIDIA/auto-ontology — adds a semantic graph reasoning layer for "deterministic query generation" in agent workflows
  • vercel-labs/agent-desktop — gives agents a CLI to operate desktop applications
  • garrytan/gstack — ships 23 role-based tools (CEO, Designer, Eng Manager, QA) for Claude Code

What do they have in common? They're all trying to solve the same problem: agents can think, but they can't reliably execute.

The Determinism Gap

LLMs are probabilistic by nature. When an agent says "I'll fill in the form and submit it," what actually happens? Maybe it calls the right API. Maybe it hallucinates a field name. Maybe it works on the first try and fails on the second.

NVIDIA's auto-ontology tackles this at the reasoning layer — adding semantic graphs for deterministic query generation. It's a powerful approach for knowledge-intensive tasks.

But for physical execution — clicking buttons, filling forms, reading files, navigating browsers — you don't need a reasoning layer. You need RPA.

RPA Is Deterministic Execution, Packaged

RPA (Robotic Process Automation) has been doing exactly what agent-desktop is trying to build, but for years and at a higher abstraction level:

  • Browser automation: navigate pages, fill forms, click buttons, extract data
  • Desktop operations: open apps, read windows, trigger shortcuts
  • File operations: read, write, move, organize
  • Full audit trail: every action logged, every step reproducible

The difference is: RPA packages these as atomic, callable capabilities — not a raw CLI that you have to configure from scratch.

Agent and RPA synergy in desktop automation

Role-Based Execution: gstack's Insight, Applied to RPA

gstack's 23 role-based tools (CEO, Designer, QA, etc.) reveal a key principle: role-based division beats one-agent-does-everything.

This maps perfectly to RPA operations:

Role RPA Operations
Data Entry Clerk Form filling, data input, field validation
File Manager Document organization, archiving, retrieval
Auditor Result verification, compliance checks
Browser Operator Web navigation, scraping, interaction

Agent dispatches tasks by role. RPA executes by role. Each role has a bounded toolset, reducing error surface.

The Combo: Agent Plans, RPA Executes

This is the architecture behind iflytek/astron-rpa — an Agent-ready RPA suite that turns desktop and browser operations into atomic capabilities agents can call directly.

Paired with iflytek/astron-agent for workflow orchestration, the division is clean:

  • Agent (astron-agent): understands user intent, breaks down complex goals into steps, handles ambiguity and edge cases, decides which role to dispatch
  • RPA (astron-rpa): executes each step deterministically, logs every action, supports resume on failure, provides full audit trail

A Concrete Scenario

Imagine a monthly report workflow:

  1. Agent receives: "Generate the November financial summary from last month's data"
  2. Agent plans: fetch data from internal system → format into template → generate charts → email to stakeholders
  3. Agent dispatches to RPA roles:
    • Browser Operator: logs into internal system, navigates to reports page, exports data
    • Data Entry Clerk: fills in the report template with extracted data
    • File Manager: saves the report to the shared drive
    • Browser Operator: opens email client, attaches report, sends to stakeholder list
  4. Every step is logged. If step 3 fails (file system full), the workflow pauses and resumes from that exact point after the issue is resolved.

No hallucinated API calls. No "the agent almost got it right." Every action is deterministic, auditable, and resumable.

Why This Matters Now

The ecosystem is racing to give agents "hands" — from computer-use CLIs to role-based tool stacks. But the infrastructure for deterministic execution already exists. RPA was always the answer.

The question isn't "can agents do more?" It's "can agents execute reliably?" And that's exactly what RPA brings to the table.

Explore the repos: