kagent for Amphitrite¶
Amphitrite is the Nereid that will give the platform its AI agents: a reef whose kind is Agent (plural agents), used by other Nereids for the tasks where AI does better than a deterministic step (summarise, catalogue, classify). The Agent does not name its engine: it points at a mandate that says which gateway and model to use, as a PersistentVolumeClaim points at a StorageClass, so swapping LiteLLM for OpenRouter is swapping the mandate. Triton, the coordinator of the agents, is the first Agent. "Native first, build last" (vision) asks whether an open-source tool already does this; this page evaluates kagent, compares it briefly with the alternatives, and records a first end-to-end run of Triton on k3d with a tiny local model through Ollama. It answers the beach order 20261028-1708-evaluate-kagent-for-amphitrite-resend. Facts come from pages opened on 2026-10-28, linked inline and in Learn more; repository figures were read from the GitHub API that day; what the run on k3d showed is marked as our own observation.
Recommendation¶
Adopt kagent as the Tool of the Amphitrite Nereid, behind a thin Nereus reef: wrap it, do not build our own runtime and do not expose kagent's CRDs as the platform's API.
- Adopt the runtime: kagent already does what we would build: a Kubernetes controller that turns an
Agentresource into a Deployment serving the agent over A2A, aModelConfigthat is exactly the StorageClass-style engine object of the design, OpenAI-compatible endpoints (LiteLLM, OpenRouter) and Ollama as providers, MCP tools, memory, a UI and a CLI. It is Apache-2.0, a CNCF Sandbox project, and very active. It ran Triton end to end on k3d in minutes (below). - Wrap it in a reef: kagent's API is
kagent.dev/v1alpha2and moving fast towards 1.0 (17 alphas in five weeks, and the chart onmainalready differs from the 0.10 docs), so other Nereids should depend on a Nereus contract, not on kagent's. The rule "the API never names a Nereid" (rules) says the same: the reef'sAgentcarries what an agent is (description, instructions, the engine's mandate, tools), and Amphitrite renders it into kagent'sAgentandModelConfig. Swapping kagent later (for Ark, say) changes the Nereid, not the Nereids that use agents. - Do not build our own CR runtime: the alternatives either are not an agent definition (Agent Sandbox, Dapr Agents) or are younger and smaller than kagent (Ark, Kagenti).
kagent¶
| Question | Answer |
|---|---|
| What it is | Kubernetes-native framework for AI agents: an agent is a resource the controller reconciles into a pod serving the agent over A2A (repo) |
| Started by | Solo.io; CNCF Sandbox since 2025-05-22 (CNCF) |
| Licence | Apache-2.0 (repo) |
| Activity (2026-10-28) | about 4.1k stars, about 213 contributors, repository created 2025-01-21; releases v0.10.4 and v1.0.0-alpha17, both 2026-10-21; 17 v1.0 alphas between 2026-09-18 and 2026-10-21; 100+ commits on the default branch in the last month (releases) |
| API | kagent.dev/v1alpha2 (also serves v1alpha1) (API reference) |
| CRDs installed by chart 0.10.4 | Agent, ModelConfig, ModelProviderConfig, RemoteMCPServer, MCPServer, ToolServer, Memory, SandboxAgent, AgentHarness (our observation, kubectl get crd); the API reference documents the first four plus SandboxAgent and AgentHarness, memory as declarative.memory (API reference) |
| Agent types | Declarative (model, system message, tools, on kagent's runtime, go by default or python) or BYO (your own image serving A2A on port 8080) (API reference; kubectl explain agent.spec) |
| Tools | MCP servers (RemoteMCPServer, up to 20 tools per agent) and other Agents as tools (API reference) |
| Invocation | A2A on the controller, port 8083: /api/a2a/<namespace>/<agent>/; kagent invoke --agent <name> --task "..." (A2A example) |
Model providers: LiteLLM and OpenRouter¶
ModelConfig.spec.provider is one of Anthropic, OpenAI, AzureOpenAI, Ollama, Gemini, GeminiVertexAI, AnthropicVertexAI, Bedrock, SAPAICore, Foundry (API reference).
- LiteLLM: yes.
provider: OpenAIwithopenAI.baseUrltakes any OpenAI-compatible endpoint; the "BYO OpenAI-compatible model" page shows kagent in front of a LiteLLM proxy (BYO OpenAI-compatible). - OpenRouter: yes by the same field, not documented. OpenRouter has no page among the supported providers (providers); its API is OpenAI-compatible at
https://openrouter.ai/api/v1(OpenRouter quickstart), so it is the sameopenAI.baseUrlcase. Not run yet: it needs a key. - The path is proven: the Triton run below uses
provider: OpenAIwithbaseUrlpointing at Ollama's OpenAI-compatible/v1(Ollama docs), the same mechanism LiteLLM and OpenRouter would use (our observation). - Ollama natively:
provider: Ollamawithollama.host(Ollama provider). - Caveat: the agent sends tool definitions; a backend without automatic tool choice (vLLM without it) fails every turn with a 400 (BYO OpenAI-compatible).
Install footprint on k3d¶
Chart 0.10.4, with the ten built-in agents, kagent-tools, kmcp and grafana-mcp turned off (values below), our observation:
| Pod | Image | Requests |
|---|---|---|
kagent-controller |
ghcr.io/kagent-dev/kagent/controller:0.10.4, 42 MB |
100m, 128Mi |
kagent-ui |
ghcr.io/kagent-dev/kagent/ui:0.10.4, 136 MB |
100m, 256Mi |
kagent-postgresql (bundled, "for development and evaluation only") |
postgres:18.6-alpine3.23, 120 MB |
250m, 256Mi |
one per Agent (triton) |
ghcr.io/kagent-dev/kagent/golang-adk:0.10.4, 38 MB |
100m, 384Mi |
The whole k3d node used about 970 MiB of memory with Triton running. The UI has no enabled flag in the chart. The default install (installation) adds ten agents and the tool servers; kagent install --profile minimal installs none.
What to watch¶
- Security: the controller's
auth.modedefaults tounsecure: a caller who reaches port 8083 acts asadmin@kagent.dev(chart values,controller.auth). Amphitrite must install it withtrusted-proxy(oauth2-proxy in front) or keep the controller unreachable outside the cluster; the authentication reef is the natural front. This is OWASP A01 (Broken Access Control) and A07 (Identification and Authentication Failures). - The bundled Postgres is for evaluation only; a real install points
database.postgres.urlat a database of the platform. - API churn: v1alpha2 and a 1.0 in alpha; the reef shields the other Nereids from it.
- Unknown: how the 1.0 Substrate runtime changes the footprint.
Alternatives¶
| Project | Licence and status | What it is | Why not first |
|---|---|---|---|
| Ark (McKinsey) | Apache-2.0, about 432 stars, v0.1.72 on 2026-10-21 | Kubernetes CRDs Agent, Model, Team, Query, Tool, MCPServer, A2AServer, Memory (docs) |
Closest model (a Model the Agent references, Team for coordination); younger and ten times smaller; the second candidate if kagent stalls |
| Kagenti | Apache-2.0, about 302 stars, docs at v0.7.0; the repository now redirects to rossoctl/rossoctl |
Framework-neutral platform for agent identity, authorisation, tools and sandboxes, A2A and MCP | Its CRDs are not documented in the README; in transition |
| Agent Sandbox (kubernetes-sigs, SIG Apps) | Apache-2.0, about 4.4k stars, v1.0.8 on 2026-10-22 | Sandbox, SandboxClaim, SandboxTemplate, SandboxWarmPool (agents.x-k8s.io/v1beta1) |
Runtime isolation, not an agent definition: a possible layer under Amphitrite for agents that run code |
| Dapr Agents | Apache-2.0, under the CNCF Dapr project, about 767 stars, v1.1.0 on 2026-10-27 | Python framework for durable agents on Dapr | A library, no agent CRD |
LangGraph Platform and Kubeflow were not evaluated.
Triton under the recommendation¶
The reef's Agent, what other Nereids and the CLI write. The reef's name and the shape of the mandate are open questions (below); this draft assumes a reef agent and a second reef model whose mandates are the engines (Nereids ollama, litellm, openrouter):
apiVersion: agent.getnereus.dev/v1alpha1
kind: Agent
metadata:
name: triton
spec:
description: Triton, the coordinator (mediator) of the platform's agents.
instructions: |
You are Triton, the coordinator of the Nereus platform's agents.
Answer in one short sentence.
model:
mandate: local # model reef mandate: Nereid ollama, model qwen2.5:0.5b
tools: []
Moving Triton to the Anthropic API later changes only mandate: (for example anthropic), never the Agent's other fields. Amphitrite renders it into kagent's objects, the ones applied by hand in the run below.
The first end-to-end run¶
Agent → ModelConfig → Ollama → answer, on 2026-10-28 (our observation). The quality of the answer does not matter; the flow does.
- Model:
qwen2.5:0.5b(about 400 MB), pulled into the Ollama already installed on the machine (0.20.7, systemd service on127.0.0.1:11434). - Wiring: Ollama listens only on loopback, so a
socatcontainer on the host network forwards the k3d network's gateway (host.k3d.internal, here192.168.240.1) to it; Ollama's own config stays untouched. TheModelConfigusesprovider: OpenAIwithbaseUrl: http://host.k3d.internal:11434/v1, the path LiteLLM and OpenRouter would take. - Result: Triton answered "I am an agent designed to help users smoothly interact with Nereus, the platform for coordinating AI research." The first call took about 50 s (the model loading), the second about 5.5 s.
To reproduce:
ollama pull qwen2.5:0.5b
k3d cluster create amphitrite \
--no-lb \
--k3s-arg '--disable=traefik@server:0' \
--wait
gateway="$(docker network inspect k3d-amphitrite --format '{{(index .IPAM.Config 0).Gateway}}')"
docker run \
--detach \
--name amphitrite-ollama-bridge \
--network host \
alpine/socat \
"TCP-LISTEN:11434,bind=${gateway},fork,reuseaddr" \
TCP:127.0.0.1:11434
cat > minimal-values.yaml <<'EOF'
providers:
default: ollama
ollama:
provider: Ollama
model: "qwen2.5:0.5b"
config:
host: host.k3d.internal:11434
kmcp: {enabled: false}
kagent-tools: {enabled: false}
grafana-mcp: {enabled: false}
k8s-agent: {enabled: false}
kgateway-agent: {enabled: false}
istio-agent: {enabled: false}
promql-agent: {enabled: false}
observability-agent: {enabled: false}
argo-rollouts-agent: {enabled: false}
helm-agent: {enabled: false}
cilium-policy-agent: {enabled: false}
cilium-manager-agent: {enabled: false}
cilium-debug-agent: {enabled: false}
EOF
helm install kagent-crds oci://ghcr.io/kagent-dev/kagent/helm/kagent-crds \
--kube-context k3d-amphitrite \
--version 0.10.4 \
--namespace kagent \
--create-namespace
helm install kagent oci://ghcr.io/kagent-dev/kagent/helm/kagent \
--kube-context k3d-amphitrite \
--version 0.10.4 \
--namespace kagent \
--values minimal-values.yaml \
--wait
kubectl --context k3d-amphitrite apply -f - <<'EOF'
apiVersion: v1
kind: Secret
metadata:
name: triton-local-engine
namespace: kagent
stringData:
OPENAI_API_KEY: ollama # Ollama ignores the key; LiteLLM or OpenRouter need a real one
---
apiVersion: kagent.dev/v1alpha2
kind: ModelConfig
metadata:
name: triton-local-engine
namespace: kagent
spec:
provider: OpenAI
model: qwen2.5:0.5b
apiKeySecret: triton-local-engine
apiKeySecretKey: OPENAI_API_KEY
openAI:
baseUrl: http://host.k3d.internal:11434/v1
---
apiVersion: kagent.dev/v1alpha2
kind: Agent
metadata:
name: triton
namespace: kagent
spec:
description: Triton, the coordinator (mediator) of the platform's agents.
type: Declarative
declarative:
modelConfig: triton-local-engine
systemMessage: |
You are Triton, the coordinator of the Nereus platform's agents.
Answer in one short sentence.
EOF
kubectl --context k3d-amphitrite --namespace kagent wait \
--for=condition=Ready agent/triton \
--timeout=300s
kubectl --context k3d-amphitrite --namespace kagent port-forward svc/kagent-controller 8083:8083 &
curl --silent http://localhost:8083/api/a2a/kagent/triton/ \
--header 'Content-Type: application/json' \
--data '{"jsonrpc":"2.0","id":"1","method":"message/send","params":{"message":{"kind":"message","role":"user","messageId":"m1","parts":[{"kind":"text","text":"Who are you?"}]}}}' \
| jq --raw-output '.result.artifacts[0].parts[0].text'
To clean up: k3d cluster delete amphitrite and docker rm --force amphitrite-ollama-bridge.
Open questions¶
- The reef's name and group:
agent.getnereus.dev(kindAgent, pluralagents) is a draft. - Where the model lives: a second reef
model(Nereidsollama,litellm,openrouter, its mandates naming gateway and model) or the model as a parameter of Amphitrite's own mandate. ADR 0011 (a Mandate binds one reef to one Nereid) fits the first: the Agent references a mandate of themodelreef. - Does Amphitrite expose kagent's tools and memory in the first slice, or only description, instructions and model?
- The UI and Postgres: keep kagent's UI (no flag to turn it off) and point it at a database of the platform, or wait for the 1.0 chart.
Learn more¶
- kagent and its repository, releases, API reference, installation, supported providers, BYO OpenAI-compatible model, Ollama, A2A agents, Helm reference.
- kagent at the CNCF.
- OpenRouter quickstart (the OpenAI-compatible base URL).
- Ark and its docs, Kagenti, Agent Sandbox, Dapr Agents.
- Ollama's OpenAI compatibility.