Related Projects
A common first question is “how is this different from X?” This page answers it for the projects people ask about most. Each entry says what the project is, where it overlaps with Kubemoot, and where the two differ. Several of these are the better choice for some jobs, and the entries say so. Descriptions of other projects are summaries of their own documentation; read their sites for the current picture.
Other projects run an agent, serve a model, or sandbox code on Kubernetes. Kubemoot convenes them into a crew that decides together, so most of these entries are as much about what Kubemoot builds on or can convene beside as about how it differs. Kubemoot builds the moot, the scheduling across accelerators, governance as code, and fitness evidence. It stands on MCP for tools, NATS for the message bus, and vLLM and Ollama for model serving, each behind a swappable seam. Other harnesses can sit at the table: goose already holds a seat, and kagent agents or agents built with a framework are directions, not shipped integrations.
For Kubemoot’s own position, see Why Kubemoot and the Questions page.
Kubernetes-native agent platforms
kagent
kagent describes itself as a Kubernetes native
framework for building AI agents. It is a CNCF Sandbox project under the Apache 2.0
license, started by Solo.io. It defines agents as Kubernetes
custom resources (Agent, ModelConfig, RemoteMCPServer, MCPServer), runs them on
Google’s Agent Development Kit, and every kagent agent speaks the A2A protocol.
Kubemoot is meant to run beside kagent, not replace it. kagent makes a single agent a first-class Kubernetes resource; Kubemoot builds the crew around agents. A kagent agent joining a crew over A2A is an idea under consideration, not something that ships today.
- Overlap: both declare agents as Kubernetes custom resources and manage them with
kubectl. An agent in kagent is a system prompt, a set of tools and agents, and an LLM configuration. Both connect agents to tools through MCP servers. - Differences: kagent lists OpenAI, Azure OpenAI, Anthropic, Google Vertex AI, and Ollama as model servers and ships MCP tool servers for Kubernetes, Istio, Helm, Argo, Prometheus, Grafana, and Cilium, and reports OpenTelemetry tracing. Kubemoot’s hosted-model servers are not yet implemented (vLLM and Ollama are the model servers today) and it does not emit OpenTelemetry traces yet, so kagent is the better fit if you want agents backed by hosted models, standard tracing, or a ready set of cluster-operations tools. Kubemoot adds three things on top of the declarative agent: a consensus protocol between agents (each specialist can agree, raise a concern, object, or abstain, and a coordinator synthesizes the answer), a scheduler that picks a model server for each inference call, and fitness functions that score a crew over time.
Agent Sandbox
Agent Sandbox is a Kubernetes SIG
Apps project (not a CNCF project). It has a 1.0 release, but its APIs are still v1beta1. It
provides a Sandbox custom resource for isolated, stateful, singleton pods with a
stable identity, persistent storage, and pause and resume. Extensions add
SandboxTemplate, SandboxClaim, and SandboxWarmPool for templated, claimable, and
pre-warmed sandboxes. Isolation comes from gVisor or Kata Containers through a
Kubernetes RuntimeClass. It ships Go and Python SDKs and an optional Sandbox Router.
- Overlap: Kubemoot’s compute agent runs the code it writes in a pod-level
code sandbox, the
code-sandboxMCP server. Agent Sandbox addresses the same need, a safe place to run untrusted, model-written code, with stronger isolation and a standard resource. - Differences: Agent Sandbox is a workload primitive. It does not define agents, prompts, models, or how agents work together, so it does not replace crews, consensus, ADL governance, or fitness. Kubemoot does not use it today. A gVisor runtime class for the code sandbox is the first step, and Agent Sandbox with a warm pool fits its disposable runs, a direction on the Roadmap.
- Background: Kubernetes Podcast episode 268, “Agent Sandbox and Lovable”.
Agent Substrate
Agent Substrate is a standalone, Google-originated Apache-2.0 project (not part of Kubernetes SIGs; it has applied to the CNCF Sandbox). It is pre-1.0. Because agents are idle most of the time, it multiplexes many agent “actors” onto a smaller set of worker pods, checkpointing an actor when it goes idle and restoring it in well under a second, with gVisor or microVM isolation.
- A project we watch. It is packaged for GKE only and publishes no public images, and Kubemoot pins every dependency by digest, so there is nothing to pin. Kubemoot does not depend on it and makes no commitment to run agents on it. Kubemoot builds isolation, network policy, scale to zero, and identity on plain Deployments. See Agents on plain Deployments.
- Background: Kubernetes Podcast episode 272, “Agent Substrate”.
Both projects address density, isolation, and fast resume, and they solve different problems: Agent Sandbox gives one isolated, stateful pod per sandbox, and Substrate packs many idle agents onto a shared pool of workers. Agent Sandbox is covered in Kubernetes Podcast episode 268 and Agent Substrate in episode 272.
In-process multi-agent frameworks
These are libraries. You write agents in code, and the framework runs them inside your application process. Kubemoot runs crews as Kubernetes services declared in YAML. The Orchestration Gap page explains why that distinction matters. If one application, a notebook, or a prototype is the goal, a library is usually the right tool.
CrewAI
CrewAI is a standalone Python framework for orchestrating role-playing, autonomous agents. Its Crews are teams of agents that delegate tasks to one another, and its Flows are event-driven workflows with fine-grained control.
- Overlap: the “crew” vocabulary and the idea of role-based agents working together.
- Differences: CrewAI’s crew is Python objects in a process that you deploy
yourself. A Kubemoot
Crewis a Kubernetes resource that the operator reconciles, with agents that deliberate to consensus rather than pass tasks along. - Direction: CrewAI is a harness Kubemoot can convene, not only an alternative. An agent written with CrewAI could sit at the table as one voice through the Moot Mesh sidecar, with the crew’s own tools. That is an idea under consideration; no CrewAI integration ships today.
LangGraph
LangGraph is a low-level orchestration framework for stateful agents. Its stated strengths are durable execution, human oversight of agent state, and short-term and long-term memory.
- Overlap: long-running, stateful multi-step agent work.
- Differences: LangGraph gives you a graph you define in code, with fine control of the control flow. Kubemoot fixes the control flow (the consensus discussion) and declares the participants. LangGraph is the better fit when you need to design a bespoke workflow.
AG2 and AutoGen
AG2 is an open-source programming framework for
building agents and getting multiple agents to cooperate, with multi-agent
conversation patterns. It grew out of AutoGen; the classic AutoGen-style code lives in a
separate ag2-classic repository. Microsoft’s
AutoGen is in maintenance mode, and its README
points new users to Microsoft Agent Framework.
- Overlap: multi-agent conversation as the way to reach an answer.
- Differences: same as the other libraries: code in a process versus resources on a cluster.
Model serving and inference routing
These projects serve models. Kubemoot does not replace them; it sits above a model server. Today Kubemoot drives vLLM, which is currently preferred, and Ollama, the engine of the quickstart. Reading the state of other servers, and the projects below in particular, is under assessment on the Roadmap and is not shipped.
Ollama
Ollama runs open models locally through a REST API, powered by the llama.cpp inference engine. It is the model server of the Kubemoot quickstart and remains supported. Ollama serves models; Kubemoot decides which model server and model serve each inference call and coordinates the agents that use them.
vLLM
vLLM is a library for LLM inference and serving.
Its README lists continuous batching, prefix caching, PagedAttention, distributed
inference, and an OpenAI-compatible API server. Kubemoot drives vLLM through a vllm
ModelServer, and vLLM is currently the preferred engine for an installation (see the
measured results). Kubemoot does not
run vLLM: you install it, for example with the kubemoot-vllm chart, and point a
ModelServer at it.
KServe
KServe is a distributed generative and predictive AI inference platform for Kubernetes. For LLMs it supports vLLM and llm-d backends, an OpenAI-compatible protocol, model caching, and request-based autoscaling. If you need to deploy and scale model servers as Kubernetes resources, use KServe; Kubemoot does not deploy model servers of that kind. It is an agent layer that would sit above one.
llm-d
llm-d is a distributed inference serving stack for Kubernetes and a CNCF sandbox project. It provides prefix-cache and load-aware routing, tiered KV-cache management, and prefill/decode disaggregation. It routes and serves requests for one deployment of a model. Kubemoot decides across models and crews. Assessing llm-d is on the Roadmap.
Gateway API Inference Extension
The Gateway API Inference Extension is an official Kubernetes project that makes gateways inference-aware. Its Endpoint Picker routes requests using model server metrics such as cache status and adapter availability. Kubemoot’s engine-state contract aligns with its Model Server Protocol, as described on the Roadmap.
KAITO
KAITO is an operator suite that automates LLM inference, fine-tuning, and RAG engine deployment in a Kubernetes cluster, including automatic GPU node provisioning. It solves how models get deployed onto GPUs. Kubemoot schedules inference onto model servers that already run and does not provision accelerator nodes.
MCP gateways and tool infrastructure
agentgateway
agentgateway is an open-source proxy for agentic AI, a Linux Foundation project. It provides an LLM gateway, an MCP gateway, and an agent-to-agent (A2A) gateway, and runs on Kubernetes with Gateway API support. It was started by Solo.io and is hosted by the Agentic AI Foundation. One gateway carries LLM requests, MCP tool calls (with per-tool authorization), and A2A traffic.
- Overlap: both put MCP tools behind a gateway. Kubemoot has its own
MCPGatewayandMCPServerresources (see the MCPGateway guide and MCP Tools). - Differences: agentgateway is general connectivity infrastructure that any agent framework can use. Kubemoot’s gateway is built into the crew model and onboards tools for the crew’s own agents. If you need a shared, security-focused proxy for many frameworks, agentgateway is the specialist.
- Direction: Kubemoot is meant to run beside agentgateway. It is the first candidate Kubemoot intends to evaluate behind its tool gateway, to keep credentials out of tool processes. That is intent, not a shipped integration.
Solo.io
Solo.io started both kagent and agentgateway, and also sells enterprise editions of them. It has shown kagent running on Agent Substrate (see Agent Substrate). Kubemoot focuses on crews of agents reaching consensus on shared accelerators, and treats these projects as neighbors to run beside.
Memory interchange
Open Memory Protocol Initiative (OMPI)
The Open Memory Protocol Initiative (OMPI) is an open effort, hosted at the AI Disclosures Project and co-convened with IBM and Mozilla, to define how agent memory is stored, scoped, and exchanged between tools. Its Open Memory Protocol specification is in development, written first for single-user coding agents. Kubemoot runs goose as an agent harness, and goose is named among the project’s participants.
- Overlap: both treat memory as something an agent keeps across sessions, with scope, provenance, and a lifecycle.
- Differences: OMPI specifies the memory format and its operations, not the agents or how they work together. Kubemoot’s memory is shared by many agents in a crew, which the first OMPI use cases do not center on.
- Today: Kubemoot exports a crew’s memory in the OMPI interchange format with
kmctl memory export, follows the newest OMPI working spec, leaves out any fact that holds a credential, and checks the export against OMPI’s own checker. Importing is not supported, and OMPI has not certified the export. - Direction: Kubemoot is meant to be an implementer of the protocol for crews, and to report to OMPI what the format does not yet cover. See Durable crew memory on the Roadmap.
Evaluation frameworks
Kubemoot’s fitness functions score a crew’s answers against references, and the score is tracked as the crew changes. These frameworks evaluate LLM applications more generally.
- promptfoo is a CLI and library for evaluating and red-teaming LLM apps, with CI/CD integration and side-by-side model comparison.
- DeepEval is a Pytest-style framework for unit testing LLM applications, with metrics such as faithfulness and hallucination detection and evaluation of agent trajectories.
- Inspect, from the UK AI Security Institute, is a framework for model evaluations with more than 200 pre-built evaluations.
They are general-purpose and run wherever your code runs. Kubemoot’s fitness functions are specific to crews: they run in the cluster as resources against the deployed crew, and they score consensus behavior as well as answers. If you already evaluate a single model or prompt, these tools are the mature choice; they can also be used alongside a crew.
Next: Why Kubemoot or the Roadmap.