Two Rust-native AI coding agent harnesses. One cross-agent message bus. The question: is it better to stitch together hcom + ante for inter-agent messaging and offline coding, or run a single jcode all-in-one binary?
The Architecture
hcom is a cross-agent messaging layer (SQLite-based). It’s a bus that lets different agents talk to each other — Hermes hands off a coding task to hcom, which routes it to whichever agent instance is available.
ante and jcode are both Rust-native coding agent harnesses — the things that actually edit files, run commands, and produce code.
hcom + ante
The plug-and-play combo: hcom provides the coordination layer ante doesn’t have built in. Ante brings its unique value — built-in GGUF offline inference (zero API calls), Terminal-Bench verified performance, ~15MB binary, and a “cellular-native” philosophy of tiny self-contained agents.
Why it works:
- hcom fills ante’s biggest gap (no swarm/inter-agent messaging built in)
- Ante fills hcom’s gap (hcom doesn’t do coding — it’s a message bus)
- Offline GGUF is useful for security-conscious workflows where you don’t want to phone home
- Ante’s gateway mode maps to Hermes channel integrations
Why it doesn’t:
- You’re stitching two projects together that weren’t designed for each other
- Ante’s core is closed during alpha — can’t fork or hot-fix
- The integration is on you to build and maintain
- Two binaries, two config systems, two upgrade cycles
jcode alone
The everything-in-one approach: jcode has built-in swarm coordination, inter-agent messaging (file conflict detection, autonomous agent spawning), and 30+ tools in one MIT binary. No stitching needed.
Why it works:
- One project, one config, one binary — the swarm features are designed to work together
- Fully open (MIT) — fork, patch, contribute, no trust required
- 27MB idle RAM, 14ms time-to-first-frame
- 14.6K★, 64 releases in 7 months
- Self-dev workflow (edits own Rust source, hot-reloads)
Why it doesn’t:
- No offline inference — every call hits an API endpoint
- Single maintainer with 160 open issues — bus factor is real
- The project is a moving target at that velocity
Verdict
hcom + ante is the intellectually interesting combo — offline inference is genuinely novel and the “tiny agents at scale” thesis aligns with where agent orchestration is going. But you’re paying the integration tax for a closed-core alpha project.
jcode is the pragmatic bet — one MIT binary that already has the swarm features you’d otherwise need hcom to provide. The inter-agent messaging jcode has built-in overlaps with what hcom does, so adding hcom on top of jcode would be redundant.
The real question is whether you’d ever need offline inference badly enough to accept a closed core and the cost of stitching two tools together. If your stack already routes through API gateways, that tilts it toward jcode.
Bottom line: jcode alone, unless offline inference becomes a hard requirement. Then hcom + ante becomes the interesting play.