KRONUS DOCS

Claude Code is the most powerful AI tool available. It scores 80.8% on SWE-bench, handles a million tokens of context, and can use your computer, your terminal, and your voice. It is terminal-native.

That last part is both its strength and its limitation. If you live in the terminal, Claude Code is extraordinary. If you don't, it's inaccessible. And most people on a team don't live in the terminal.

Kronus removes that barrier. It layers persistent memory, personalized agents, Telegram access, a web dashboard, and team collaboration on top of Claude Code. One developer installs it. The whole team uses it, through Telegram, through the dashboard, through voice. No terminal required.

Kronus is free. It runs on your own Claude Code subscription. Zero additional cost.

What Kronus Adds to Claude Code

Brain: Persistent Memory

Every Claude Code session starts from zero. You re-explain your project, your preferences, your decisions. Context evaporates between sessions.

Kronus fixes this. Every session generates structured knowledge: decisions you made, patterns you prefer, project state, team context. This knowledge persists across sessions and gets auto-injected when relevant. Not chat history. Structured, queryable knowledge that compounds over time.

Day 1, Kronus knows your project structure. Month 1, it knows your architectural decisions better than most of your team.

Connections: Telegram, Voice, MCP

Kronus connects Claude Code to the rest of your workflow:

Tools: Agents, Skills, Teams

Kronus generates AI tools personalized to your workflow:

These aren't generic. The setup interview generates agents and skills matched to your domain, tech stack, and workflows.

Shield: Scope Guard

Every sensitive operation requires your explicit approval. File access outside your project, API calls, destructive commands, cost-heavy operations. Kronus asks before it acts.

Approval flows route to the right person. A junior developer's deployment request goes to the senior engineer. A budget decision goes to the PM. Full audit trails for everything.

Dashboard: Visibility for Everyone

A web interface at localhost:8420 designed for the whole team:

PMs see project status without asking developers. Managers see costs without digging through billing. Clients see progress without waiting for updates. The dashboard makes Claude Code's work visible to people who will never open a terminal.

Who Kronus is For

Developers using Claude Code who want persistent memory, mobile access, personalized agents, and team features on top of what they already use.

PMs, managers, and designers who want access to Claude Code's capabilities without touching a terminal. Through Telegram and the dashboard, the full power is available in interfaces they already know.

Teams where one developer installs Kronus and the entire team benefits. The developer gets enhanced tooling. Everyone else gets an AI assistant that actually knows the project.

Agencies managing multiple clients with separate project contexts. Per-project memory, per-project agents, per-project personas. Context never bleeds between clients.

Any professional who needs deep analysis, reasoning, and the ability to build custom tools: doctors, lawyers, professors, bankers, researchers, consultants, teachers. Through Telegram, voice, and the dashboard, they access Claude Code's full capabilities without touching a terminal.

Solo builders who want their entire workflow automated: code, test, review, deploy, invoice, communicate. One brain that handles it all.

What You Can Build

Because Claude Code writes and executes code, Kronus lets you build real applications through natural language. Describe what you need via Telegram or voice. Claude Code builds it. You use it. A professor builds a test generator. A banker builds a portfolio dashboard. A doctor builds a patient tracker. They never write a line of code.

How Much Does It Cost?

Kronus is free.

It runs on your own Claude Code subscription (Pro, Max, or Team plan from Anthropic). You pay Anthropic for Claude Code. Kronus adds the intelligence layer, memory, agents, dashboard, Telegram access, at zero additional cost.

What You Need

Next Steps

Set up Kronus in about 15 minutes. You need a Claude Code subscription and a Telegram account.

Prerequisites

Kronus itself is free. It runs on your own Claude Code plan at zero additional cost.

Quick Install

Step 1: Install Claude Code

If you do not have Claude Code yet, follow the installation guide at code.claude.com. Verify it is working:

claude --version

Step 2: Install Kronus

# Clone the repository (beta access required)
git clone https://github.com/par1kahl/kronus.git
cd kronus

# Run the installer
./install.sh

The installer handles:

Step 3: Run the Setup Interview

kronus init

This starts a conversational interview that takes about 15 minutes. Kronus asks about:

Based on your answers, Kronus generates:

This is not a one-size-fits-all setup. Two developers on the same team will get different configurations based on their role, preferences, and workflow.

Step 4: Verify

# Check the daemon is running
kronus status

# Open the dashboard
open http://localhost:8420

Then open Telegram, find your Kronus bot, and send "hello" to verify the connection.

What Is Running After Installation

Four components run after setup:

The daemon starts automatically on login. All other components depend on it.

Adding Team Members

After your own setup is complete, see Team Setup for adding your team.

The short version: non-developers only need to join the Telegram group and get the dashboard link. No installation required for them.

Updating

cd kronus
git pull
./install.sh --update

Updates preserve your memory, configurations, and personalized agents. Only the daemon and dashboard are updated.

Troubleshooting

Daemon not starting

Check kronus logs for errors. The most common cause is Claude Code not being installed or not authenticated. Run claude --version to verify.

Telegram not connecting

Re-run the Telegram setup:

kronus telegram-setup

This reconnects the bot without affecting your other configuration.

Dashboard not loading

The dashboard requires the daemon. Verify the daemon is running:

kronus status

If the daemon is running but the dashboard is not loading, check if port 8420 is in use by another process.

MCP servers failing

Check your API tokens in .claude/mcp.json. Tokens expire and need refreshing. The most common fix:

kronus mcp refresh

Setup interview did not finish

You can re-run it:

kronus init --resume

Or start fresh:

kronus init --reset

Uninstalling

./install.sh --uninstall

This removes the daemon and dashboard but preserves your memory and configurations in .claude/. Your data stays on your machine.

Next Steps

You've installed Kronus and completed the setup interview. Here's what to do next.

After Installation

Four things are now running:

You don't need to start anything manually. Everything is live.

Five Things to Try in the First Hour

1. Ask Kronus about your project

Open Telegram and send a message to your Kronus bot:

> "What's in this project?"

Or open your terminal in a project directory and run claude.

Kronus reads your codebase, cross-references it with the context from your setup interview, and responds with a structured overview: tech stack, file structure, key patterns, and any context it already has from your interview.

This is also a good test of memory. After this first conversation, Kronus will remember the project context for every future session.

2. Check the Dashboard

Open localhost:8420 in your browser. You'll see three main panels:

Bookmark this. It's where you check what Kronus is doing and what it knows.

3. Run a skill

Skills are single-command workflows. Try one from your terminal:

/test-gen src/auth/login.ts

Generates unit tests for a specific file.

/quick-review

Reviews your recent code changes.

/dep-check

Scans your dependencies for known vulnerabilities.

/standup-update

Generates a standup update from your recent git activity.

Skills run fast. Most complete in under a minute. The results appear in your terminal or Telegram, depending on where you triggered them.

4. Use an agent

Agents handle complex, multi-step work. Try these in Telegram or terminal:

> "Run a security audit on this repo"

This triggers the security-auditor agent. It scans your code for vulnerabilities, checks dependencies, looks for hardcoded secrets, and produces a structured report with severity levels and fix suggestions.

> "Review the latest changes"

This triggers the code-reviewer agent. It analyzes your recent commits for quality, security, performance, and maintainability issues.

Agents take longer than skills (minutes, not seconds) and produce detailed, structured output. You'll see their progress in the Dashboard sessions panel.

5. Send a voice message

Open Telegram and record a voice message:

> "Generate tests for the user authentication module and then run them"

Kronus transcribes your message, identifies the intent, selects the right tools, and executes. No special syntax. Natural language works.

Voice is particularly useful when you're away from your desk. Commuting, walking, between meetings. Your AI keeps working.

For Non-Developers on the Team

If a developer on your team installed Kronus and added you to the team configuration, here's what you can do right now:

Ask questions about the project via Telegram: > "What's the status of the billing feature?" > "When was the last deployment?" > "What's blocking the frontend team?"

Kronus answers from project memory and recent activity. No need to interrupt developers for status updates.

Open the Dashboard at the URL your team lead shared. See live activity, project status, and session history. Everything the AI is doing is visible here.

Approve or deny actions when they require sign-off. If a scope guard rule routes an approval to you, you'll get a Telegram message with the details and options to approve or deny.

Use voice messages in Telegram. Describe what you need in plain language. If it's within your permissions, Kronus handles it.

What Happens Over Time

Kronus gets more useful the more you use it. Here's what to expect:

Day 1: Kronus knows your project structure, tech stack, and basic preferences from the setup interview. It can navigate your codebase and answer questions about it.

Week 1: Memory now includes your architectural decisions, code review patterns, team communication preferences, and project-specific context. Morning briefings start surfacing relevant information automatically.

Month 1: Hundreds of structured memories across projects. Cross-project awareness means Kronus can reference patterns from one project when working on another. The "second brain" effect becomes tangible: Kronus remembers things you've forgotten.

Month 3+: Deep institutional knowledge. New team members onboard faster because the shared memory contains months of context. Your AI assistant knows your codebase history, your decision rationale, and your team's working patterns better than any documentation could capture.

Troubleshooting

Dashboard not loading? Make sure the Kronus daemon is running: kronus status in your terminal.

