Grex is a thin operations layer that sits above your agents without touching how they work. Here's exactly how the pieces fit together.
Every deployment has three layers. Your agent packs run on your machines. Hermes orchestrates them locally and reports to Grex. Grex is the central view across every machine you own.
Hermes checks in with Grex every five minutes. That single loop is what drives fleet health, agent updates, and control intent delivery — with no persistent connection required.
Every five minutes, Hermes sends the current state of its machine to Grex: which agents are installed, whether they ran, their run outcomes, token costs, and any errors encountered since the last check-in.
Grex stores the heartbeat, updates the fleet view, and evaluates your alert rules. If an agent's error rate spiked, a budget threshold was crossed, or a heartbeat is overdue — Grex fires the alert through your configured channels.
The heartbeat response tells Hermes what to do next: install or remove a pack, enable or disable specific agents, or pull an updated version of a component. Grex never pushes — it waits for the next heartbeat and responds.
Hermes applies any control intents — running git pull on specific pack
directories, restarting agents, updating configs — then waits five minutes and does
it again. The loop never stops.
Four terms you'll see everywhere in Grex.
A single managed machine. When Hermes first starts on a machine it bootstraps
a Nidus in Grex and gets a permanent team_id. All heartbeats, run
events, and alerts are scoped to that Nidus. One machine, one identity.
A self-describing bundle of AI agents with a single manipulus.yaml
manifest. A pack declares its agents, their schedules, and their directives.
Hermes installs and runs packs. Grex tracks what's installed where.
The lightweight runtime that lives on every Nidus. It runs your agent packs on schedule, sends heartbeats to Grex, receives control intents, and self-updates when Grex advances the canonical version. No persistent connection required.
The hosted dashboard at https://app.grex-ai.com. It receives
telemetry from all your Nidi, evaluates alert conditions, delivers notifications,
and issues control intents back through heartbeat responses.
The only contract between a pack and Grex is the fm_client interface —
heartbeat participation and run event reporting. Everything inside the pack is an
implementation detail. Mix frameworks within the same pack if you want to.
| Pack | AI implementation | Why |
|---|---|---|
| Engineering | MiniMax + Gemini + Claude Code subprocess | Different models for planning, coding, and review within one pack |
| Research | CrewAI | Multi-agent synthesis pipeline maps cleanly to Crew/Agent/Task |
| Security | Raw subprocess + CrewAI reporter | Scanning is deterministic; only the digest step uses an LLM |
| Testing | Raw subprocess + CrewAI analyzer | Test execution is deterministic; failure triage uses an LLM |
| Marketing | CrewAI | Content synthesis from structured campaign inputs |
| Your pack | Whatever you want | Grex observes the output, not the implementation |
Grex maintains a canonical version registry for every component in the fleet. When you bump a version, Hermes detects the drift on its next heartbeat and pulls exactly the changed component — no SSH, no manual deploys.
Update an agent pack, fix a bug in Hermes, or ship a new directive. Commit and push.
Increment the component version in component_versions.json. Grex
now considers all Nidi running the old version to be behind canonical.
On each Nidus's next heartbeat, the response includes a component_updates
entry. Hermes runs git pull on just that component — not the whole repo —
and restarts the affected agents.
Grex lets you start a live multi-turn chat session with Claude, DeepSeek, GPT-4, Gemini, or any other frontier model — running on a specific machine you choose. No SSH. No terminal. Works from any browser.
Pick a target Nidus, choose the AI model, and open the session pane. Grex queues the session as pending on that machine.
On the next heartbeat (within five minutes), Hermes sees the pending session and claims it. It spawns the frontier AI process on-machine — your API keys never leave your hardware.
Type a message in the dashboard. Hermes delivers it to the running AI process, gets the reply, and posts it back through the Grex session channel. Each exchange is logged with token counts and cost.
Claude Sonnet, DeepSeek V3, GPT-4o, Gemini — whichever model Hermes is configured to support on that Nidus. The model runs on your machine against your API keys, not routed through Grex servers.
Grex gives you full control over every machine in your fleet without touching a terminal. Everything that affects how Hermes behaves on a Nidus is configurable from the dashboard and delivered on the next heartbeat.
Tell Grex which Manipulus Packs belong on which Nidus. Hermes installs or uninstalls them on the next heartbeat — no SSH required.
Turn a specific agent off without removing its pack. Useful for pausing one crew member during an incident without disturbing the rest of the pack.
Define daily or monthly token spend limits per machine. When a threshold is crossed, Grex fires an alert and can halt agent runs until reset.
Set heartbeat timeout windows, error-rate thresholds, and budget trip-wires. Route them to Slack, PagerDuty, or a webhook — and test-fire before you need them.
Hermes ships with a built-in chat skill that understands natural language configuration requests. Instead of navigating the dashboard, you can just tell Hermes what you want — and it applies the change on the spot.
Start a remote session with Hermes itself (not an agent pack — Hermes directly). This puts you in a conversation with the on-machine orchestrator.
Say things like "disable the research agent until Monday", "lower my daily budget to $5", or "remove the marketing pack from this machine." Hermes interprets the intent.
Changes that are local to the machine (agent enable/disable, config values) take effect immediately. Changes that go through Grex (pack installs, budget rules) are propagated on the next heartbeat cycle.
Grex is not a dashboard you babysit. Once your packs are deployed and your alert rules are set, the fleet operates autonomously. Your role shifts from operator to supervisor — you get paged when it matters, not when it doesn't.
Each agent inside a Manipulus Pack has its own run schedule defined in
manipulus.yaml. Hermes runs them without any external trigger — research
at 9am, security scans nightly, marketing synthesis on Tuesday mornings.
Every heartbeat, Grex checks: did the expected agents run? Did any error rate spike? Is any budget window close to its limit? Did a heartbeat go quiet? These checks happen every five minutes, around the clock.
Alerts fire to Slack, PagerDuty, or webhook. You see the dashboard summary when you choose to check in. Between alerts, the fleet is simply running — building, researching, reviewing — without requiring your attention.
When you do need to step in — kill an agent, adjust a budget, start a session to investigate — you can do it from a phone browser in under a minute. Then step away again.
Sign in to your dashboard and get full visibility across every machine you own.
Open your dashboard →