kube memory

• 

  Landing Page

• 

  Capabilities

• 

  Connect to any IDE

• 

  15+ industry integrations

• 

  MCP connectivity through kube-memory API

Inspiration

Every DevOps team has experienced the same problem: an incident happens, someone spends hours debugging it, the issue gets fixed, and a few weeks later the exact same failure happens again. The logs still exist, the dashboards still exist, but the knowledge of why it happened and how it was resolved is usually trapped in Slack messages, forgotten runbooks, or someone's memory.

As AI coding assistants become part of everyday engineering workflows, we realized they're incredibly good at reasoning over the current state of a system—but they have no long-term memory of what an organization has already learned.

We wanted to build something that lets AI agents learn from operational experience instead of starting from scratch every time.

That became kube-memory: organizational memory for DevOps agents.

What it does

kube-memory gives AI coding assistants and CI/CD pipelines a persistent, searchable memory of an organization's infrastructure history.

Instead of only looking at the current cluster state, agents can recall similar incidents, previous fixes, deployment outcomes, and operational runbooks before deciding what to do.

Every incident follows the same lifecycle:

• Detect the symptom
• Diagnose the root cause
• Apply a remediation
• Store the outcome as organizational knowledge

The next time a similar issue appears, the agent can retrieve previous experience through semantic search and reuse what already worked.

The platform includes:

• MCP-native server that works with Cursor, VS Code, Claude Desktop and any MCP-compatible client
• Semantic memory powered by Cognee
• Workspace dashboard for integrations, API keys and configuration
• Connectors for Kubernetes, GitHub, Slack, PagerDuty, Prometheus, ArgoCD, AWS, Azure, GCP, Datadog, Splunk and Jira
• Risk prediction for planned deployments using historical incidents
• REST APIs for CI pipelines and automation

One of our favorite workflows is /kube-deploy, where an AI agent deploys an application, monitors it, investigates failures, proposes a GitHub fix, validates the deployment, and permanently stores the incident for future agents.

How we built it

We built kube-memory from the ground up as an MCP-native platform.

The backend exposes both MCP tools and REST APIs, while every workspace maintains an isolated semantic memory built on top of Cognee.

The system is composed of three major pieces:

• A secure multi-tenant backend handling authentication, RBAC, encrypted connector credentials and API key management.
• A memory layer that converts incidents, fixes, deployments and runbooks into structured operational episodes that can be semantically recalled.
• A modern dashboard where users configure integrations, generate API keys and connect their AI coding assistants.

We integrated Kubernetes, GitHub, Slack, PagerDuty, Prometheus, ArgoCD and multiple cloud providers into a single MCP surface so agents don't have to switch between dozens of different tools.

One of the most exciting parts of this project was building it alongside OpenAI Codex. Rather than using it only for code completion, we treated Codex as an engineering collaborator. It helped us iterate on APIs, refactor modules, generate integration scaffolding, speed up repetitive implementation work, and explore different architectural approaches while we focused on the overall system design and product direction.

Challenges we ran into

The biggest challenge wasn't building an MCP server—it was building a memory system that remains useful over time.

We had to figure out how incidents should be represented so that future searches return meaningful operational knowledge instead of generic vector matches. Designing a consistent "episode" model for symptoms, diagnoses, remediations and outcomes took multiple iterations.

Another major challenge was supporting many external integrations while keeping a consistent developer experience. Every platform has different authentication methods, APIs and permission models, so normalizing them behind a single MCP interface required significant engineering.

Building secure workspace isolation, role-based API keys, encrypted credential storage and reliable semantic retrieval also introduced a lot of complexity beyond what users actually see.

Finally, orchestrating an end-to-end deployment workflow that spans Kubernetes, GitHub, Slack and long-term memory required careful coordination between many moving parts.

Accomplishments that we're proud of

We're proud that kube-memory goes beyond being another AI wrapper around Kubernetes.

Instead of simply exposing infrastructure tools to LLMs, we built a system that lets AI agents accumulate operational experience over time.

Some highlights we're especially proud of:

• Building a complete MCP-native developer experience.
• Designing a reusable organizational memory model for infrastructure operations.
• Integrating a wide range of DevOps platforms behind a single interface.
• Creating an end-to-end deployment workflow that can deploy, monitor, investigate, remediate and remember.
• Shipping a production-ready dashboard with authentication, integrations and API key management.
• Using Codex throughout development to accelerate implementation while keeping the focus on product design and engineering decisions.

What's next for kube memory

Next, we want to expand kube-memory with:

• Automatic memory creation directly from incidents and postmortems.
• Cross-incident reasoning to identify recurring infrastructure patterns.
• Smarter deployment risk prediction using historical operational data.
• Richer visualizations of an organization's operational knowledge graph.
• Support for additional DevOps and observability platforms.
• Team collaboration features around shared operational knowledge.
• More autonomous AI workflows that continuously learn from every deployment and every incident.

Built With

• codex