Telegram not responding? Check your bot connection: kronus telegram status.

Memory seems empty? Memory accumulates through usage. Have a few conversations about your project and check the Brain panel again.

Skills not found? Run kronus skills list to see your available skills. If something is missing, re-run the setup interview or add it manually.

Next Steps

When you install Kronus, it doesn't hand you a generic configuration and wish you luck. It interviews you. About 15 minutes of conversation that shapes everything Kronus generates for you.

This is the first thing that happens after installation, and it's the reason no two Kronus setups are identical.

How It Works

The setup interview is a guided conversation. Kronus asks you questions, you answer naturally, and it builds your configuration from what you tell it. No forms. No dropdowns. Just a conversation about how you work.

What it asks about

Your projects: What are you building? What's the tech stack? Monorepo or multiple repos? What stage is each project in?

Your role: Are you a frontend developer? Full-stack? DevOps? A PM? A founder doing everything? Your role determines which agents and skills get generated.

Your tools: Do you use GitHub or GitLab? Linear or Jira? Slack or Teams? Gmail or Outlook? Kronus connects to the tools you actually use, not the ones it assumes you use.

Your workflows: What do you do repeatedly? Code review every PR? Generate invoices monthly? Write proposals weekly? Run security scans before releases? These become skills and agent workflows.

Your communication style: How do you prefer to interact? Detailed explanations or concise answers? Do you want to approve every action or trust Kronus to handle routine tasks? This shapes the scope guard configuration.

Your team: Who else will use Kronus? What are their roles? What should they have access to? This sets up team routing and approval flows.

What Gets Generated

Based on your answers, Kronus creates:

Personalized Agents

A frontend developer gets agents tuned for component architecture, design system work, and browser testing. A DevOps engineer gets agents for infrastructure review, deployment pipelines, and monitoring. A PM gets agents for project summarization, stakeholder updates, and timeline tracking.

The agents aren't cosmetically different. They have different system prompts, different tool access, different model routing, and different output formats. An agent built for your domain knows the terminology, patterns, and priorities of your domain.

Tailored Skills

Skills are single-command workflows. The interview identifies which ones matter to you. If you write proposals, you get /upwork-proposal configured for your positioning. If you manage dependencies, /dep-check is ready. If you never write invoices, /invoice-gen stays out of your way.

MCP Connections

Kronus ships with 9+ MCP server integrations. The interview activates the ones you need and configures them for your accounts. GitHub repos get connected. Slack channels get mapped. Linear projects get linked. Only what you use, nothing extra.

Per-Project Configuration

If you work across multiple codebases, each project gets its own configuration. Different agents, different personas, different memory partitions. Your client project stays separate from your open-source work. Context never bleeds across boundaries.

Memory Seed

The interview itself becomes your first batch of structured memories. Your preferences, your project context, your team dynamics. From the very first real session after the interview, Kronus already knows you.

Why This Matters

Every other AI tool ships the same generic experience to every user. A frontend developer at a startup and a DevOps engineer at an enterprise get the same assistant, the same suggestions, the same workflows. The burden of customization falls entirely on the user.

Kronus inverts this. It starts personalized. The setup interview ensures that from your first real session, the agents understand your domain, the skills match your workflows, and the connections link to your tools.

And it compounds. The interview is the seed. Every session after adds more memory. Your patterns, your decisions, your preferences accumulate. The longer you use Kronus, the sharper it gets. But it starts sharp, not generic.

Re-running and Adjusting

The setup interview isn't a one-time lock-in.

Professional Personalization

The setup interview doesn't assume you're a developer. It adapts to your profession.

Describe your work as a medical researcher: Kronus generates agents for literature review, data analysis, and paper writing. Describe your work as a financial analyst: you get agents for market analysis, portfolio tracking, and risk modeling. Describe your work as a professor: agents for curriculum design, test generation, and grading.

The interview also asks about your tools. What software do you use? What databases? What cloud services? Kronus configures MCP connections and API integrations for your specific ecosystem. A professor's Kronus connects to their LMS. A banker's connects to their financial data feeds. A lawyer's connects to their document management system.

For tools without APIs, Computer Use lets Claude Code interact with them directly on your screen. If your workflow involves a desktop application, Kronus can still work with it.

For Teams

Each team member runs their own setup interview. A developer's Kronus looks different from a PM's Kronus, even on the same project. The interview captures individual workflows and preferences while the shared project memory keeps everyone aligned on context.

This means onboarding a new team member is a 15-minute interview, not a week of documentation reading. Kronus generates their personalized setup and injects the team's shared memory on day one.

Next Steps

If you're not a developer, this is your starting point.

The Short Version

A developer on your team installed Kronus. That means you now have access to a powerful AI assistant through two simple interfaces:

You don't need to write code. You don't need to touch anything technical. You talk to Kronus like you'd talk to a colleague, and it gets things done.

What You Can Ask It To Do

If You're a Project Manager

If You're a Designer

If You're a Manager or Founder

If You're a Client

If You're a Doctor or Researcher

If You're a Professor or Teacher

If You're a Banker or Financial Analyst

If You're a Lawyer or Consultant

The common thread: Kronus doesn't just answer questions. It builds. Describe what you need. Claude Code creates it. Through Telegram, voice, or the dashboard. Your tools, your data, your machine.

What You Need

That's it. No installation. No setup. No account creation beyond Telegram.

How It's Different from ChatGPT

Getting Started

Ready to try it? Start with these two guides:

Telegram is the main way non-developers interact with Kronus. If you can send a text message, you can use Kronus.

Getting Started

That's it. You're connected.

What You Can Send

Text Messages

Type a question or instruction in plain language. No special format needed.

Examples:

Voice Messages

Press and hold the microphone button in Telegram. Speak naturally, like you're talking to a colleague. Release the button when you're done. Kronus will understand what you said and respond with text.

Great for:

Photos and Screenshots

Attach an image and include a question or instruction with it.

Examples:

Documents

Send PDFs, spreadsheets, or text files directly in the chat.

Examples:

Example Conversations

Checking project status

You: What's the status of the checkout feature?

Kronus: The checkout feature is 80% complete. The payment form and cart summary are done. Still in progress: order confirmation emails and error handling for declined cards. Sarah is the owner. No blockers currently. Estimated completion: April 3.

Getting a weekly summary

You: Summarize what happened on the project this week

Kronus: This week on Project Atlas:

Generating content

You: Draft a client update email about the beta launch. Keep it under 200 words and make it friendly

Kronus: [A ready-to-send draft email, properly formatted, under 200 words]

Using voice

You: [voice message] "Hey, after today's meeting with the client, we decided to push the launch date to April 15. The budget increased to $30K. Can you update the project context?"

Kronus: Got it. I've updated the project context: launch date moved to April 15, budget updated to $30,000. I'll include this in tomorrow's morning briefing.

Approval Requests

Sometimes Kronus needs your permission before doing something. You'll see a message like:

> Kronus wants to update the project timeline in the shared document. Approve or Deny?

Tap the button to respond.

If you're not sure, tap Deny. You can always approve it later or ask your developer for clarification. Nothing breaks if you deny a request.

Group Chats

Kronus can be added to Telegram group chats so your whole team can interact with it in one place.

How it works in groups:

Example team standup:

Tips for Getting Better Results

The dashboard is a web page where you can see everything Kronus is doing across your team's projects. Think of it as a control center. No technical knowledge required.

Accessing the Dashboard

Your developer will share a link with you. Open it in any web browser (Chrome, Safari, Firefox, Edge). Bookmark it for easy access.

If the link doesn't work, check with your developer. They may need to make sure Kronus is running on their machine.

What You'll See

Sessions Panel

This shows what Kronus is working on right now. Each "session" is a task that someone asked Kronus to do.

You'll see status indicators next to each session:

Click on any session to see the details: what Kronus is reading, what it's writing, and what steps it's taking to complete the task.

Why this matters: You can see exactly what the AI is doing at any moment. No black box. Full transparency.

Brain Panel

This is Kronus's memory. Everything it has learned about your projects, your team, and your decisions lives here.

Think of it as a living knowledge base that updates itself after every conversation and every task. When someone tells Kronus "the launch date moved to April 15," that information gets stored here and is available to everyone on the team.

Projects Panel

An overview of all projects Kronus knows about:

This is useful for managers and founders who want a high-level view of where effort and resources are going.

What You Can Do from the Dashboard

Monitor

Watch what Kronus is doing in real time. See active sessions, completed work, and pending approvals.

Approve Actions

When Kronus needs permission to do something (like modifying an important file or deploying an update), you'll see it in the Sessions panel with an orange dot. Click on it to review what's being requested, then approve or deny.

Review History

Browse past sessions to see what Kronus has done. This is useful for catching up on work that happened while you were away, or for understanding how a decision was made.

Track Costs

See how much AI usage each project is consuming. This helps with budgeting and understanding where the AI is adding the most value.

Check Memory

Browse what Kronus knows about your projects. If something looks outdated or wrong, let your developer know so they can update it.

What You Cannot Do from the Dashboard (Yet)

Tips

You can talk to Kronus instead of typing. This works through Telegram voice messages today, and directly in the dashboard soon.

How to Use Voice in Telegram

