The project

witwave is a cloud-native framework for governed autonomous agents.

The codebase is a way to run AI agent teams on Kubernetes, route real work to them, connect MCP tools and memory, observe what they are doing, and keep humans in the loop when judgment matters. It is built for agent teams, but the same pieces can support a single specialized agent.

Quick Start View the GitHub project Read the whitepapers

Run agents

Deploy named agents with durable identity, schedules, routing, memory, backend choice, and health checks.

Give them tools

Connect autonomous agents to shared workspaces and MCP tools for Kubernetes, Helm, Prometheus, and future systems.

Govern the loop

Keep work observable with metrics, traces, logs, readiness checks, explicit routing, and human escalation.

Try it

Start with the CLI and a cluster.

Install ww, point it at a Kubernetes cluster, install the operator, and create an echo-backed agent that needs no LLM API key.

bash

curl -fsSL https://github.com/witwave-ai/witwave/releases/latest/download/install.sh | sh
ww operator install --if-missing --yes
ww agent create hello --namespace witwave --create-namespace

Open Quick Start

Core thesis

Agents create leverage. Lifecycle governance compounds it.

witwave is built around a simple belief: agentic AI can help inside existing teams, hybrid workflows, and human-driven development loops. The larger shift happens when agents become part of the development system itself. Work routing, context, quality gates, memory, observability, escalation, and human judgment are not extras around autonomy. They are the control system that lets autonomy compound safely.

Read the adoption model

Agents need a lifecycle.

The important work is not just prompting a model. It is giving agents durable identity, clear lanes, reusable context, evaluation loops, memory, and a visible path from request to outcome.

Humans still own the system.

Humans define policy, own risk, review exceptions, set direction, and audit the work. The goal is leverage, not abdication.

Autonomy is not a runtime.

Moving agents from an IDE to cloud infrastructure changes operations. Trust comes from governance, observability, and feedback, not from where the process happens to run.

What the code does

The framework turns agents into deployable software infrastructure.

witwave is not just a prompt folder. The repository contains the runtime, operator, CLI, charts, backends, tool servers, and documentation needed to make autonomous agents behave more like managed services than loose chat sessions.

Agent runtime

A harness container receives work, schedules heartbeats and jobs, handles triggers and continuations, and routes each concern to the configured backend.

Backend choice

Claude, Codex, Gemini, and Echo backends expose a common A2A surface while keeping their own sessions, memory, conversation logs, and metrics.

Cloud control plane

Helm charts, Kubernetes CRDs, an operator, and the ww CLI create agents, prompts, workspaces, credentials, and deployable team topologies.

Tool layer

MCP services give agents controlled access to systems such as Kubernetes, Helm, and Prometheus without baking every capability into the agent image.

Shared context

Workspaces, prompt bundles, memory folders, identity files, and backend routing give agents continuity across sessions and across a team.

Operational posture

Health probes, metrics ports, auth boundaries, redaction, traces, dashboards, and release tooling make the agent system inspectable instead of magical.

The duality

witwave is both the framework and its proving ground.

The project uses its own agent-team model to maintain the codebase, write documentation, shape public updates, watch releases, and improve the operating process. That does not mean humans disappear. It means the project is intentionally practicing the same lifecycle it argues for: agents do real work, the work is visible, and human stewardship remains responsible for direction, risk, and judgment.

Meet the working team

For teams

Beyond chat sessions

Most organizations already know how to ask an AI for help. The harder question is how to make agents part of delivery without losing accountability, context, or quality.

For the project

Built in public, used in practice

The working team is not a separate demo. It is a live operating environment where the framework is used to coordinate maintenance, documentation, releases, outreach, and process improvement.

Community

Join the conversation.

Share ideas, report bugs, ask questions, or follow announcements and progress in GitHub Discussions.

Updates Announcements What the team just shipped — releases, critical events, and user-facing surface changes. Updates Progress What the team is working on right now — peer activity, polish progress, and events worth knowing. Participate Ideas Suggestions for what's next — features, changes, or directions worth the team's attention. Participate Bugs Bugs you've encountered — what broke, what you expected, and the fix when it lands. Participate Questions Questions and conversation — about the codebase, the team, or the autonomous-development experiment.