What Is Claude Code Chyros? The Always-On Background Agent Revealed in the Source Leak

An Unshipped Feature That Changes Everything

Someone dug through Claude Code’s source strings and found something that wasn’t supposed to be public yet: a feature called Chyros.

The name doesn’t appear in any official Anthropic announcement. There’s no product page, no blog post, no developer preview. But the references are there in the code — and what they describe is significant. Claude Code Chyros appears to be a persistent, always-on background agent that keeps working on your codebase even when your laptop is closed and you’re asleep.

This article breaks down what the leak revealed, what Chyros would actually do, and what it tells us about where AI-assisted development is heading.

What the Leak Actually Showed

Claude Code is Anthropic’s terminal-based AI coding tool. Unlike a chatbot you open in a browser, it runs locally in your development environment, reads your files, and executes code on your behalf.

In early 2025, researchers and developers combing through Claude Code’s bundled source files found string references to “Chyros” — a codename for what appears to be an always-on background agent mode. The references included:

Mentions of push notifications that fire when Chyros completes a task
Strings describing autonomous background operation — the agent running independently of an active user session
References to task queuing, suggesting Chyros can receive instructions and work through them asynchronously
Indicators that the feature is not yet enabled for users — it’s in the codebase but gated off

This is consistent with how Anthropic (and most AI companies) ships features: the code ships first, the feature launches second. Chyros is clearly in active development, not just a prototype that got accidentally committed.

What Chyros Is Designed to Do

Based on what the source strings reveal, Chyros functions as a persistent coding agent — one that doesn’t require you to be actively present for it to work.

It Runs 24/7

Current Claude Code sessions are interactive. You open the terminal, give Claude an instruction, watch it work, and provide follow-up prompts. The session ends when you close it.

Chyros changes that model entirely. It’s designed to run continuously in the background — monitoring your project, executing tasks, and making progress without you at the keyboard.

Think of the difference between hiring a contractor who only works when you’re standing next to them versus one who shows up, does the work, and leaves you a summary. Chyros is trying to be the latter.

It Sends Push Notifications

The leak includes references to push notification infrastructure. When Chyros finishes a task — fixes a bug, runs tests, resolves a merge conflict — it notifies you, rather than waiting for you to check in.

This is a small detail that matters a lot. It shifts the interaction pattern from polling (you keep checking whether something is done) to event-driven (you get pinged when it is). That’s how real async workflows work.

It Can Fix Bugs While You Sleep

Several of the strings explicitly describe Chyros completing work during periods when the user is inactive. The implied use case: you flag a list of known bugs or pending tasks before you log off, and Chyros works through them overnight. You come back in the morning to a notification summary.

This is genuinely different from anything publicly available in Claude Code today. It’s not just a longer context window or a smarter autocomplete — it’s an autonomous agent operating on your codebase independently.

It Queues and Prioritizes Tasks

References to task queuing suggest that Chyros won’t just work on one thing at a time — it can maintain a list of work items and process them sequentially (or potentially in parallel). This starts to look less like a coding assistant and more like a background worker process that happens to understand code.

Why “Chyros” and Not “Claude”

The codename is worth noting. Anthropic doesn’t typically give internal names to Claude’s capabilities — they just ship them as part of Claude. The fact that this has a distinct name suggests it may be positioned as a separate product or a distinctly differentiated mode within Claude Code.

There’s precedent for this. GitHub Copilot Workspace is a different product from Copilot Autocomplete, even though both use AI and both live inside the development workflow. Chyros may eventually ship under its own branding, or fold into Claude Code under a toggle like “background mode.”

Either way, the codename signals that this is a meaningfully different capability — not just Claude doing more, but Claude operating in a fundamentally different way.

The Broader Pattern: Background Agents Are Becoming Real

Chyros isn’t an anomaly. It’s part of a clear pattern in the AI development tooling space.

Several companies are building toward always-on, background agent models right now:

Devin (from Cognition) already markets itself as an autonomous AI software engineer that can work on tasks over extended periods
GitHub Copilot Workspace allows developers to hand off multi-step tasks and review the results
Cursor has been experimenting with longer-horizon agentic features in its editor
OpenAI’s Codex (the cloud-based version) can run code in sandboxed environments asynchronously

The pattern is the same everywhere: AI tools are moving from synchronous assistant to asynchronous agent. You describe what you want, the agent works on it, you review the output.

Chyros represents Anthropic’s answer to this trend — and given Claude’s strengths in reasoning and long-context understanding, a persistent background Claude agent has real potential to be competitive in this space.

Why This Is Hard to Ship

The technical challenges with always-on background agents are not small.

Safety and oversight are the obvious ones. An agent that autonomously edits your codebase, pushes commits, or runs scripts without supervision can do real damage if something goes wrong. Anthropic has been notably careful about agentic safety, which may be part of why Chyros isn’t live yet.