Kronus will convert your speech to text, understand what you're asking, and respond. The whole process takes a few seconds.

What Works Well with Voice

Status Checks

"What's the status of the mobile app project?" "Are there any blockers on the website redesign?" "What did the team finish yesterday?"

Task Requests

"Generate a weekly report for the design team." "Draft a short email to the client about the timeline change." "Create a summary of all open tasks on Project Atlas."

Quick Questions

"Who owns the authentication module?" "When is the next release scheduled?" "What was the last decision we made about pricing?"

Capturing Decisions After Meetings

"After today's meeting, we decided to push the launch to April 15. Budget is now $30K. The client wants a demo before launch. Update the project context."

This is one of the most powerful uses of voice. Right after a meeting, while everything is fresh, you can speak your notes into Telegram and Kronus will store the decisions, dates, and context for the whole team.

Content Creation

"Draft a LinkedIn post about our new feature launch. Keep it casual and under 300 words." "Write a short thank you message to the client for their feedback." "Summarize the project for a board presentation. Focus on milestones and budget."

Tips for Better Results

Speak clearly and at a normal pace

You don't need to slow down or over-enunciate. Just talk the way you normally would in a meeting.

Include specifics

Names, dates, numbers, and project titles help Kronus give you a precise answer.

Good: "What's the status of the Acme Corp dashboard project?" Less good: "How's the project going?"

Break complex requests into shorter messages

If you have a lot to say, send two or three shorter voice messages instead of one long one. Each message can build on the last.

Mix voice and text

You can send a voice message and then follow up with a text message in the same conversation. Kronus handles both seamlessly.

When Voice Really Shines

Language Support

Kronus understands voice messages in 20+ languages. Speak in whatever language is most comfortable for you. Kronus will respond in the same language.

If you switch languages mid-conversation (for example, asking in English and then switching to Spanish), Kronus will follow your lead.

Coming Soon: Voice in the Dashboard

A future update will add voice input directly to the dashboard. You'll be able to click a microphone button on the web page and speak, just like in Telegram. For now, Telegram is the way to use voice with Kronus.

How to get your team on Kronus. The developer installs. The team benefits.

The Team Model

Kronus is federated. Each team member runs their own Kronus instance on their own machine. Instances communicate through Telegram groups and shared memory. There is no central server.

This means:

Step-by-Step Team Setup

Step 1: First Developer Installs

One developer installs Kronus on their machine and runs the setup interview. This creates their personalized configuration and connects to Telegram. See the Installation Guide if you have not done this yet.

Step 2: Create a Telegram Group

Create a Telegram group for your project or team. Add the Kronus bot. This becomes the team channel where:

One group per project keeps context clean. If your team works on multiple projects, create a group for each.

Step 3: Add Team Members

Each additional developer:

Non-developer team members (PMs, designers, managers, clients):

Step 4: Configure Shared Projects

For shared codebases, configure the project in each team member's Kronus:

kronus project add --name "my-project" --path /path/to/repo

Shared memory entries sync through the team channel. When one developer's Kronus learns something about the project (an architectural decision, a deployment process, a key contact), it becomes available to the whole team.

What Each Role Gets

Team Size

Kronus works for teams of any size. Each instance runs independently on each developer's machine. Communication happens through Telegram.

There is no per-seat licensing or team plan required for Kronus itself. Each developer needs their own Claude Code subscription. Non-developers access Kronus through Telegram and the dashboard at no cost.

Next Steps

How knowledge flows across your team through Kronus.

How It Works

Each team member's Kronus has its own memory. When Kronuses are connected through a shared Telegram group, certain memories can be shared across the team.

Three modes:

What Gets Shared

Project decisions and context that the whole team needs:

What Stays Private

Individual preferences and work-in-progress:

You control what is shared. Nothing leaves your machine without either matching the automatic sharing rules or being explicitly tagged.

The New Team Member Advantage

When a new developer joins and sets up Kronus:

They do not start from zero. They start with weeks or months of team context. Architectural decisions, naming conventions, deployment processes, key contacts: all available from day one.

This is one of the biggest time savings for teams. Onboarding goes from weeks of "ask someone who was there" to hours of "Kronus already knows."

Viewing Shared Memory

Dashboard Brain panel: filter by "shared" to see all team-wide memories. Search by keyword, filter by project, type, or date.

Telegram: ask natural language questions and Kronus pulls from shared memory.

"What decisions have we made about the auth module?"
"What's our deployment process for staging?"
"Who's working on the billing feature?"

Memory files: shared entries are stored in project memory directories, accessible to all connected instances.

Managing Shared Memory

Adding a shared memory

From the terminal:

kronus memory add --shared "We're using Redis for session storage. PostgreSQL was too slow for this use case."

From Telegram:

@kronusbot remember (shared): deployment to production requires PM approval in the team channel

Removing outdated memories

Shared memories can become stale. Any team member with developer access can update or remove them:

kronus memory remove --id mem_abc123

Or ask in Telegram:

@kronusbot forget the decision about using Redis for sessions. We switched back to PostgreSQL.

Memory Conflicts

When two team members record conflicting information, Kronus flags the conflict in the team channel and asks for resolution. It does not silently overwrite. The most recent entry is marked as pending until the conflict is resolved.

Next Steps

How teams use Telegram with Kronus for daily work.

Setting Up Team Channels

Create Telegram groups for your projects. Each group becomes a collaborative workspace where developers and non-developers work alongside the AI.

Recommended structure:

Add the Kronus bot to each group. Every team member joins the groups relevant to their work.

Daily Team Workflow

Here is what a typical day looks like for a team using Kronus through Telegram.

Morning (9:00 AM)

Kronus posts the daily briefing to the project channel:

Daily Briefing: Project Alpha

Completed yesterday:
- Auth module: JWT refresh token flow implemented (Sarah)
- API: rate limiting added to /users endpoint (Mike)

In progress:
- Billing integration with Stripe (Sarah, 60% complete)
- Dashboard redesign: components migrated to new design system (Mike)

Blockers:
- Stripe webhook testing requires production API keys (Sarah)

AI cost this week: $12.40 across 3 developers

Everyone sees what happened, what is in progress, and what is stuck. No standup meeting required.

Mid-Day (Developer)

A developer sends a task directly in the group:

@kronusbot run a security audit on the payment module

Kronus responds in the channel with the security-auditor agent findings, categorized by severity. The whole team sees the results.

Afternoon (PM)

The PM asks a planning question:

@kronusbot what's blocking the sprint? can we hit the Friday deadline?

Kronus pulls from project memory and active sessions to give a structured answer. No need to interrupt developers.

End of Day (Manager)

The manager checks the dashboard for completed sessions, cost tracking, and any pending approvals. Or asks in Telegram:

@kronusbot summarize today's progress

Approval Flows in Telegram

When an AI action needs approval, the request appears in the channel:

Approval Request
Action: Modify database/migrations/002_add_billing.sql
Session: Billing integration
Reason: Adding billing_history table for Stripe webhook data

[Approve] [Deny]

Anyone with approval authority taps the button. The decision is logged and visible to the team. See Approval Flows for details on routing approvals to the right person.

Voice Messages

Team members can send voice messages instead of typing:

"Quick update: the client call went well, they approved the design.
Budget is confirmed at $30K. Move to implementation phase."

Kronus transcribes the message, updates project memory with the key information, and can trigger follow-up actions. This is especially useful for PMs and managers who are on the go.

Common Commands in Team Channels

These are natural language. No special syntax required.

Tips for Team Telegram

Direct Messages vs. Group Channels

You can also DM the Kronus bot directly for individual work:

Group channels are for team-visible work. DMs are for individual productivity.

Next Steps

The dashboard gives everyone visibility into what the AI is doing, what it knows, and what it costs.

Accessing the Dashboard

The dashboard runs at localhost:8420 on the developer's machine.

For team access:

Dashboard Panels

Sessions Panel

Live feed of all AI activity.

Click any session to see details: what files were read, what was written, what commands ran, how long it took, and what it cost.

For PMs: see what work is happening without interrupting developers.

For managers: monitor AI activity across projects in real time.

Brain Panel

The team's collective knowledge, searchable and browsable.

For PMs: search for past decisions. "What did we decide about the API versioning?"

For new team members: browse project history and team context to get up to speed fast.

Projects Panel

Overview of all projects with cost tracking.

For managers: cost accountability without asking anyone.

For finance: track AI spend against project budgets with exportable data.

What Each Role Sees

Role-based access is configured during team setup. The developer who hosts the dashboard controls who sees what.

Real-Time Updates

The dashboard uses live streaming (SSE). Changes appear instantly. No need to refresh.

When a session starts, completes, or requests approval, you see it immediately. This makes the dashboard useful as a persistent monitor on a second screen or a shared team display.

Cost Tracking

The Projects panel tracks Claude Code API costs automatically:

This is especially useful for teams that need to justify AI tooling costs or allocate spend across client projects.

Using the Dashboard with Telegram

The dashboard and Telegram are complementary:

Most team members use both. Developers lean on Telegram for quick interactions and the dashboard for detailed session review. PMs and managers often prefer the dashboard for its visual overview.

Next Steps

How your team controls what the AI can do. Every sensitive action requires human approval.

