Today's GitHub Trending tells a clear story: agents are moving from chat to action. Three repos caught my attention, each representing a different route to making agents operate real software.
Route 1: CLI-ification (HKUDS/CLI-Anything)
CLI-Anything takes the approach of "Making ALL Software Agent-Native" by generating CLI interfaces for software that doesn't have them. The idea is elegant: if an agent can call a command, it doesn't need to navigate a GUI.
This works great for developer tools, system utilities, and anything that already has a command-line surface. The limitation is obvious: that internal CRM your company has been running since 2018? It's not getting a CLI anytime soon. And visual tools like Figma or complex ERP dashboards don't naturally decompose into command-line operations.
Route 2: Workflow Orchestration (n8n-io/n8n)
n8n brings native AI capabilities to a workflow automation platform with 400+ integrations. It's the "connect APIs with AI in the loop" approach — visual building blocks, custom code nodes, self-hosted or cloud.
This is powerful for API-to-API automation: trigger on an event, call a service, transform data, call another service. But workflows operate at the API layer. When the task is "open this desktop application, navigate to this tab, fill this form, and submit" — n8n alone can't do it.
Route 3: Skill Standardization (google-labs-code/stitch-skills)
Google's Stitch Skills defines an open standard for Agent Skills, compatible with Cursor, Claude Code, Gemini CLI, and Antigravity. This is about packaging and portability — write a skill once, run it across coding agents.
Standards matter. But a standard is a contract, not an execution engine. You still need something that actually runs the operation — clicks the button, reads the screen, fills the form.
The Missing Layer: RPA as Agent Hands
Here's what none of the three routes fully cover: operating software through the UI layer when no API or CLI exists. That's the traditional domain of RPA — and it's exactly where iflytek/astron-rpa fits.
Astron-RPA is an Agent-ready RPA suite that handles the execution layer:
- Browser automation for web apps
- Desktop automation for native applications
- Form filling, data extraction, report generation
- Built-in human approval checkpoints for critical steps
The "Agent-ready" part is key. Traditional RPA is script-and-schedule: you record a macro, set a trigger, and hope nothing changes. Agent-ready RPA means the agent can decide what to do, decompose the task, call the RPA runtime to execute, and hand off to a human when judgment is needed.
The Combo: Brain + Hands + Supervisor
The real power emerges when you pair it with iflytek/astron-agent — an enterprise-grade agentic workflow platform for building SuperAgents. The pattern is:
- Agent plans: decompose a complex task into steps, decide which steps need API calls vs. UI automation vs. human review
- RPA executes: carry out the UI operations — open the app, fill the form, export the report
- Human supervises: review critical decision points before the agent proceeds
This isn't "agents replace humans" or "humans block agents." It's a collaboration model where each party does what it's best at.
When to Use Which Route
| Scenario | Best Route |
|---|---|
| Software has CLI/API, task is well-structured | CLI-ification or direct API calls |
| Multi-service orchestration with AI in the loop | n8n or similar workflow platform |
| Operating legacy/desktop software with no API | RPA (astron-rpa) |
| Complex multi-step tasks with judgment calls | Agent + RPA + human (astron-agent + astron-rpa) |
The takeaway: agents need hands, not just brains. CLI-ification, workflow orchestration, and skill standards are all important pieces. But for the vast majority of enterprise software that lives behind a GUI, RPA remains the most reliable bridge between agent intent and software action.
Check out Astron-RPA: https://github.com/iflytek/astron-rpa
And Astron-Agent for orchestration: https://github.com/iflytek/astron-agent


Top comments (0)