@kord-campbell-kordless

Kord Campbell

I build agent-native dev tools — chiefly Hyperia, a terminal where AI agents run as panes — and orchestrate a fleet of harnesses via nemesis8, with grubcrawler research runs, lume search, ferricula memory and nuts.services identity.

How this setup has evolved

Version 1 · Latest

Enrich n8 as the 'engine room': telemetry to Hyperia (file changes, bandwidth, CPU, tokens), cross-agent session search, restart/restore, one TUI.

What I use AI for

I build agent-native developer tools — above all Hyperia, a terminal where AI agents run as first-class panes — and I use AI end-to-end to design, build, review and ship them. My style is orchestration over autopilot: I run a fleet of agents in parallel, keep myself in the loop, and hold the irreversible steps — merges, releases, installers — for myself.

My everyday setup

  • Hyperia (current): The terminal I build and work inside. Every agent is a visible pane I can read and steer, and its MCP server lets an agent drive panes, tabs, notes and builds. Its built-in web panes give an agent a real browser it can drive — to inspect and debug its own work, or browse data — while I watch it happen live, with no extension and none of the slow relay a browser plugin adds.
  • nemesis8 / n8 (current): My orchestration engine room. It wraps AI coding CLIs in Docker/Podman containers with persistent, resumable sessions and durable per-agent identities, and feeds Hyperia live telemetry for every agent — file changes, container CPU and bandwidth, and token usage — plus cross-agent session search and one-key restart/restore, all in one TUI. It can tunnel apps back to my local box, run agents remotely on another server, or schedule tasks.
  • grubcrawler (current): An agentic web crawler. I start research runs — its bounded agent mode — that fetch and clean pages into markdown; those results feed the build plans I hand to agents.
  • lume (current): My hybrid search and document-memory layer — lexical, semantic and an index-native knowledge graph — as a CLI or an MCP server.
  • shivvr (current): The chunking and embedding engine under lume and ferricula.
  • ferricula (current): An agent memory service — remember/recall with decay and consolidation — my long-term memory layer for agents.
  • nuts.services (current): The identity and ledger fabric my agents run on. A token maps to a handle, every write lands on a public ledger, and it hosts the crawler and a news board the agents post to and query.

Agents & models

  • The harnesses (current): n8 gives me eleven agent harnesses — Codex, Claude Code, Grok, Antigravity, OpenCode, Gemini, hax, omp and fx among them — each in its own container: same workspace, different brain. Claude (this one), Codex and Antigravity are the ones I drive most; I switch harness to fit the job.
  • Open-weight models (current): local models through Ollama — GLM, Qwen, Gemma — via OpenCode and omp, alongside Grok, Claude, Codex and Antigravity.
  • jev (current): TypeSafe.ai's model, used as a deterministic tool door — routing and gating tool calls rather than free-text chat.

How the pieces fit together

The stack runs one chain — crawl → embed → search → remember → publish — under a single nuts.services identity: grubcrawler gathers and cleans sources, shivvr embeds them, lume searches and synthesizes, ferricula keeps what's worth remembering, and results and discussion get posted to the nuts news ledger. That chain is what a research run feeds before I write a build plan.

The MCP bench

  • n8 ships a large bench of MCP tools my agents can reach: driving Blender, controlling Hyperia, and controlling n8 itself — tunnels, remote runs and scheduled tasks.
  • Google Workspace (configured): Gmail, Calendar and Drive when a task needs them.
  • mysetup (current): keeps this page updated through my agent.

How I delegate and review

  • I write a build plan first, then hand agents one part at a time.
  • Each agent gets a bounded role; a judge reviews before anything lands, and a DevOps gateway owns check-ins, PRs, host builds and releases — coding only deployment.
  • The irreversible, outward-facing moves — merge, tag, release, install, or killing a running app — stay with me.
  • Agents never steal my active pane or tab; their activity surfaces passively, and only I move the view.

What runs where

  • A personal Windows 11 workstation (local), with a Rust + Node/Yarn toolchain for building Hyperia. Agents run locally in panes and in containers, and n8 can push a run out to a remote server when I want the muscle elsewhere.
  • Google Cloud Run (current): where my deployed services run.

How I work

  • I start from a build plan and a research run, not a blank prompt.
  • I push a change through the team — owners implement, the judge reviews, the gateway verifies on the host — then I field-test the built artifact myself.
  • Building and signing the local installer is automated behind one script — I run it, or an agent runs it during rapid iteration.
  • I bump a version for every build and never stamp the same version on two different builds, so the number always means one exact binary.

What changed and what I learned

  • I tend to write the first version myself, then have agents improve it. My auth system started as my own hand-written code; agents hardened it and ported it to Rust, which is the version I run now.