Why Approvals Matter

AI with full system access is powerful but risky. Approval flows keep humans in control:

How Approvals Work

The Flow

What Triggers Approvals

What Does Not Need Approval

Configuring Scope Guard

The scope guard is configured per project. You define what is allowed, what is blocked, and what requires approval:

kronus scope set --project my-project \
  --allow "src/**" \
  --approve "database/migrations/**" \
  --approve "infrastructure/**" \
  --block "production.env"

Team Approval Routing

In team settings, approvals can route to specific people based on the type of change:

This matches how real teams work. The person with domain knowledge reviews the relevant changes. Configure routing in the project's Kronus config:

kronus approvals route --project my-project \
  --pattern "src/frontend/**" --to "@sarah" \
  --pattern "database/**" --to "@mike" \
  --pattern "infrastructure/**" --to "@devops-team"

Approval Speed

Approvals are designed to be fast, not bureaucratic:

If nobody responds within a configurable timeout (default: 30 minutes), the action is denied. Fail-closed, not fail-open. The timeout is configurable per project.

Dashboard Audit Trail

Every approval decision is logged and visible in the dashboard Sessions panel:

This is useful for:

Common Patterns

Development Team

Allow all source code modifications. Require approval for infrastructure, deployment, and database changes. Block production credentials.

Agency / Client Work

Allow all code within the project. Require PM approval for client-facing changes. Route security-sensitive changes to the tech lead.

Solo Developer

Minimal approvals. Allow most actions. Require approval only for production deployments and credential access. Useful as a safety net even when working alone.

Next Steps

Agents are specialized AI assistants that handle specific types of work. Instead of one generic AI trying to do everything, Kronus routes each task to the agent best suited for it.

How Agents Work

When you give Kronus a task, it analyzes what kind of work is involved and dispatches the right agent. Each agent has:

Your Agents Are Personalized

This is a key difference from other AI tools. Kronus does not ship a fixed set of generic agents.

During the 15-minute setup interview, Kronus asks about your role, tech stack, workflow, and team structure. It then generates agents tailored to your answers. A React developer gets different agents than a DevOps engineer. An agency owner gets different agents than a solo freelancer.

While the examples below show development-focused agents, the setup interview generates agents for any profession. A medical researcher gets a literature-review agent. A financial analyst gets a market-analysis agent. A professor gets a curriculum-builder agent. A lawyer gets a contract-review agent. The agent system adapts to your domain.

The result: agents that know your stack from the start and are organized around the way you actually work.

You can view, modify, and create agents in your .claude/agents/ directory. Each agent is a markdown file. No special tooling required to customize them.

Agent Examples

Your set will differ based on your setup interview, but here are representative examples.

Development Agents

frontend-dev. React, Next.js, Tailwind, component architecture. Knows your component patterns, styling conventions, and state management approach. Handles UI implementation, component refactoring, and frontend debugging.

backend-infra. APIs, databases, Docker, Terraform, infrastructure. Handles endpoint implementation, database schema changes, container configuration, and infrastructure provisioning.

ai-engineer. RAG pipelines, prompt engineering, model selection, evaluation. Handles AI feature implementation, prompt optimization, and model integration work.

Review and Quality Agents

code-reviewer. Analyzes pull requests for code quality, performance issues, security concerns, and architectural consistency. References your project's established patterns when reviewing.

security-auditor. Static analysis, dependency vulnerability scanning, OWASP checks. Finds security issues before they reach production.

fuzzing-agent. Edge cases, boundary conditions, adversarial inputs. Tests the paths that developers typically miss: empty strings, negative numbers, Unicode edge cases, concurrent access patterns.

Business and Content Agents

proposal-writer. Generates proposals, statements of work, and RFP responses based on your past projects, pricing, and client context.

memory-retriever. Queries your memory system for past decisions, project context, and historical patterns. Useful when you need to remember why something was built a certain way.

Orchestration Agents

planner. Breaks complex tasks into steps, assigns each step to the right agent, manages dependencies between steps. This is the agent that coordinates multi-agent work.

team-lead. Coordinates multiple agents working simultaneously in swarm mode. Manages parallel execution, merges results, resolves conflicts between agent outputs.

Teams and Swarms

Agents work together on complex tasks. When a task requires multiple types of expertise, the planner agent breaks it into subtasks and dispatches them to specialized agents.

Example: comprehensive code review. You ask Kronus to review a large PR. The planner dispatches three agents in parallel:

All three run simultaneously. Results are merged into a single review with categorized findings.

Example: feature implementation. You describe a feature. The planner:

Each agent focuses on what it knows. The planner handles coordination.

Cost Routing

Different agents run on different model tiers based on task complexity:

This routing happens automatically. You do not need to configure which model each agent uses. Kronus selects based on the agent's role and the specific task.

The result: you pay less for simple tasks without sacrificing quality on complex ones.

Creating Custom Agents

You can create agents beyond what the setup interview generates. Add a markdown file to .claude/agents/ with this structure:

---
name: agent-name
description: What this agent does
model: sonnet
tools: [github, filesystem]
---

# System Prompt

Instructions for the agent. What it specializes in, how it should approach problems, what it should prioritize.

The frontmatter defines metadata (name, description, model tier, available tools). The body is the system prompt that shapes the agent's behavior.

Tips for Good Custom Agents

Project-Level Agents

Agents in a project's .claude/agents/ directory take priority over global agents with the same name. This lets you customize agent behavior per project without changing your global configuration.

A client project might have a stricter code-reviewer. An open-source project might have an agent tuned for community contribution guidelines. Each project gets the agents it needs.

Skills vs Agents

Kronus also has skills: quick, single-command workflows for common tasks. The difference:

Use skills for quick workflows. Use agents (or teams of agents) when the task requires depth.

Skills are single-command workflows. Instead of writing a multi-step prompt every time, you invoke a skill with one command and get a complete result.

How Skills Work

A skill is a markdown file with a system prompt and metadata. When you type /test-gen src/auth/login.ts, Kronus loads the skill's prompt, injects your file as context, routes it to the right model tier, and returns a structured result.

Key properties:

Built-in Skills

Development

Content and Business

Operations

Composite Skills (Chains)

These run multiple skills in sequence:

Creating Custom Skills

Skills are markdown files with YAML frontmatter. Drop one into .claude/skills/ and it's immediately available.

Minimal Example

Create .claude/skills/changelog.md:

---
name: changelog
description: Generate a changelog entry from recent commits
model: haiku
---

Read the git log for the last 7 days. Group commits by category
(features, fixes, refactors, docs). Output a markdown changelog
entry with the date as the heading.

Format:
## [date]
### Added
- ...
### Fixed
- ...
### Changed
- ...

Now /changelog works from any session in that project.

Frontmatter Fields

---
name: my-skill          # Required. The slash command name
description: What it does  # Required. Shown in skill listings
model: sonnet           # haiku | sonnet | opus. Controls cost routing
---

The model field controls which Claude model runs the skill:

Advanced Example: PR Summary

---
name: pr-summary
description: Generate a PR description from staged changes
model: sonnet
---

Analyze the current git diff (staged changes). Write a pull request
description with:

1. A one-line title (under 72 characters)
2. A summary section with 2-3 bullet points explaining the change
3. A testing section describing how to verify
4. A list of files changed with brief explanations

Use the project's conventional commit style if one exists.
Output the title and body separately so they can be passed to `gh pr create`.

Project-Level vs Global Skills

Skills can live in two places:

Project-level skills override global skills with the same name. This lets you customize behavior per project without affecting other work.

Skills vs Agents

Rule of thumb: if the task has a predictable structure and a clear input/output, it's a skill. If it requires exploration, judgment, or coordination, use an agent.

Output Format

Skills return markdown by default. This makes them easy to read and pipe into other tools. When a skill chains into another skill or agent, it can return structured JSON instead.

You can see all available skills by running /help in any Kronus session.

Every Claude Code session starts from zero. You explain your project, your decisions, your preferences. Every single time. Kronus fixes this with persistent memory.

How Memory Works

The Memory Cycle

This cycle runs automatically. You don't manage it manually.

What Gets Extracted

The daemon extracts structured knowledge, not raw conversation:

What Does NOT Get Stored

Memory Types

User Memories

Your personal context: role, expertise level, preferences, communication style. These follow you across all projects.

# user_preferences.md
- Prefers Vitest over Jest
- Uses strict TypeScript, no `any`
- Named exports only, no default exports
- Wants code reviews to flag performance issues

Project Memories

Decisions, architecture, and state specific to one project. These are scoped to the project directory.

# project_auth_decisions.md
- JWT auth with refresh tokens (decided 2026-01-15)
- Access tokens expire in 15 minutes
- Refresh tokens stored in httpOnly cookies, 7-day expiry
- Rate limiting: 5 attempts per minute on /api/auth/login
- Using argon2 for password hashing (switched from bcrypt 2026-02-01)

Feedback Memories

Corrections you've made during sessions. These prevent the AI from repeating mistakes.

# feedback_corrections.md
- Do NOT use default exports in this project (corrected 2026-01-20)
- The staging database is on port 5433, not 5432 (corrected 2026-02-05)
- Always run migrations before seeding in this project (corrected 2026-02-10)

