Show HN: Axon – A Kubernetes-native framework for AI coding agents

[gjkim042]

Hi HN, I originally started this project simply to safely run autonomous coding agents (like Claude in auto-mode) in isolated environments. But as I built it, I realized the potential was much bigger than just sandboxing: it's about making a coding agent callable like a standard API, and ultimately, defining your entire development workflow as infrastructure.

Axon is a Kubernetes-native framework that abstracts the coding agent itself. By standardizing the container interface, you can seamlessly plug in Claude, Codex, Gemini, OpenCode, or your own custom images without changing your orchestration.

How it works under the hood:

The architecture relies on standard K8s CRDs (Tasks, Workspaces, TaskSpawners, and AgentConfigs).

A Task is the fundamental unit of work for a coding agent. When a Task is created, Axon spins up an ephemeral Pod with a freshly cloned git workspace to execute it.

You use an AgentConfig to declaratively define the specific rules, custom skills, and MCP (Model Context Protocol) servers the agent is allowed to access during that Task.

A TaskSpawner reacts to GitHub events (like a new issue or PR) and automatically generates these Tasks on the fly.

Deterministic outputs (branch names, PR URLs, token usage) are captured directly back into the K8s resource status.

To test this, I built a fully autonomous self-development pipeline. It actively triages issues, suggests new features, finds bugs, and writes the code to fix them. It uses standard GitHub issues and PR comments as the feedback loop to guide the agents. You can see how that is wired together here: https://github.com/axon-core/axon/tree/main/self-development

The main repo is here (with demo video): https://github.com/axon-core/axon

I’d love to get your real-world feedback—especially on the CRD design, the container abstraction model, and what new features you would need to actually integrate this into your workflows.

[jcalloway_dev]

Really cool project. The self-development pipeline demo is what sold me — that's not just a toy, that's a proof of a real workflow pattern.

Few things I'm genuinely curious about:

On the CRD design — how are you handling secret/credential scoping per Task? Ephemeral pods are great for isolation, but if AgentConfigs can reference MCP servers, there's a credential surface area question worth thinking through early before people wire this into production pipelines.

On the container abstraction — does the standardized interface currently enforce any output schema validation, or is it mostly convention right now? Would love to know how strict that contract is in practice.

On adoption friction — K8s-native is powerful but raises the floor pretty high. Have you considered a lighter local mode (kind/minikube) with pre-baked configs to let people prototype workflows before committing to a full cluster setup?

Genuinely interested in where this goes. Watching the repo.

[gjkim042]

About handling secret/credential scoping, there’s todo issue to reference kubernetes secret from mcp config. https://github.com/axon-core/axon/issues/313

[gjkim042]

about the agent container interface,

It’s mostly about the inputs not the outputs. (How to inject prompts, context, skills…)

However, axon is trying to provide deterministic outputs such branch, PR link, etc, by executing a post script.

[gjkim042]

about the adoption friction, You can easily use it by kind create cluster + axon install.

Thanks for your interest. (Sorry for the late interaction, I thought the post was just abondoned.)