What's Next: The Roadmap for a Self-Hosted AI Agent Team

After 48 hours of building, debugging, and deploying, my 7 AI agents are stable, connected to Google Workspace, and running on subscription-based models at zero marginal cost. The cluster is healthy, the probes are passing, and the agents are doing real work. Here's what comes next.

Where We Are

The current stack is fully operational:

• 7 agents: Henry (orchestrator) + 6 specialists, each with a defined role and skill set
• 16 skills loaded and ready across the team
• Telegram channel for human-agent interaction
• Google Workspace access: Calendar, Gmail, Drive, Docs, Sheets
• Claude Code for Opus 4.6 delegation at $0 marginal cost
• GitHub CLI for repo operations: issues, PRs, releases

Everything runs on my two-node Talos Linux cluster, managed via GitOps with Flux. No cloud VMs, no SaaS agent platforms, no per-token billing surprises.

The Immediate Roadmap

1. Automated Issue-to-PR Pipeline

This is the highest-leverage item. The pieces are already in place: gh-issues skill, a coding agent, and Claude Code delegation. The flow looks like this:

• Henry reads a GitHub issue (triggered by webhook or poll)
• Henry spawns Opus 4.6 via Claude Code to implement the fix
• Opus 4.6 opens a PR with the changes
• I review and merge

Fully autonomous from issue to PR. Human stays in the loop at the merge gate. This turns GitHub Issues into a task queue that agents execute against, which is exactly what an issue tracker should be.

2. Morning Briefing Enhancement

The 7 AM morning briefing currently pulls from Life Hub data. Now that Henry has Calendar, Gmail, and Drive access, the briefing can include:

• Today's meetings with agenda links
• Relevant emails that need action
• Linked documents from Drive
• Cross-referencing calendar events with open tasks

The briefing goes from "here's what your dashboard says" to "here's what your day actually looks like." That's a meaningful difference when you're juggling infrastructure work, security governance, and certification study.

3. Credential Rotation Automation

OAuth tokens for Claude Code, Google, and Gemini all expire eventually. Right now, a stale token means a silent failure: the agent tries to act, gets a 401, and either retries uselessly or fails the task.

I need a CronJob or heartbeat check that:

• Validates each OAuth token on a schedule
• Alerts via ntfy before tokens go stale
• Optionally triggers a refresh flow for tokens that support it

This is pure operational hygiene. Credentials are the most fragile part of any integration, and agents can't fix their own auth failures.

4. Cost Monitoring Dashboard

After the $100 incident (one busy night of agent activity hitting variable API billing), I need visibility into spend. The plan is a Grafana panel showing:

• Model provider usage (requests, tokens, latency)
• Fallback frequency (how often agents drop from primary to secondary models)
• Estimated daily/weekly spend
• Alert if OpenRouter spend exceeds $5/day

The subscription model changes the economics, but I still have fallback paths that hit metered APIs. I need to know when that happens and how much it costs.

5. Agent Autonomy Tiers

Not all agents should have the same permissions. Right now, access is relatively flat. That needs to change:

• Henry (orchestrator): Full access: Google Workspace, Claude Code, GitHub, all skills
• Kit (builder): Claude Code delegation, repo write access, no email
• Petra (researcher): Read-only Google access, web search, no write operations
• Other specialists: Scoped to their domain, least-privilege by default

This isn't theoretical security theater. Agents that can write code and push commits need different guardrails than agents that summarize documents. Define the boundaries, encode them in configuration, enforce them at the skill level.

6. Obsidian Vault Access

The Engineer's Compass vault (2,500+ notes of decisions, runbooks, architecture docs, and project context) lives on my Mac, not the cluster. The agents can't see it, which means they're missing the richest source of institutional knowledge I have.

Two options:

• NFS mount: Sync the vault directory to the NFS server at 192.168.1.133, mount it into agent pods. Simple, but introduces sync lag and file-locking concerns.
• MCP server bridge: Build an MCP server that indexes the vault and exposes it as a tool. Agents query by topic, tag, or full-text search. More work upfront, but cleaner integration and no filesystem coupling.

I'm leaning toward the MCP server. The vault's value isn't in raw file access. It's in structured retrieval. An agent that can ask "what was the decision on Cilium L2 policy configuration?" and get back the right note is more useful than one that can cat a markdown file.

7. Multi-Repo Coding

Right now, Claude Code operates on whatever repo is mounted in the container. That works for single-repo tasks, but my projects span multiple repositories:

• home-ops: cluster infrastructure and GitOps
• life-hub: personal dashboard and API
• openclaw-workspace: agent platform configuration

An agent working on a Life Hub feature that requires a new Kubernetes manifest needs access to both repos simultaneously. I need to either mount multiple repos via PVC or have agents clone on demand. The latter is simpler and avoids stale working copies, but adds latency. Worth testing both approaches.

The Bigger Picture

This is infrastructure for a personal AI operating system.

The agents don't just chat. They check your calendar, read your email, manage your code repos, and execute on your priorities. They have persistent memory, tool access, and the ability to delegate compute-intensive work to models that would otherwise cost dollars per task.

The platform question isn't "can AI agents do useful work" anymore. That's settled. The question is: how do you operate them reliably at low cost?

That's an infrastructure problem. And infrastructure problems have infrastructure solutions: monitoring, redundancy, access control, cost management, and operational runbooks. The same discipline that keeps a Kubernetes cluster healthy keeps an agent team productive.

The Economics

The math is straightforward:

• $220/month flat: ChatGPT Plus + Claude Max subscriptions
• Unlimited agent computation: Opus 4.6 delegation via Claude Code costs $0 per task
• Compare to variable billing: One busy night of API calls cost $100 before I switched

Subscriptions change what's economically viable for autonomous agents. When every API call has a price tag, you optimize for fewer calls, which means dumber agents that do less. When computation is flat-rate, you can let agents think longer, retry more, and tackle harder problems without watching a billing meter tick up.

The $220 isn't free, but it's predictable. And predictable costs let you plan capacity instead of reacting to invoices.

Closing

The hard part isn't the AI. It's the plumbing.

OAuth in containers. PVC persistence across pod restarts. Model fallback chains that degrade gracefully. Liveness probes with tolerances wide enough for V8 garbage collection. Sidecar processes that need to start before the main container. SOPS-encrypted secrets that Flux decrypts at reconciliation time.

None of that is glamorous. None of it shows up in demos. But the agents are only as good as the infrastructure they run on. Get the plumbing wrong and your orchestrator hangs on a stale token at 3 AM. Get it right, and the agents take care of the rest.

The roadmap isn't about making the AI smarter. It's about making the platform more reliable, more observable, and more autonomous. That's the work. That's what's next.