Orchestrating Remote Coding Agents with Hermes: An Architecture Where Your AI Assistant Becomes the Dispatcher

A Counterintuitive Architecture

While most developers are still focused on making a single AI agent more powerful, one Reddit developer shared a fundamentally different approach: instead of having an AI assistant write code directly, turn it into a lightweight orchestrator — one whose sole job is to dispatch tasks to specialized coding agents running on other machines.

This developer runs Hermes 24/7 on a cheap VPS as their personal AI assistant. But they had no interest in running code repositories, build pipelines, or coding agents on that VPS — because their Mac already had everything: compute resources, repos, MCP tools, a complete development environment, and AI subscriptions they were already paying for.

So they connected the two, building a clean task pipeline: User → Hermes → Mac → Superset → Claude.

The Minimal Handoff: One ID Is Enough

The most elegant aspect of this system is its minimal handoff protocol.

The author's example: they simply send Hermes a single message — TSK-42.

That's it. Hermes does not read the YouTrack ticket. It does not spend effort crafting a lengthy prompt. What it does is deliberately restrained:

1. Create an isolated workspace on the Mac from the develop branch
2. Spin up a Claude session via Superset
3. Hand Claude the task ID, then step aside

Everything after that is Claude's responsibility: it receives the task ID, uses a local YouTrack MCP to load the ticket, understands the requirements, operates on the local repo, implements the feature, commits the changes, and opens a PR on GitHub.

Fire-and-Forget: No Babysitting

One notable design detail: Hermes stops after the handoff. It doesn't poll Claude's status or continuously supervise execution. This "fire-and-forget" pattern dramatically reduces the orchestrator's overhead.

Because Claude has remote control enabled, the developer can jump directly into the same session at any time for manual intervention when needed. This preserves a flexible switch between fully automated and human takeover modes.

Why This Orchestration Architecture Matters

The author highlights what they find most interesting: Hermes doesn't need to be the agent that does everything. It can simply be a lightweight shell or scheduler that drives specialized agents distributed across different machines.

This separation of concerns delivers several practical benefits:

• Cost optimization: The VPS stays cheap and always-on; the heavy lifting goes to the local Mac
• Reuse existing subscriptions: Leverage already-paid AI subscriptions (like Claude) instead of burning additional API credits for coding tasks
• Isolated coding sessions: Superset creates a separate workspace per task, preventing cross-contamination
• Full local environment: Directly use local MCP tools and dev environment without rebuilding anything remotely

The Mindset Shift: From Monolithic Agent to Multi-Agent Orchestration

This case reflects an emerging trend in the AI agent space: moving away from one all-powerful agent toward multi-agent collaborative orchestration.

The traditional instinct is to pile every capability onto a single agent — make it conversational, planful, and executable all at once. But as task complexity grows, this monolithic architecture hits walls around resources, context limits, and specialization.

This developer's approach decomposes the system into distinct roles: Hermes handles "sense and dispatch" (when to hand off what task to whom), while Claude handles "deep execution" (the actual coding work). Each component does only what it's best at, connected through a minimal interface — a task ID.

A Bigger Vision for Automated Workflows

The author notes that Hermes was already integrated with Slack and YouTrack, so this orchestration capability opens up more interesting automation chains:

Research a problem → identify a task to handle → hand off to the Mac → Claude implements it → PR gets generated

In other words, the entire pipeline from "discovering a problem" to "submitting code" requires human involvement only at key checkpoints. And Telegram is simply the current interaction surface — it can be swapped out for Slack, a web UI, another bot, or any interface that can control Hermes.

Prerequisites and Real-World Constraints

Of course, this elegant architecture has one hard requirement: the Mac must stay online. This execution machine is the backbone of the entire pipeline — if it goes offline, tasks can't land.

Beyond that, the setup depends heavily on the MCP ecosystem (e.g., YouTrack MCP), Superset's isolated session capabilities, and Claude's remote control features. For developers looking to replicate this, there's a meaningful configuration overhead and some required experience with the toolchain.

Closing Thought: The Role of AI Assistants Is Being Redefined

The developer ends with an open question: Is anyone else using Hermes this way — as an orchestrator for standalone coding agents, rather than as a coding agent itself?

The question itself is revealing. It suggests that as AI agent tooling matures, the definition of "assistant" is evolving — from "one intelligent entity that does everything" to "a coordination hub that knows how to route the right tasks to the right executors."

For developers who regularly handle large volumes of engineering work, this "orchestration-first" mindset may be more pragmatic than chasing an ever-more-capable monolithic agent. It combines the distinct strengths of existing paid subscriptions, local environments, and cheap always-on servers — building an automated development pipeline at minimal cost.