Resource consumption is another issue. A persistent agent running 24/7 uses compute continuously. Pricing models for always-on AI are still being figured out — per-token pricing doesn’t translate cleanly to background agent usage.

Context drift is subtler but real. A session that runs for hours or days has to manage what it knows about the codebase, which changes over time. Keeping that context coherent requires careful engineering.

The fact that the push notification infrastructure is already in the source suggests Anthropic has thought through the async delivery model. The gating is almost certainly about safety validation and pricing, not core functionality.

What This Means for Developers

If Chyros ships anywhere near what the leak implies, it changes how you structure your development workflow.

Right now, most developers use AI coding tools reactively: you hit a problem, you ask Claude, you get help. Chyros flips that. You could potentially:

Queue a backlog of issues before a weekend and come back Monday to find half of them resolved
Set up automated code review that runs on every pull request without anyone manually triggering it
Run continuous refactoring passes on parts of your codebase without dedicating active attention to them
Get notified about breaking changes before you catch them in production

This is less “AI assistant” and more “AI team member with a to-do list.”

The catch is that this only works if the agent’s output is trustworthy enough to review efficiently. A background agent that produces subtly wrong code is potentially worse than no agent — you have more to review, and the errors are harder to spot. That trust threshold is where the real work is.

Building Background Agents Today with MindStudio

Chyros is compelling precisely because the concept — a persistent agent that works in the background and notifies you when it’s done — is genuinely useful. And while Chyros isn’t available yet, the underlying pattern is something you can build right now.

MindStudio is a no-code platform for building and deploying AI agents, including autonomous background agents that run on a schedule. If you’ve been following the Chyros story and thinking “I want that kind of always-on agent for my own workflow,” MindStudio is worth looking at.

You can build agents that:

Run on a schedule — hourly, daily, on a cron — without requiring anyone to trigger them manually
Send notifications via Slack or email when a task finishes (exactly the push notification pattern Chyros is designed around)
Connect to external tools — GitHub, Jira, Linear, Notion — so they can read and act on real data from your existing stack
Use Claude as the underlying model, alongside 200+ other models available out of the box

For developers who want to extend what their agents can do, MindStudio’s Agent Skills Plugin is an npm SDK that lets Claude Code and other agents call MindStudio’s typed capabilities — things like agent.sendEmail() or agent.runWorkflow() — as simple method calls. It handles the infrastructure layer so your agent focuses on reasoning, not plumbing.

The average MindStudio build takes 15 minutes to an hour. You can try it free at mindstudio.ai.

If you want to build more sophisticated AI workflows beyond coding — automated content pipelines, data processing agents, customer-facing AI tools — there’s a guide to building autonomous AI agents that covers the pattern in depth.

Frequently Asked Questions

What is Claude Code Chyros?

Chyros is an unreleased feature discovered in Claude Code’s source code. It appears to be a persistent, always-on background agent that can work on coding tasks autonomously — fixing bugs, running tests, and completing work even when the user isn’t actively present. It’s designed to send push notifications when tasks complete. As of now, it’s not publicly available.

How was Chyros discovered?

Developers and researchers analyzing the bundled source strings in Claude Code found references to “Chyros” alongside descriptions of push notifications, background operation, and task queuing. This kind of source code analysis is how many unannounced features get surfaced before official announcements.

Is Chyros available to use?

No. The feature is present in Claude Code’s codebase but is gated off and not enabled for users. There’s no official release date, and Anthropic hasn’t publicly acknowledged the feature.

How is Chyros different from regular Claude Code?

Standard Claude Code requires an active interactive session — you prompt, it responds, you continue the conversation. Chyros is designed to operate asynchronously, working through a task queue without requiring you to be present, and notifying you when work is done rather than waiting for your next input.

What can Chyros do with my codebase?

Based on the source strings, Chyros is designed to fix bugs, execute tasks, and work on coding problems autonomously. The specific scope of what it can and can’t modify isn’t detailed in the leak — that will depend heavily on the safety guardrails Anthropic builds around it before shipping.

When will Chyros be released?

Unknown. The presence of push notification infrastructure and task queuing logic suggests meaningful progress, but Anthropic hasn’t confirmed a timeline. Given their focus on agentic safety, expect thorough testing before any public release.

Key Takeaways

Chyros is a background agent feature found in Claude Code’s source code — currently unshipped and gated off for all users.
It’s designed to run 24/7, autonomously fix bugs and complete coding tasks, and send push notifications when work is done.
The feature represents Anthropic’s entry into the always-on AI coding agent space, competing with tools like Devin and autonomous Copilot Workspace.
The main challenges before launch are safety validation, resource pricing, and preventing context drift in long-running sessions.
The underlying pattern — background agents that notify you on completion — is already buildable today using platforms like MindStudio, even while Chyros remains in development.

The always-on agent model isn’t a distant future concept. It’s being built right now, and Chyros is one of the clearest signals yet that the major AI labs are racing to ship it. Whether Chyros arrives first or another tool beats it to market, the workflow shift it represents is coming regardless.