Reference Memories

Pointers to external resources and systems.

# reference_external.md
- Linear project: https://linear.app/team/project-alpha
- Slack channel: #project-alpha-dev
- Staging URL: https://staging.project-alpha.com
- CI pipeline: GitHub Actions, runs on push to main

Storage Format

Memories are plain markdown files stored in .claude/projects/ directories. The structure looks like this:

~/.claude/projects/
  -Users-you-projects-myapp/
    memory/
      MEMORY.md              # Index file (table of contents)
      project_decisions.md
      project_architecture.md
      user_preferences.md
      feedback_corrections.md
      reference_external.md

MEMORY.md is the index. It lists all memory files with one-line descriptions so the daemon can quickly identify which memories are relevant for a given session.

# Memory Index

- [Architecture Decisions](project_decisions.md) - Database, auth, and API design choices
- [Team Context](project_team.md) - Who owns what, review processes
- [User Preferences](user_preferences.md) - Coding style, tooling, review preferences

Cross-Project Memory

Kronus manages memory per-project but can surface cross-project context when relevant.

Example: you're working on Project B and need to integrate with Project A's API. If you documented Project A's auth flow in a previous session, that memory can be injected into your Project B session.

This works because the daemon evaluates relevance based on the current task, not just the current project directory.

Team Memory

When multiple people on a team each run their own Kronus:

Viewing and Managing Memory

Dashboard

The Brain panel shows all memories. Search by keyword, filter by type, edit or delete entries.

CLI

The memory-retriever agent can query past context:

"What did I decide about the caching strategy for the user service?"

Manual Editing

Memory files are plain markdown. Open them in any editor:

# List all memory files for a project
ls ~/.claude/projects/-Users-you-projects-myapp/memory/

# Edit directly
vim ~/.claude/projects/-Users-you-projects-myapp/memory/project_decisions.md

You can add, edit, or delete memory entries. The daemon respects manual changes.

The Compounding Effect

Memory value grows over time:

This accumulated context is the core value. Starting over with a different tool means rebuilding months of knowledge from scratch.

MCP (Model Context Protocol) servers connect Kronus to external tools and services. They give Claude Code the ability to interact with systems beyond your local filesystem.

What MCP Servers Do

Each MCP server exposes a set of tools that Claude Code can call during a session. Without MCP servers, Claude Code can only work with your local files and terminal. With them, it can create GitHub PRs, send Slack messages, manage Linear tickets, search the web, and more.

You interact with Claude Code normally. It decides when to use an MCP tool based on what you asked for.

Example: "Create a GitHub issue for the auth rate-limiting bug and post it to #backend-bugs on Slack."

Claude Code uses two MCP servers (GitHub and Slack) to complete this in one step. You don't invoke the servers directly.

Supported MCP Servers

Kronus supports these MCP servers out of the box. During the setup interview, the ones relevant to your workflow are configured automatically.

Configuration

MCP servers are configured in .claude/mcp.json at the project or user level.

Basic Structure

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@anthropic/mcp-server-github"],
      "env": {
        "GITHUB_TOKEN": "ghp_xxxxxxxxxxxx"
      }
    },
    "slack": {
      "command": "npx",
      "args": ["-y", "@anthropic/mcp-server-slack"],
      "env": {
        "SLACK_BOT_TOKEN": "xoxb-xxxxxxxxxxxx"
      }
    }
  }
}

Adding a New MCP Server

{
  "mcpServers": {
    "linear": {
      "command": "npx",
      "args": ["-y", "@anthropic/mcp-server-linear"],
      "env": {
        "LINEAR_API_KEY": "lin_api_xxxxxxxxxxxx"
      }
    }
  }
}

The MCP server is now available to all agents and skills in that project.

Configuration Locations

Project-level configuration overrides user-level for servers with the same name.

Practical Examples

GitHub Workflow

You: "Review the open PRs and summarize which ones are ready to merge"

Kronus uses the GitHub MCP server to:
1. List open PRs
2. Check CI status on each
3. Read review comments
4. Return a summary with recommendations

Cross-Service Automation

You: "Check Linear for any unassigned backend tickets,
     pick the highest priority one, create a branch for it,
     and post to #backend that I'm working on it"

Kronus uses three MCP servers:
1. Linear: query unassigned tickets, filter by priority
2. GitHub: create a branch named after the ticket
3. Slack: post a message to #backend with the ticket link and branch name

Research and Documentation

You: "Look up the latest Next.js 15 migration guide
     and update our migration checklist in Notion"

Kronus uses two MCP servers:
1. Context7 or Brave Search: find the migration docs
2. Notion: update the team's migration checklist page

The Hub Marketplace

Kronus Hub is a marketplace where developers publish and discover MCP servers:

Hub handles authentication, metering, and payment flows. You build the MCP server, Hub handles the business side.

Professional Tool Connections

MCP servers aren't just for developer tools. The setup interview configures connections for any profession:

Any specialized tool with an API can be connected. For tools without APIs, Computer Use lets Claude Code interact with them directly on your screen. The setup interview identifies your tools and configures the right connections automatically.

Security

MCP servers require authentication tokens (API keys, OAuth tokens, bot tokens). Important details:

Using Environment Variables

Instead of hardcoding tokens in mcp.json:

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@anthropic/mcp-server-github"],
      "env": {
        "GITHUB_TOKEN": "${GITHUB_TOKEN}"
      }
    }
  }
}

Then set GITHUB_TOKEN in your shell profile or a local .env file.

Scope guard is Kronus's permission layer. It controls what Claude Code can and cannot do on your system, requiring explicit approval for sensitive operations.

Why It Exists

Claude Code has full access to your terminal, filesystem, and any connected MCP servers. That's powerful. It's also dangerous. A misunderstood prompt can lead to force-pushing to main, deleting the wrong directory, or exposing credentials in a command.

Scope guard sits between Claude Code and your system. It intercepts sensitive operations and asks you before proceeding.

How It Works

File Access Control

Each project defines an allowlist of directories the AI can read and write freely. Anything outside that boundary requires approval.

Project: ~/projects/myapp

Allowed (auto-approved):
  ~/projects/myapp/src/
  ~/projects/myapp/tests/
  ~/projects/myapp/docs/

Requires approval:
  ~/projects/myapp/.env
  ~/projects/myapp/infrastructure/
  ~/projects/other-project/
  /etc/

Inside the allowlist, Claude Code operates without interruption. Outside it, the daemon intercepts the request.

Dangerous Command Blocking

Certain command patterns are blocked or flagged by default:

Blocked by default:
  git push --force origin main
  git push --force origin production
  DROP TABLE / DROP DATABASE
  rm -rf /
  kubectl delete namespace production

Flagged (requires approval):
  git push --force origin [non-protected-branch]
  rm -rf [project-directory]
  docker system prune
  Any command containing credentials or tokens

These patterns are configurable per project. You can add your own blocked patterns or relax defaults for trusted contexts.

Interactive Approvals

When Claude Code tries to do something outside its permissions:

Kronus wants to run:
  rm -rf dist/ && npm run build

Project: myapp
Context: Cleaning build artifacts before rebuild

[Approve] [Deny]

Mobile Approvals

This is where the Telegram interface becomes critical for scope guard. You're away from your desk, an agent is running a task, and it needs approval to modify a config file. You get a Telegram notification, review the request, tap a button. The task continues.

No need to be at your terminal for approvals.

Permission Modes

Kronus supports different permission levels per project:

Set the mode in your project's CLAUDE.md:

# Project Settings
Permission mode: acceptEdits

Or override per-session when launching from the CLI or dashboard.

Choosing a Mode

Per-Project Configuration

Each project can have its own scope guard rules. Configure them in .claude/ or the project's CLAUDE.md.

Example: a project with strict infrastructure controls:

# Scope Guard Rules

## Blocked Commands
- Any `terraform apply` without `--auto-approve=false`
- Any `kubectl` command targeting the `production` namespace
- Any `docker push` to the production registry

## Auto-Approved
- File changes within src/ and tests/
- Git commits and pushes to feature branches
- npm install / npm run test / npm run build

## Require Approval
- Changes to .env, docker-compose.yml, terraform/
- Git push to main or release branches
- Any database migration command

Audit Trail

Every action is logged, whether approved, denied, or auto-approved:

{
  "timestamp": "2026-03-31T14:22:05Z",
  "action": "file_write",
  "target": "infrastructure/terraform/main.tf",
  "status": "approved",
  "approved_by": "par1k (via Telegram)",
  "context": "Adding CloudFront distribution for static assets",
  "session_id": "sess_abc123"
}

View the audit trail in the dashboard's security panel. Filter by action type, status, date range, or project. Query it programmatically through the memory system.

Team Approvals

In team settings, approvals can be routed to specific people based on the type of change:

This is configured at the team level. When a Kronus agent needs approval for a Terraform change, the notification goes to the person who owns infrastructure, not to every team member.

Comparison with Other Approaches

Some AI tools use declarative policy engines: you write rules, the engine enforces them silently. Scope guard takes a different approach. It keeps you in the loop with interactive approvals. You see what's happening and make the call.

Policy engines are good for known patterns. Interactive approvals handle the unknown. When an AI does something you didn't anticipate, you want a human reviewing it, not a policy that may not have a rule for it.

