**TL;DR —** Running a company on AI requires a structured routing system, not just a chatbot. At [VijayaTech Labs](https://vijayatechlabs.com), we coordinate multi-brand operations using Hermes Agent instances deployed on a VPS and a developer laptop. By integrating Telegram, Google Drive, and a Kanban board, we maintain clear ownership and human-in-the-loop review gates. Here is our exact, production-tested ops stack and the configuration rules we use to prevent chaos.

---

Most people install an AI agent and expect the chaos to disappear.

It doesn't.

A chatbot is not an operating system. If you drop one into a messy team, you get the same mess — just faster, and now with a bot arguing in your group chat.

We made a different choice. At [VijayaTech Labs](https://vijayatechlabs.com) (and across our brands — Glint, OpenStart, Zira, LaunchLoop) we run Hermes Agent as a small **ops system**. Humans, agents, inbox, files, and tasks all have a place. The result is a 2-person team running multi-brand operations without drowning.

This post is the exact setup. Copy it, or hire us to build it for you.

## The problem: AI toys don't fix ops

The failure mode is always the same:

- Important work lives only in chat messages (lost by Friday).
- Files are scattered across personal Drives, desktops, and DM attachments.
- "The agent did it" has no owner, no review, no audit trail.
- Everyone assumes someone else is on it.

An AI assistant makes all four worse if you don't give it *structure*.

The fix is not a smarter model. It's a **routing system**: where humans talk, where agents act, where files live, and who owns what.

## The cast: humans + agents, on one team

We don't pretend agents replace people. We put them *inside* the team. Unlike standard [AI Agents for SMBs](/blog/ai-agents-for-smbs) that operate in silos, our setup is highly integrated.

| Role | Who / what | Job |
|------|-----------|-----|
| Owner | Me | Decisions, approvals, strategy |
| Operator | Teammate | Human execution, review, QA |
| Orchestrator | Hermes on VPS | Breaks big goals into tasks |
| Worker | Hermes on VPS / [Zira](/blog/zira-ai-agent-chases-invoices) | Executes the work (implementer profile) |
| Local helper | Hermes on laptop | Dev machine, local/special tasks |

**Hermes on VPS** is the always-on brain: it runs the gateway, answers in the group, runs scheduled jobs, and works the Kanban board. For details on how we host such infrastructure on a budget, see our guide to [self-host n8n on a VPS](/blog/self-host-n8n-vps-guide).

**Hermes on the laptop** is for local tasks — a dev machine, a browser session, private files — when we don't want that work on the server.

Two Hermes instances, one company system, different surfaces.

> Rule: only ONE Hermes runs the Telegram gateway. If both tried, they'd fight over the same bot token. The laptop instance never starts a gateway.

## The rule that keeps it sane

One sentence, on every wall:

> **Chat = talk. Kanban = ownership. Drive = files.**

- If it's only in a message, it will get lost.
- If it's on the board, someone owns it.
- If it's in Drive, everyone can find it.

That's the whole philosophy. Everything below is just enforcement of those three lanes.

## Layer 1 — Telegram as the team inbox

We use Telegram for all human↔agent communication.

- **Private DM with Hermes** = owner channel (private decisions, sensitive stuff).
- **Ops group** (team + bot) = shared communication.
- The bot is set to **require @mention** in the group, so it doesn't reply to every human message — only when called.

Humans talk normally. The agent joins when mentioned, or when a task needs a human's input.

This is the "inbox": where work enters and where exceptions get surfaced.

## Layer 2 — Google Drive as the shared brain

One team Drive. Not ten personal folders.

```
VVV Ops/
  00-inbox/        # drops from humans / VA
  10-briefs/       # trend radar, research
  20-projects/     # active work
  90-archive/      # done
  workspaces/      # per-workstream space
```

- Humans drop files.
- Agents upload results.
- Everyone opens the same tree.

No "can you resend that doc?" Ever.

## Layer 3 — Hermes Kanban as the assignment system

This is where most setups break. They keep task state in chat. We don't.

Every piece of real work is a **Kanban card**:

- `assignee` = an agent profile **or** a human
- `parent` / `child` for pipelines (research → draft → review)
- `block` = needs human review before continuing
- `unblock` = approved, carry on

The gateway's **dispatcher** automatically claims cards that are ready and spawns the right profile to work them. No manual "hey agent, do this" required.

A human only gets pulled in when a card is explicitly **blocked** for review. That's the approval gate — and it's the reason we can let agents work unattended without fear.

## Agent roles (profiles)

On the VPS we run three profiles:

| Profile | Purpose |
|---------|---------|
| `default` | Telegram gateway, human-facing |
| `orchestrator` | Decomposes big goals into tasks |
| `implementer` | Does the execution work |

External coding agents (Claude Code, Codex, OpenCode) are **not** board assignees. Inside an implementer task, they can be spawned as coding lanes — but Hermes owns completion and the human gate. For messaging connectivity, we route notifications through the [Atharva AI](https://atharva.app) WhatsApp API platform.

## The daily human loop

It's boring on purpose:

1. Check Telegram (DM + ops group).
2. Check the board — list, blocked, needs-review.
3. Comment + **unblock**, or **reassign**.
4. Pull artifacts from Drive.

You manage exceptions. Agents grind the rest. A small team can run multiple brands this way because the system, not your memory, tracks ownership.

## What this delivers for a small team

- **Multi-brand ops without 10 tools.** One system, every brand.
- **Clean handoffs.** Human ↔ agent transfers leave a trail.
- **Always-on work.** Cron jobs + the dispatcher run while you sleep.
- **Clear ownership.** No "I thought you had it."
- **Repeatable onboarding.** A new hire gets the same board, Drive, and group.

This is the difference between an "AI toy" and an "AI coworker."

## Want this built for your team?

We set up Hermes ops for other teams — and we harden it, not just install it:

- Hermes on a VPS + gateway
- Telegram bot → DM + ops group (with @mention rules)
- Profiles: default / orchestrator / implementer
- Kanban dispatch wired into the gateway
- Google Drive team folder + agent auth
- Human approval gates on real work
- Handoff and ownership conventions documented for your team

If you want this running in your company, **DM "HERMES OPS"** and I'll send the setup scope and pricing.

## Copy-this setup order (DIY)

Don't start with 20 agents. Start here:

1. Install Hermes on a VPS, get the gateway running. For hosting, you can [self-host on a VPS](/blog/self-host-n8n-vps-guide).
2. Add the Telegram bot → private DM + one ops group (require @mention).
3. Create profiles: `default`, `orchestrator`, `implementer`.
4. Enable Kanban dispatch in the gateway.
5. Create one Google Drive team folder and give the agent auth.
6. Put one real task behind a human **block** gate.

That's it. Two humans, one always-on Hermes, zero chaos.

## FAQ

### Can Hermes Agent handle multiple tasks concurrently?
Yes. The orchestrator profile breaks down complex, multi-brand goals into isolated child tasks. The dispatcher then assigns these child tasks to concurrent implementer profiles (worker lanes), running them in parallel while monitoring execution state.

### Do I need a high-performance VPS to run this stack?
No. Because Hermes Agent primarily routes heavy inference tasks to external model endpoints and coordinates files in Google Drive, the server-side footprint is very low. A simple VPS costing ₹500/month to ₹1,000/month is more than enough for small team operations.

### How does the human review gate prevent errors?
The Kanban board implements strict state transition checks. When an agent reaches a task that requires verification (e.g. sending an email or publishing a code change), the task status is set to `blocked`. Hermes then sends a Telegram alert and pauses the workflow. The task only resumes once a human reviews the draft and toggles it to `unblocked`.

## Sources
- [Nous Research Hermes Agent Repository](https://github.com/NousResearch/Hermes-Agent) — Open-source agent architecture and learning loop implementation.
- [VijayaTech Labs AI Agents Overview](/blog/ai-agents-for-smbs) — Our framework for evaluating AI automation projects.
- [Self-Host n8n VPS Guide](/blog/self-host-n8n-vps-guide) — How to spin up private orchestration servers.

---

*Viswanatha Reddy runs VijayaTech Labs — AI visibility and agent tooling for small teams. Building in public.*