KAIROS: Claude Code's Self-Running Perpetual Agent

Claude Code changed the way developers work. Instead of writing each line of code, you describe what you want and the AI ​​executes it. But there is a fundamental limitation in this model:you need to be present. You ask, the AI ​​does it, you check, you ask again. And a cycle that depends on humans at each stage.

KAIROS eliminates this dependency. Found in leaked source code from Claude Code in March 2026, KAIROS is a perpetual agent system -- an AI that runs continuously in the background, monitors your project, identifies problems, and performs taskswithout needing you to tell what to do at every moment. It's the difference between having an assistant who waits for your orders and having a co-worker who takes initiative.

This article explains everything we know about KAIROS: what and how it works, which complementary systems were found in the code, and what this means for the future of software development.

1. How KAIROS was discovered

The Claude Code source code leak in March 2026 revealed more than bugs and optimizations. It revealed Anthropic's strategic direction for the coming months. Between Easter eggs like the Claude Buddy and performance improvements, developers found something much more significant: a complete system of autonomous agents.

The name "KAIROS" appears in multiple source code files, always associated with concepts of continuous execution, automatic monitoring and autonomous decision making. It is not an abandoned prototype -- the code is structured, documented internally and connected to other systems that were also found in the leak.

The community quickly identified three interconnected systems:

• KAIROS:the perpetual agent that runs in the background
• ULTRAPLAN:a long-term remote planning mode
• Coordinator + Agent Swarms:multi-agent coordination infrastructure

Together, these systems represent a qualitative leap in what Claude Code can do. It is no longer a tool that answers questions. And a tool thatworks on his own.

2. What is KAIROS: always-on agent

In the current Claude Code model, the interaction follows a simple pattern: you open the terminal, give an instruction, Claude executes it, you evaluate the result. When you close the terminal, Claude stops. When you open it again, it starts from scratch (or resumes a saved context, but without having done anything in between).

KAIROS reverses this model. He is an agent whocontinues running even when you are not interacting. Think of it as a daemon -- a background process that monitors, reacts, and executes autonomously.

What KAIROS does in the background

Based on the code found, KAIROS is capable of:

• Monitor changes to the project:detects when files are changed (by you or other devs) and evaluates whether the changes introduce problems
• Automatically fix errors:If a test breaks after a commit, KAIROS can identify the cause and apply the fix without human intervention
• Run scheduled tasks:you can leave instructions for KAIROS to execute at certain times or when certain conditions are met
• Maintain code quality:run linters, check conventions, update dependencies -- all continuously and silently
• Respond to events:when a PR is opened, when an issue is created, when a deploy fails -- KAIROS can take predefined actions

3. ULTRAPLAN: 30-minute remote planning

One of the most impressive systems found alongside KAIROS and ULTRAPLAN. While KAIROS is focused on continued execution, ULTRAPLAN is focused ondeep planning.

The concept is simple but powerful: you give the system a complex task, and it spends up to 30 minutes analyzing, planning, and decomposing the task before doing anything. It's not 30 minutes of execution -- it's 30 minutes ofpure thought.

How ULTRAPLAN works

The difference between ULTRAPLAN and simply asking "migrate from Express to Fastify" and thedepth of analysis. In normal mode, Claude Code starts running immediately -- fast, but prone to errors in complex tasks. ULTRAPLAN takes real time to understand all the ramifications before touching any file.

ULTRAPLAN use cases

• Large migrations:change framework, change database, update major version
• Complex refactorings:change architecture from monolith to microservices
• New transversal features:add authentication, internationalization, permissions system
• Debugging systemic issues:degraded performance, memory leaks, race conditions

The crucial point: ULTRAPLAN can run while you do something else. You start planning, go out for coffee, and when you come back the plan is ready for review. It is the first step towards asynchronous work with AI.

4. Coordinator: multi-agent coordination

KAIROS alone and powerful. But the real potential comes when you combine it with Coordinator -- the multi-agent coordination system also found in the code.

The Coordinator is the layer that allows multiple agents to work together on the same project without conflicts. Think of it as a project manager who distributes tasks, avoids duplicate work, and resolves conflicts between agents.

Coordinator Architecture

Component	Function
Task Queue	Queue of prioritized tasks that agents consume
Lock Manager	Prevents two agents from editing the same file at the same time
State Sync	Keeps all agents updated on project status
Conflict Resolution	Resolves situations where agents reach contradictory conclusions
Progress Tracker	Monitors the progress of each agent and reports to the user

In practice, Coordinator allows scenarios such as: one agent works on the frontend, another on the backend, another on tests -- all at the same time, without stepping on each other's work. The Coordinator ensures that each agent's changes are compatible with each other.

5. Agent Swarms: cluster scheduling

The third pillar of the KAIROS infrastructure is Agent Swarms -- literally, swarms of agents. It is the system that scales multi-agent coordination to dozens or hundreds of simultaneous agents.