Not every task needs the most powerful model. Kronus routes tasks to the cheapest model that handles them well, so your Claude Code subscription goes further.

How It Works

Claude Code supports multiple model tiers. Each Kronus agent and skill has a model tier defined in its configuration. When you invoke a skill or agent, Kronus routes the task to the appropriate model automatically.

You don't configure this per-task. It happens based on the skill or agent you're using.

What Routes Where

Haiku (fast, cheap)

Tasks with predictable structure and simple transformations:

Example: /standup-update reads your recent git log and formats it into a standup. That's extraction and formatting. Haiku handles it in seconds for minimal cost.

Sonnet (balanced)

Tasks that require understanding code, generating content, or making judgments:

Example: /test-gen src/auth/login.ts needs to understand your auth implementation, identify edge cases, and generate valid test code. Sonnet has the code comprehension for this.

Opus (powerful, use sparingly)

Tasks that require multi-step reasoning across many files or coordinating multiple agents:

Example: "Refactor the payment system to support multiple currencies" requires the planner to analyze the existing codebase, identify all affected files, create a sequenced plan, and coordinate multiple agents. That's Opus territory.

Opus is never used for formatting, extraction, or simple generation. That would be burning money.

Routing in Practice

Skill Routing

Every skill defines its model in the frontmatter:

---
name: dep-check
description: Dependency vulnerability scan
model: haiku
---

---
name: test-gen
description: Generate tests for a file
model: sonnet
---

When you run /dep-check, it uses Haiku. When you run /test-gen, it uses Sonnet. No configuration needed.

Agent Routing

Agents also define their model tier:

---
name: code-reviewer
description: PR analysis, quality and security review
model: sonnet
---

---
name: planner
description: Task orchestration and parallel planning
model: opus
---

Composite Command Routing

Composite commands chain multiple skills. Each skill in the chain uses its own model tier:

/audit runs:
  1. /secret-scan    -> haiku  (pattern matching)
  2. /dep-check      -> haiku  (scanning)
  3. security review -> sonnet (analysis and judgment)

The cheap parts run on the cheap model. Only the analysis step uses the more expensive one.

Why This Matters

Without cost routing, every task uses whatever model you have selected. A 10-second formatting task consumes the same resources as a complex architecture review. That burns through your Claude Code subscription faster than necessary.

With routing:

Over a month, this means your subscription handles significantly more work. The difference is especially noticeable if you run multiple agents and skills throughout the day.

Customizing Routing

Override a Skill's Model

Edit the skill's frontmatter:

---
name: standup-update
model: sonnet    # upgraded from haiku for more detailed output
---

Override an Agent's Model

Same approach. Edit the agent's frontmatter model field.

Per-Session Override

Use the /effort command to adjust the model effort level for the current session. This doesn't change the model tier, but controls how much reasoning the model applies within its tier.

Creating Cost-Efficient Custom Skills

When building custom skills, choose the cheapest model that produces acceptable output:

---
name: changelog
description: Generate changelog from git log
model: haiku          # extraction + formatting = haiku
---

---
name: api-design
description: Design a REST API from requirements
model: sonnet         # needs code generation = sonnet
---

---
name: system-architect
description: Full system architecture analysis
model: opus           # multi-file reasoning = opus (rare)
---

Most custom skills should use haiku or sonnet. If you find yourself setting opus on a skill, consider whether it should be an agent instead.

Viewing Usage

The dashboard tracks AI usage per project and per session:

Use this data to identify opportunities. If a sonnet-tier skill could work with haiku, downgrade it. If an agent is running on opus but only doing simple analysis, switch it to sonnet.

Kronus has three layers: the engine, the brain, and the access points. Each layer does one job well, and together they turn Claude Code from a terminal tool into a persistent AI system for your whole team.

The Three Layers

Layer 1: Claude Code (The Engine)

Claude Code is Anthropic's most capable AI tool. It reads files, writes code, runs commands, controls your screen, and reasons about complex problems. While it started in the developer world, its capabilities are universal: any task that involves analysis, creation, or building can be handled by Claude Code. It scores 80.8% on SWE-bench, has a 1M token context window, Voice Mode, and Computer Use.

This means Claude Code can build applications, create documents, analyze data, generate reports, and construct tools. Through Kronus, anyone accesses these capabilities without ever opening a terminal.

Kronus runs Claude Code underneath. Every feature Claude Code has, Kronus has too. Nothing is removed or limited. Claude Code does the heavy lifting. Kronus adds structure around it.

Layer 2: The Daemon (The Brain)

The Kronus daemon runs in the background on your machine. It manages four things:

Memory. After every Claude Code session, the daemon extracts structured knowledge: decisions made, preferences discovered, project state changes, people mentioned. It stores this in a local knowledge graph. Before the next session, the daemon injects relevant memories so Claude Code starts with context, not from zero.

Sessions. The daemon spawns and monitors Claude Code sessions. It can run multiple sessions in parallel across different projects. If a session crashes, the daemon restarts it. If a session needs input, the daemon routes the request to your Telegram.

Connections. Telegram, MCP servers, external APIs. The daemon is the router. Messages from Telegram go to Claude Code. Responses from Claude Code go back to Telegram. MCP servers provide access to GitHub, Slack, Linear, Notion, and other tools.

Scope Guard. When Claude Code tries to do something sensitive (modifying a production config, running a destructive command, accessing a file outside the project allowlist), the daemon intercepts it. You get a Telegram notification with Approve and Deny buttons. Nothing happens until you decide.

Layer 3: Interfaces (The Access Points)

You interact with Kronus through multiple interfaces. All of them connect to the same daemon, the same memory, the same agents.

Terminal. Direct Claude Code access with all Kronus features layered on top. This is the full-power interface for developers.

Telegram. Send text messages, voice notes, or photos. Get structured responses. Approve scope guard requests. Check project status. This works from your phone, anywhere.

Dashboard. A web interface showing active sessions, memory contents, project status, and cost tracking. Useful for monitoring, and for giving non-developers visibility into what the AI is doing.

Voice. Speak to Kronus through Telegram voice messages. The daemon transcribes your speech, processes the request, and sends back a text response. Useful when you're away from a keyboard.

Switch between interfaces freely. Start a task in the terminal, check its progress from Telegram, review the results in the dashboard. The context follows you.

Everything Stays Local

Your code, your memory, your configurations: all stored on your machine. No Kronus server holds your data.

The only thing that leaves your machine is Claude API calls, which go directly to Anthropic. This is identical to what raw Claude Code does. Kronus adds no additional external dependencies.

If you disconnect from the internet, your memory and configurations are still there. You just can't make API calls until you reconnect.

The Memory Cycle

This is the core of what makes Kronus different from other AI tools. Here is how it works:

This cycle compounds. The more you use Kronus, the more it knows.

Day 1: Basic project structure and tech stack. Week 1: Your coding preferences, naming conventions, architectural patterns. Month 1: Why you chose specific technologies, what you've tried and rejected, your team's communication style, project history across multiple codebases.

Memory is organized per-project, but cross-project patterns are captured too. If you always use Zod for validation across projects, Kronus learns that as a personal preference.

Agents and Skills

Kronus organizes AI capabilities into two categories:

Agents handle complex, multi-step work. A code review agent analyzes PRs for quality, security, and performance. A planner agent breaks large tasks into subtasks and dispatches them to other agents. Agents can work in teams, running in parallel on different aspects of the same problem.

Skills handle quick, single-command workflows. /test generates and runs tests. /review does a lightweight code review. /invoice generates an invoice from project data. Skills are fast, focused, and cheap to run.

Both are personalized during the setup interview. A frontend developer gets different agents and skills than a DevOps engineer. You can view, modify, and create your own in the .claude/ directory.

Cost Routing

Not every task needs the most powerful model. Kronus routes automatically:

This happens without configuration. You save money on simple tasks without sacrificing quality on complex ones.

Getting Started

Installation takes about 15 minutes. The setup interview asks about your role, stack, workflow, and team. Kronus generates a personalized set of agents, skills, and memory configuration based on your answers. After that, the daemon runs in the background and everything works through whichever interface you prefer.

What is a Second Brain?

The idea of a "second brain" comes from personal knowledge management. Tools like Notion, Obsidian, and Roam help you store and organize information externally so your biological brain doesn't have to hold everything. It's a powerful concept. But these tools share a fundamental limitation: they can only store and retrieve. They cannot act.

Kronus is a second brain that acts.

It remembers your decisions, understands your projects, knows your team, and can execute. Write code. Run tests. Generate documents. Deploy changes. Send emails. Manage tasks. All from memory, with context, personalized to you.

The difference between a note-taking app and a second brain that acts is the difference between a filing cabinet and a colleague who has read every file in it.

Why Not Just Use Claude Code?

Claude Code is the most powerful AI tool available. 80.8% on SWE-bench. A million tokens of context. Voice input. Computer use. It's extraordinary at what it does.

But every session starts from zero.

You open Claude Code and re-explain your project structure. You re-state your preferences. You re-describe the decision you made last week about the database schema. Context evaporates when the session ends. The next session is a stranger who happens to be very smart.

Kronus solves this with three layers:

1. Persistent Memory

Every session generates structured knowledge. Not a chat log. Structured, categorized, queryable memories: decisions you made and why, architectural patterns you chose, team preferences, project state, client requirements, debugging insights.

These memories persist indefinitely. When you start a new session, Kronus injects the relevant ones automatically. You don't search for them. You don't paste them. The right context appears because Kronus knows what's relevant based on what you're doing right now.

2. Personalized Agents

The setup interview generates agents tuned to your workflow. Not a generic assistant that can do a bit of everything. Specialized agents that understand your domain, your tools, your patterns.

A code-reviewer agent that knows your team's style guide. A security-auditor that understands your compliance requirements. A proposal-writer that matches your positioning and voice. Each one carries the accumulated memory of every previous interaction.

3. Universal Access

Terminal. Telegram. Dashboard. Voice. The second brain is available wherever you are, however you prefer to interact.

On your laptop, it's Claude Code in the terminal. On your phone, it's a Telegram conversation. In a meeting, it's a voice message. At your desk, it's the dashboard showing you what's happening across all projects. Same brain, same memory, different interfaces.

The Compounding Effect

Most tools deliver roughly the same value on day 1 and day 100. You learn the features, you use them, the experience plateaus.

Kronus works differently. It compounds.

Day 1: basic project context from the setup interview. Kronus knows your tech stack and can navigate your codebase.

Week 1: your coding patterns, architectural decisions, team preferences, communication style. Context from a dozen sessions shapes how Kronus responds and what it prioritizes.

Month 1: deep project knowledge across multiple codebases. Cross-project pattern recognition. Morning briefings that surface exactly what matters today. The AI starts anticipating what you need before you ask.

Month 6: institutional knowledge that no single team member holds entirely. The history of why decisions were made, not just what was decided. New team members inherit months of context on their first day.

This creates a switching cost, but not the artificial kind. Not a proprietary format or a walled garden. The cost of switching is losing months of accumulated understanding. The same reason you wouldn't replace a senior colleague who knows every corner of the codebase with a brilliant stranger who knows nothing about your project.

For Teams

The second brain concept extends beyond individual use. Each team member has their own Kronus with their own memory and personalized agents. But these instances can communicate.

Shared project memory: decisions, architecture choices, and project context are available to every team member's Kronus. A decision made in one session is known in every future session, regardless of who's asking.

Cross-instance coordination: multiple Kronuses can work on related tasks in parallel, aware of what each other is doing. Frontend and backend agents coordinate without the developers needing to sync manually.

Approval routing: sensitive actions route to the right person automatically. A deployment approval goes to the tech lead. A budget decision goes to the PM. The routing is configured, not manual.

Morning briefings with team context: each team member's daily briefing includes relevant activity from the whole team. What shipped yesterday. What's blocked. What needs attention.

A new team member doesn't start from zero. They run the 15-minute setup interview, and their Kronus immediately has access to the team's shared memory. Months of accumulated project context, decision history, and architectural knowledge. Available on day one.

For Non-Technical Users

The second brain serves any profession. Through Telegram and the dashboard, anyone on the team accesses the collective intelligence.

Ask questions and get real answers: > "What's blocking the billing feature?" > "When did we last deploy to production?" > "What was the rationale for choosing Postgres over MongoDB?"

These aren't search queries. Kronus answers from structured project memory with actual context, not keyword matches.

Trigger workflows through natural language: > "Generate an invoice for last month's work" > "Write a project status update for the client" > "Summarize what the team shipped this week"

No commands to memorize. Describe what you need. Kronus figures out which skill or agent to use.

You don't need to be part of a developer's team. Any professional can install and use Kronus directly.

The second brain builds, not just remembers. A professor describes a grading tool. Claude Code writes the code, creates the interface, connects it to their learning management system. The professor uses it through the dashboard or directly on their computer. They never see a line of code. But they built a real, working application.

Your existing tools become building blocks. Render engines, databases, spreadsheets, cloud APIs. The setup interview configures connections to whatever you use. Claude Code builds on top of your ecosystem.

See everything on the Dashboard: project status, costs, activity, session history. The dashboard is designed for people who want visibility without technical depth. No terminal knowledge required.

Voice works too: record a Telegram voice message with your question or request. Kronus transcribes and responds. Useful when you're mobile, in a meeting, or just prefer talking over typing.

The Vision

Claude Code is the engine. The raw capability. The intelligence.

Kronus is the brain. The memory. The personalization. The accessibility layer that makes that engine useful to an entire team, not just the person who knows how to use a terminal.

An engine without a brain is powerful but forgetful, accessible only to mechanics. A brain built on top of that engine remembers, learns, adapts, and serves everyone.

That's Kronus. Your AI second brain.

Next Steps

Kronus is designed around a simple principle: your code and data stay on your machine. Everything else follows from that.

Local-First Architecture

Everything runs locally. Code, memory, configurations, session history, agent definitions. All stored on your machine, managed by the Kronus daemon running in the background.

No Kronus server stores your data. There is no Kronus cloud. There is no account that holds your code.

The only external calls are to the Claude API (Anthropic), which is the same thing raw Claude Code does. Kronus adds no additional external dependencies. Your Claude Code API key stays on your machine and is never sent anywhere except Anthropic's API.

Scope Guard

Scope guard is the security layer between the AI and your system. Think of it as a firewall with human approval built in.

File Access Control

Each project has an allowlist that defines which files and directories the AI can read and write. If the AI tries to access something outside the allowlist, scope guard intercepts the request.

You define these boundaries per project. A web app project might allow full access to src/ and tests/ but block config/production/ and .env files. A monorepo might allow access to your team's package but block other teams' code.

Dangerous Command Blocking

Commands that could cause damage are blocked by default. Force-pushing to production, dropping databases, deleting directories outside the project, running unrecognized scripts. Scope guard catches these before they execute.

The default blocklist covers common dangerous patterns, and you can customize it per project.

Interactive Approvals

When the AI needs to do something outside its allowlist, you get a notification:

No action executes until you decide. There is no auto-approve mode. Every sensitive action requires human confirmation.

Audit Trails

Every action the AI takes is logged: what it did, when, which project, which interface triggered it, and whether scope guard was involved. You can review the full history in the dashboard.

Audit trails are stored locally, alongside your other Kronus data.

Per-Project Configuration

Each project can have its own security policy, independent of other projects:

A personal side project might have relaxed policies. A client project with sensitive data gets strict boundaries. A production infrastructure project might require approval for every command.

Team Security

When multiple people use Kronus on the same team, each person has their own instance with their own permissions.

Separate memory. Each team member's memory is private by default. Only explicitly shared entries are visible to teammates. Your personal preferences, draft notes, and private context stay yours.

Controlled sharing. When memory is shared, you choose what to share. Project decisions and architectural context can be shared. Personal notes and client-specific information can stay private.

Dashboard access levels. The dashboard supports different access levels. Developers get full access. PMs and managers can view session status and project progress. Clients and stakeholders can see read-only summaries. Each level shows only what's appropriate.

Cost tracking. API costs are tracked per project and per user. This prevents runaway spending and makes it clear where resources go. You can set spending limits per project if needed.

What Kronus Does NOT Do

Specifics matter more than promises. Here is what Kronus does not do:

Comparison to Cloud-Based AI Tools

Many AI tools run your code on external servers. Background agents on cloud VMs, code analysis on vendor infrastructure, cloud-stored session history.

Kronus takes the opposite approach. Your machine is the only machine involved. This means:

The tradeoff is that Kronus requires your machine to be running. There is no cloud fallback. For most developers, this is preferable. For teams that need cloud execution, other tools may be a better fit.

Claude Code is the engine. Kronus is the system built around it.

Kronus does not replace Claude Code. It runs Claude Code underneath. Every Claude Code feature (Voice Mode, Computer Use, /loop, 1M token context) works through Kronus. You get everything Claude Code offers, plus memory, agents, team features, and multiple access points.

Think of it this way: Claude Code is a powerful engine. Kronus gives that engine a brain, a team, and a phone.

Feature Comparison

What Kronus Adds

Memory That Compounds

Raw Claude Code starts from zero every session. You can write CLAUDE.md files manually, but maintaining them is on you.

Kronus extracts structured knowledge after every session: decisions made, preferences discovered, project state, people involved. Before the next session, relevant memories are injected automatically. Day 1, it knows your project basics. Month 1, it knows your architecture decisions, your coding style, your team's naming conventions, and why you chose Postgres over MongoDB.

Access Beyond the Terminal

Claude Code requires a terminal. That works for developers, but it locks out everyone else on the team.

Kronus adds Telegram (send tasks, approve actions, get updates from your phone), a web dashboard (view sessions, memory, costs), and voice input (speak naturally, get structured responses). Your PM can check project status from Telegram. Your client can see progress in the dashboard. No terminal required.

Personalized Agents, Not Generic Prompts

Claude Code's sub-agents are generic. They do what you tell them, but they don't know your stack, your workflow, or your priorities.

Kronus generates personalized agents during a 15-minute setup interview. A React developer gets a frontend-dev agent tuned for their component patterns. A DevOps engineer gets infrastructure agents that know their cloud provider. An agency owner gets proposal and client management agents.