If the Coordinator manages 3-5 agents in a project, Agent Swarms manageentire clustersof agents working on multiple projects, multiple repositories and multiple tasks in tollel.

Smart Scheduling

The Agent Swarms cluster scheduler distributes tasks based on:

• Estimated complexity:simple tasks go to "light" agents (Haiku), complex tasks to "heavy" agents (Opus)
• Dependencies:tasks that depend on others are scheduled in the correct order
• Priority:critical bugs before features, features before refactoring
• Available resources:distributes load to avoid API bottlenecks
• History:agents that were successful in similar tasks are prioritized for tasks of the same type

In practice, Agent Swarms allow for scenarios that today seem like science fiction: you arrive at work on Monday and discover that KAIROS, using a swarm of 20 agents over the weekend, migrated the entire test suite to a new framework, updated 300 dependencies and resolved 47 backlog issues. All while you slept.

6. Agent Teams vs KAIROS: episodic and persistent

This is the most common confusion. Claude Code already has Agent Teams -- the ability to run multiple agents in tollel to perform tasks. So what is the difference for KAIROS?

The difference andfundamentaland can be summed up in one word: persistence.

Feature	Agent Teams (current)	KAIROS (future)
Start	You start manually	Runs automatically
Duration	Until the task is finished	Continuous (always-on)
Supervision	You follow in real time	Runs in the background, reports when necessary
Scope	A specific task	The entire project, continuously
Reactivity	Does not react to external events	Reacts to commits, PRs, issues, deploys
Planning	Immediate (starts executing)	ULTRAPLAN (can plan for 30 min)
Memory	Session context	Long-term project memory
Analogy	Freelancer hired by task	Dedicated full-time employee

Agent Teams areepisodic: you ask for something, agents execute it, result delivered, end. It's useful, it's powerful, but it depends on you for each new task.

KAIROS andpersistent: it runs all the time, knows your project deeply, accumulates context over days and weeks, and takes initiative based on rules and standards that you define. You don't need to ask it to check whether the tests are passing -- it does that itself, continually.

Complementary and substitutes

It is important to understand that KAIROS does not replace Agent Teams. They are complementary. KAIROS is the agent that takes care of the day-to-day running of the project in the background. When a large, complex task arises, KAIROS can invoke Agent Teams to perform that specific task while it continues to monitor the rest.

Think of KAIROS as the CTO of the project and Agent Teams as the dev team that the CTO coordinates when necessary.

7. How KAIROS works technically

Based on the code found, the KAIROS technical architecture has five main components:

1. Process Manager

KAIROS runs as a setote process from the interactive Claude Code. It is started as a daemon (background process) that persists between sessions. When you close the terminal, KAIROS continues running.

2. Event System

KAIROS connects to project event sources: file system watches, GitHub/GitLab webhooks, results ofCI/CD, monitoring metrics. Each event is evaluated against user-configured rules.

3. Decision Engine

When an event arrives, the Decision Engine determines the action. For simple decisions (lint fix, trivial test), the engine acts automatically. For complex decisions (large refactoring, architecture change), it scales to the Opus model and/or notifies the user.

4. Memory Store

KAIROS maintains a project context database that grows over time. Unlike the session context (which resets), the Memory Store is persistent. He remembers that function X was refactored 3 weeks ago, that dev Y prefers testing with Jest, that module Z has a known bug that is being monitored.

5. Communication Layer

KAIROS communicates with the user through multiple channels: terminal notifications (when Claude Code is open), periodic summaries (via log file or webhook), and urgent alerts (for decisions you cannot make alone).

8. How this changes the dev workflow

The impact of KAIROS on workflow is not incremental. And a todigm shift. See how a dev's day-to-day life changes:

Before KAIROS (current model)

1. Dev arrives, opens the project, sees that tests failed in CI
2. Investigate the cause (15-30 min)
3. Fix the problem
4. Run tests locally
5. Commit, push, wait CI
6. Start working on the planned feature
7. Finds outdated dependency, stops to update
8. Colleague PR review (20-40 min)
9. Return to the feature
10. End of the day: feature 60% complete

With KAIROS

1. Dev arrives, opens the project
2. KAIROS reports: "Fix the test that failed at 3am, I already fixed it and merged it. I updated 3 patch dependencies. I reviewed the colleague's PR -- no security problems, I suggested 2 minor improvements."
3. Dev starts working on the planned feature immediately
4. End of the day: feature 100% complete

The difference is not justproductivity. E focus. KAIROS absorbs all the operational work that fragments the developer's attention throughout the day. Fixing tests, updating deps, reviewing trivial PRs, cool lints -- all of this leaves the dev's plate and goes to the agent.

The dev as architect

With KAIROS taking care of operational execution, the role of the dev changes. Instead of being the one who writes code, the dev becomes the one whosets direction, makes architectural decisions and supervises the agent. It is an elevation of the role: from executor to supervising architect.