Team Collaboration

Raw Claude Code is single-user. Each person works in isolation.

With Kronus, team members' instances can share memory. Your backend developer's Kronus knows about the API changes your frontend developer's Kronus is building against. Shared context means fewer miscommunications and less duplicated work.

Intelligent Cost Routing

Claude Code runs every task on the same model. A simple text extraction uses the same tier as a complex architectural analysis.

Kronus routes automatically. Quick formatting? Fast, cheap model. Code review? Balanced model. Multi-file architecture planning? Most powerful model available. Same quality, lower cost.

Who Should Stick With Raw Claude Code

If you work solo, live in the terminal, don't need memory between sessions, and prefer manual configuration, raw Claude Code is excellent on its own. It's a world-class tool.

Who Should Add Kronus

If you want persistent memory that compounds over time, mobile access, team collaboration, personalized agents, or non-developer access points, Kronus is the layer that makes Claude Code work for your whole team.

Kronus is free. It runs on your existing Claude Code plan. Zero additional cost.

Cursor and Kronus solve different problems. Cursor is an AI-enhanced code editor. Kronus is a persistent AI system that serves your whole team. Understanding the difference helps you choose the right tool, or use both.

Feature Comparison

What Cursor Does Well

Cursor excels at in-editor AI assistance. Tab autocomplete is fast and context-aware. The inline editing experience is smooth. Background agents can work on tasks while you continue coding. SOC 2 compliance matters for enterprise teams with strict security requirements.

If your primary need is faster code writing inside an IDE, Cursor delivers that.

Where Kronus Differs

Memory

Cursor does not maintain persistent memory between sessions. Each conversation starts fresh. Kronus extracts and stores structured knowledge after every session, then injects relevant context before the next one. Over time, Kronus accumulates deep project understanding that Cursor does not.

Beyond the Editor

Cursor lives inside the IDE. That's powerful for developers writing code, but it doesn't help your PM check project status, your client review progress, or your designer provide feedback.

Kronus serves the whole team through Telegram and a web dashboard. One developer installs Kronus, and the entire team can interact with it. No terminal or IDE required.

Local Execution

Cursor's background agents run on cloud VMs managed by Cursor. Your code goes to their servers for execution.

Kronus runs everything on your machine. Code stays local. The only external calls are to the Claude API (Anthropic), the same calls raw Claude Code makes.

Personalization

Cursor provides the same interface and capabilities to every user. Kronus generates a personalized set of agents and skills during a setup interview, tailored to your role, stack, and workflow.

Who Should Use Cursor

Developers who want AI autocomplete deeply integrated into their IDE. Teams that need SOC 2 compliance. People who prefer a visual editor over terminal workflows. Anyone who wants fast inline code suggestions while they type.

Who Should Use Kronus

Developers who want persistent memory across sessions. Teams where non-developers need AI access. Anyone who wants mobile task execution through Telegram. People who prefer their code to stay on their machine.

Can You Use Both?

Yes. They complement each other well. Cursor helps you write code faster in the editor. Kronus handles everything around the code: project memory, team coordination, mobile workflows, security audits, scheduled tasks, client communication. Use Cursor for editing, Kronus for everything else.

Devin and Kronus represent different philosophies about how AI should work with developers. Devin aims for full autonomy: give it a task, it completes it end-to-end. Kronus aims to be a second brain: persistent, collaborative, and always under your control.

Feature Comparison

What Devin Does Well

Devin's strength is autonomous task completion. You describe a task in natural language, and Devin works through it independently: reading code, writing changes, running tests, creating PRs. Its 67% PR merge rate on real-world tasks demonstrates real capability. The Knowledge system lets you teach Devin about your codebase through documented patterns.

For teams that want to hand off well-defined tasks and receive completed PRs, Devin delivers that workflow.

Where Kronus Differs

Control and Visibility

Devin is designed for autonomy. You hand it a task and it works independently, which is powerful but can feel opaque. When Devin makes an unexpected architectural decision, you discover it in the PR.

Kronus keeps you in the loop. Scope guard intercepts sensitive actions and sends approval requests to your Telegram. You see what the AI is doing and approve or deny each step. The dashboard shows session history, memory state, and cost tracking in real time.

Local Code Execution

Devin runs your code on Cognition's cloud servers. For many teams, this is fine. For teams with sensitive codebases, compliance requirements, or air-gapped environments, it's a blocker.

Kronus runs everything on your machine. Code never leaves your environment. The only external calls are to the Claude API (Anthropic), the same as raw Claude Code.

Team Access

Devin serves developers. The interface assumes technical users.

Kronus serves the whole team. Your PM can check project status through Telegram. Your client can review progress in the dashboard. Your designer can provide feedback through voice messages. One developer installs Kronus, and the team uses it through interfaces that match their comfort level.

Persistent Memory

Both tools have memory systems, but they work differently. Devin's Knowledge and Playbooks are manually configured. You write documentation about your codebase and Devin references it.

Kronus auto-extracts structured knowledge after every session. Decisions, preferences, project state, and people are captured and stored without manual effort. Before the next session, relevant memories are injected automatically. The knowledge graph grows with use.

Cost

Devin charges $20/mo for individuals and $500/mo for teams (with usage-based ACUs on top). Kronus is free. It runs on your existing Claude Code plan with no additional cost.

Who Should Use Devin

Teams that want fully autonomous task completion. Organizations comfortable with code running on external servers. Developers who prefer to hand off complete tasks and review the output.

Who Should Use Kronus

Teams that want human control over AI actions. Organizations that need code to stay local. Teams where non-developers need access. Anyone who wants persistent memory that compounds over time without manual maintenance.

The Key Difference

Devin is an autonomous agent that works alone. Kronus is a second brain that works with you and your team. Different philosophies, different use cases. The right choice depends on whether you want AI that works for you independently, or AI that works alongside you with full visibility.

OpenClaw and Kronus are both local-first AI systems, but they operate at completely different depths. OpenClaw is a shallow task runner for life admin. Kronus is a deep second brain for any professional domain. Understanding the boundary helps you pick the right tool for each job.

Feature Comparison

What OpenClaw Does Well

OpenClaw excels at personal task automation across messaging platforms. It connects to WhatsApp, Telegram, Slack, Discord, Signal, and iMessage, giving you a single AI assistant across every messaging app you use. The open-source community is massive, with extensive plugin support for email management, calendar scheduling, flight booking, CRM updates, and other daily life tasks.

For personal productivity and life admin, OpenClaw has broad coverage and an active ecosystem.

Where Kronus Differs

Deep, Not Shallow

OpenClaw automates errands. Kronus amplifies your thinking. This is the fundamental difference.

OpenClaw helps you book flights, sort email, and manage your calendar. Kronus helps you analyze research papers, review contracts, generate test suites, coordinate team projects, write proposals, and build on last week's work. The distinction is depth, not domain. A doctor uses Kronus to analyze medical literature via Telegram. A lawyer reviews contracts through the dashboard. A researcher brainstorms hypotheses with voice commands. A developer reviews pull requests and runs security audits. Same Claude Code engine, personalized to each person.

Code Awareness

OpenClaw cannot read your codebase, write code, run tests, or interact with your development environment. It's not designed to.

Kronus runs Claude Code underneath, giving it full access to your files and projects. It reads documents, writes code, analyzes research, generates reports, and reasons about complex problems with a 1M token context window.

Persistent Memory

OpenClaw does not maintain memory between sessions. Each interaction starts fresh.

Kronus auto-extracts structured knowledge after every session and injects relevant memories before the next one. Over time, it builds a deep understanding of your projects, decisions, preferences, and team dynamics.

Specialized Agents

OpenClaw uses a single general-purpose agent for all tasks.

Kronus generates multiple specialized agents during a setup interview: frontend development, backend infrastructure, security auditing, code review, proposal writing, and more. Each agent has domain-specific knowledge and tools. A planner agent coordinates them for complex tasks.

Team Collaboration

OpenClaw is single-user. Kronus supports multi-user collaboration where team members' instances share relevant memory. Your backend developer's Kronus can be aware of API changes your frontend developer's Kronus is working with.

Who Should Use OpenClaw

People who want AI help with personal tasks. Managing email across accounts, scheduling meetings, booking travel, updating CRM entries. Shallow task automation across every messaging platform.

Who Should Use Kronus

Anyone who needs deep analysis, persistent memory, and the ability to build custom tools. Developers, researchers, doctors, lawyers, professors, bankers, consultants, agencies, and teams who need AI that understands their domain, remembers their decisions, and serves them through multiple access points.

Can They Work Together?

Potentially. Kronus could route non-development tasks to OpenClaw through its MCP integration. Use OpenClaw for personal task automation, Kronus for professional work. Different tools for different domains, each doing what it does best.

What You Can Build

Through Kronus, Claude Code builds real applications for any profession. You describe the outcome. Claude Code handles the implementation.

They never see code. They describe what they need through Telegram, voice, or the dashboard. Claude Code writes it, runs it, and delivers the result.

The Key Difference

OpenClaw automates your existing tasks. Kronus creates new capabilities. OpenClaw books your flight. Kronus builds your flight booking system. One runs errands. The other amplifies your thinking and extends what you can create.