This doesn't mean that devs stop coding. It means that time spent coding is focused on what really matters: complex problems, design decisions, creative work. The repetitive and mechanical work is left to KAIROS.

9. Implications for automation

KAIROS doesn't just affect developers. The implications for process automation are broad:

Continuous DevOps

Today, CI/CD pipelines are static scripts: if X happens, do Y. With KAIROS, the pipeline gains intelligence: if X happens, it evaluates the context, decides between Y, Z or W, executes and monitors the result. Pipelines stop being scripts and become agents.

Preventive maintenance

KAIROS can identify patterns that precede problems. If it notices that every time function X is changed the integration tests fail, it can proactively alert when someone touches that function -- before the problem happens.

Automated onboarding

New team members could have a dedicated KAIROS that explains the project, guides through the codebase, and answers questions with in-depth context about historic architectural decisions. KAIROS knows why every decision was made because it was there when it happened.

Living documentation

Instead of static documentation that goes out of date within days, KAIROS can maintain documentation that automatically updates as the code changes. Did you change an API? KAIROS updates the documentation in the same second.

10. Risks and concerns

Not all about KAIROS and optimism. The community raised legitimate concerns that deserve discussion:

Autonomy without supervision

An agent acting alone can make errors that propagate. If KAIROS "fixes" a test by making the test less rigorous instead of fixing the code, it can mask real bugs. The question ofhow much autonomy to give the agentIt is central and there is no easy answer.

The code found suggests that Anthropic thought of this: there are configurable autonomy levels (only monitor, suggest actions, execute with approval, execute automatically). But the temptation to increase autonomy to gain productivity is real.

Computing cost

An always-on agent continually consumes tokens. Monitoring a project, evaluating events, making decisions -- all of this uses the model API. For large projects with many events, the cost can be significant. The scheduling system that uses smaller models (Haiku) for triage and larger models (Opus) for decisions is a mitigation, but does not eliminate the cost.

Dependency and skill atrophy

If KAIROS does the operational work, devs may lose the ability to do it manually. Just as GPS atrophied the ability to navigate, KAIROS can atrophy the ability to debug, code review and project maintenance. The question is whether it matters -- perhaps these skills will become as irrelevant as memorizing routes.

Security

An agent with write access to the repository, CI/CD and deploy is a powerful attack vector. If the system is compromised, the attacker gains an automatic executor with access to the entire infrastructure. KAIROS security needs to be treated with the same seriousness as root access to production servers.

11. When will it be released

Anthropic has not announced an official date for KAIROS. But we can infer a timeline based on the code signals and the company's launch history:

What do we know

• The KAIROS code is functional but marked as feature-flagged (disabled by default)
• ULTRAPLAN has extensive unit testing, suggesting it is closer to being ready
• Coordinator already has integration with the existing Agent Teams system
• Agent Swarms appears to be the least mature component, with more TODOs in the code

Probable timeline

• Q2 2026 (Apr-Jun):ULTRAPLAN as a beta feature. Long-term planning available for Max users
• Q3 2026 (Jul-Sep):KAIROS in limited beta. "Monitoring" mode for selected early adopters
• Q4 2026 (Oct-Dec):KAIROS available to everyone. Integrated coordinator. Swarms in beta
• 2027:Agent Swarms in production. Complete ecosystem of perpetual agents

This timeline is speculative, but it aligns with Anthropic's historical release cadence: code tease, limited beta, gradual expansion, general release.

12. How to prepare now

KAIROS is not yet available, but you can prepare today to get the most out of it when it arrives:

Master the current Claude Code

KAIROS is built on the Claude Code. The more fluent you are in the base tool, the faster you will take advantage of the advanced capabilities. If you don't already use Claude Code daily, start now.

Structure your projects for automation

• Automated Tests:KAIROS needs testing to verify that its fixes work. Without testing, it operates in the dark
• CI/CD configured:Continuous integration pipelines are the "eyes" of KAIROS. Without IC, it doesn't know if something broke
• Linters and formatters:Clear code rules allow KAIROS to automatically maintain consistency
• Basic documentation:CLAUDE.md, README, ADRs (Architecture Decision Records) give context for the agent to make better decisions

Learn to think in terms of rules

KAIROS operates based on rules that you define. "If test fails, correct automatically" is a simple rule. "If test fails and involves payments module, don't fix it automatically -- notify security lead" is a sophisticated rule. The better you are at setting clear rules, the more effective KAIROS will be.

Install specialized skills

Skills are not just for interactive use. When KAIROS is running, it can use skills to make better decisions in specific domains. A security skill helps KAIROS identify vulnerabilities. A performance skill helps detect regressions. The more specialized the context, the better the agent's decisions.

Set your autonomy limits

Before KAIROS arrives, think about how much control you want to delegate. For each type of action (test fix, dep update, PR review, refactoring), define whether you want manual approval or automatic execution. Having these limits clear before activating the agent avoids surprises.