Mirror_Repos/Kilo-Org_kilo
2
0
Fork 0
Code Issues Pull Requests Actions 91 Packages Projects Releases Wiki Activity

Merge branch 'main' into docs/cli-config-path-1.0

Browse Source
This commit is contained in:
Jean du Plessis
2026-02-18 12:30:38 +02:00
committed by GitHub
parent fe7045a62b 0bc5540450
commit 7c2da4d401
25 changed files with 1325 additions and 102 deletions
Download Patch File Download Diff File Expand all files Collapse all files
packages/kilo-docs/AGENTS.md
+94
View File
@@ -0,0 +1,94 @@
## Project Overview
This is the Kilo Code documentation site. Kilo Code is the leading open source agentic engineering platform.
## Dev Server
The dev server is run with `bun dev` and runs on `http://localhost:3002`. Typically the user will be running it themselves, so always check if it is running FIRST before deciding to run it yourself to test something.
## Branch Naming Convention
When making changes _only_ to the documentation, create branches with the `docs/` prefix:
```bash
git checkout -b docs/description-of-change
```
This convention helps identify documentation-only PRs and keeps them organized.
## Markdoc Custom Tags
This project uses [Markdoc](https://markdoc.dev/) for rendering markdown with custom components. Custom tags allow you to embed React components directly in markdown files.
### Images
Use the Markdoc image tag format:
```markdown
{% image src="/docs/img/kilo-provider/connected-accounts.png" alt="Connect account screen" width="800" caption="Connect account screen" /%}
```
Note that this site is served under kilo.ai/docs so the `/docs` prefix **must** be present in every image path.
Image attributes:
| Attribute | Type | Required | Description |
| --------- | ------ | -------- | ------------------------------------------- |
| `src` | String | Yes | The image source URL |
| `alt` | String | Yes | Alternative text for the image |
| `width` | String | No | Width of the image (e.g., '500px', '80%') |
| `height` | String | No | Height of the image (e.g., '300px', 'auto') |
| `caption` | String | No | Caption displayed below the image |
### Callouts
Use the Markdoc callout tag format:
```markdown
{% callout type="info" %}
You can report any bugs or feedback by chatting with us in our [Discord server](https://discord.gg/ovhcloud), in the AI Endpoints channel.
{% /callout %}
```
Callout attributes:
| Attribute | Type | Default | Description |
| ----------- | ------- | ------- | ------------------------------------------------- |
| `title` | String | - | Optional custom title for the callout |
| `type` | String | "note" | One of: generic, note, tip, info, warning, danger |
| `collapsed` | Boolean | false | When true, the callout starts collapsed |
### Codicons
Use the Markdoc codicon tag format:
```markdown
{% codicon name="gear" /%}
```
## Documentation Guidelines
### Adding New Pages
1. Create your page in the appropriate directory under `pages/`
2. **Always update navigation**: Add the page to the corresponding navigation file in `lib/nav/`
- Each section has its own nav file (e.g., `getting-started.ts`, `code-with-ai.ts`, `ai-providers.ts`)
- Navigation structure is exported from `lib/nav/index.ts`
- See `lib/types.ts` for the `NavSection` and `NavLink` interfaces
### Removing or Moving Pages
**Never remove a page without adding a redirect.** This prevents broken links from search engines, external references, and user bookmarks.
1. Add a redirect entry to `previous-docs-redirects.js`
2. Redirect format:
```javascript
{
source: "/docs/old-path",
destination: "/docs/new-path",
basePath: false,
permanent: true,
}
```
3. Update the navigation file to remove or update the link
4. Redirects are loaded in `next.config.js`
packages/kilo-docs/components/Image.tsx
+58
View File
@@ -0,0 +1,58 @@
import React from "react"
interface ImageProps {
src: string
alt: string
width?: string
height?: string
caption?: string
}
// Helper to add 'px' to numeric values that don't have units
function addPxIfNeeded(value: string): string {
// If the value is purely numeric, add 'px'
if (/^\d+(\.\d+)?$/.test(value)) {
return `${value}px`
}
return value
}
export function Image({ src, alt, width, height, caption }: ImageProps) {
const imgStyle: React.CSSProperties = {
maxWidth: "100%",
height: "auto",
}
if (width) imgStyle.width = addPxIfNeeded(width)
if (height) imgStyle.height = addPxIfNeeded(height)
const figureStyle: React.CSSProperties = {
margin: "1.5rem 0",
maxWidth: "100%",
overflow: "hidden",
}
// If width is specified, apply it to the figure to constrain caption width
if (width) {
figureStyle.width = addPxIfNeeded(width)
figureStyle.maxWidth = "100%"
}
return (
<figure style={figureStyle}>
<img src={src} alt={alt} style={imgStyle} />
{caption && (
<figcaption
style={{
fontStyle: "italic",
textAlign: "center",
marginTop: "0.5rem",
color: "var(--gray-600, #6b7280)",
width: "100%",
}}>
{caption}
</figcaption>
)}
</figure>
)
}
packages/kilo-docs/components/TopNav.tsx
+1
View File
@@ -48,6 +48,7 @@ const contributingItems: DropdownItem[] = [
const helpItems: DropdownItem[] = [
{ label: "Documentation", href: "/", description: "Browse all documentation" },
{ label: "FAQ", href: "/getting-started/faq", description: "Frequently asked questions" },
{ label: "Community Projects", href: "/community", description: "Explore community resources" },
{ label: "Support", href: "https://kilo.ai/support", description: "Get help from the team" },
{
label: "Changelog",
packages/kilo-docs/lib/nav/automate.ts
+1
View File
@@ -8,6 +8,7 @@ export const AutomateNav: NavSection[] = [
{ href: "/automate/integrations", children: "Integrations" },
{ href: "/automate/code-reviews", children: "Code Reviews" },
{ href: "/automate/agent-manager", children: "Agent Manager" },
{ href: "/automate/kiloclaw", children: "KiloClaw" },
],
},
{
packages/kilo-docs/lib/nav/contributing.ts
+4
View File
@@ -34,6 +34,10 @@ export const ContributingNav: NavSection[] = [
href: "/contributing/architecture/annual-billing",
children: "Annual Billing",
},
{
href: "/contributing/architecture/benchmarking",
children: "Benchmarking",
},
{
href: "/contributing/architecture/enterprise-mcp-controls",
children: "Enterprise MCP Controls",
packages/kilo-docs/lib/nav/getting-started.ts
+14
View File
@@ -46,6 +46,20 @@ export const GettingStartedNav: NavSection[] = [
href: "/getting-started/migrating",
children: "Migrating from Cursor",
},
{
href: "/getting-started/troubleshooting",
children: "Troubleshooting",
subLinks: [
{
href: "/getting-started/troubleshooting/troubleshooting-extension",
children: "Extension Troubleshooting",
},
],
},
{
href: "/getting-started/using-docs-with-agents",
children: "Using Docs with Agents",
},
],
},
]
packages/kilo-docs/pages/automate/kiloclaw.md
+124
View File
@@ -0,0 +1,124 @@
---
title: "KiloClaw"
description: "One-click deployment of your personal AI agent with OpenClaw"
---
# KiloClaw 🦀
KiloClaw is Kilo's hosted [OpenClaw](https://openclaw.ai) service—a one-click deployment that gives you a personal AI agent without the complexity of self-hosting. OpenClaw is an open source AI agent that connects to chat platforms like WhatsApp, Telegram, and Discord.
## Why KiloClaw?
- **No infrastructure setup** — Skip Docker, servers, and configuration files
- **Instant provisioning** — Your agent is ready in seconds
- **Uses existing credits** — Runs on your Kilo Gateway balance
- **Multiple free models** — Choose from several models at no additional cost
- **Web UI included** — Access your agent's web interface from the instance dashboard
## Prerequisites
Before creating an instance:
- **Kilo account** — Sign up at [kilo.ai](https://kilo.ai) if you haven't already
- **Gateway credits** — KiloClaw uses your existing [Gateway credits](/docs/gateway/usage-and-billing) for model inference
## Creating an Instance
1. Navigate to your [Kilo profile](https://app.kilo.ai/profile)
2. Click **Claw** in the left navigation
{% image src="/docs/img/kiloclaw/profile-claw-nav.png" alt="Profile page showing Claw navigation" width="400" caption="Claw navigation in profile sidebar" /%}
3. Click **Create Instance**
4. Select your preferred model from the dropdown. See all available models at the [Kilo Leaderboard](https://kilo.ai/leaderboard#all-models).
{% image src="/docs/img/kiloclaw/create-instance.png" alt="Create instance modal with model selection" width="600" caption="Model selection during instance creation" /%}
5. Click **Create & Provision**
Your instance will be provisioned and ready within seconds.
## Managing Your Instance
Once created, you can control your instance from the dashboard.
{% image src="/docs/img/kiloclaw/instance-dashboard.png" alt="Instance dashboard with controls and status" width="800" caption="Instance management dashboard" /%}
### Instance Controls
- **Start** — Boot up a stopped instance
- **Stop** — Shut down the instance (preserves configuration)
- **Restart** — Stop and start the instance
### Dashboard Tabs
| Tab | Purpose |
| ------------ | ----------------------------------------------- |
| **Overview** | Instance status, uptime, and resource usage |
| **Settings** | Model configuration and instance parameters |
| **Actions** | Quick actions and connected platform management |
## Accessing Your Agent
To connect to your agent's web interface:
1. Click **Get Access Code** from your instance dashboard
2. Copy the one-time access code (expires in 10 minutes)
{% image src="/docs/img/kiloclaw/access-code-modal.png" alt="Access code modal showing one-time code" width="500" caption="One-time access code with 10-minute expiration" /%}
3. Click the **Open Claw** button in the top-right corner of your instance dashboard
4. Enter your access code to authenticate
{% image src="/docs/img/kiloclaw/openclaw-dashboard.png" alt="OpenClaw web interface" width="800" caption="OpenClaw web UI" /%}
## Connecting Chat Platforms
OpenClaw supports integration with popular messaging platforms:
- WhatsApp
- Telegram
- Discord
- Slack
- And more
For platform-specific setup instructions, refer to the [OpenClaw documentation](https://docs.openclaw.ai).
## Using your OpenClaw Agent
OpenClaw lets you customize your own AI assistant that can actually take action — check your email, manage your calendar, control smart devices, browse the web, and message you on Telegram or Discord when something needs attention. It's like having a personal assistant that runs 24/7, with the skills and access you choose to give it.
For more information on use cases for OpenClaw, see:
- [OpenClaw Showcase](https://docs.openclaw.ai/start/showcase)
- [100 hours of OpenClaw in 35 Minutes](https://www.youtube.com/watch?v=_kZCoW-Qxnc)
- [Clawhub](https://clawhub.ai/): search for skills
## Pricing
KiloClaw uses your existing Kilo Gateway credits—there's no separate billing or subscription:
- **Instance hosting** — Free for 7 days during beta
- **Model inference** — Charged against your Gateway credit balance
- **Free models** — Several models are available at no cost. See the [Kilo Leaderboard](https://kilo.ai/leaderboard#all-models) for current availability.
See [Gateway Usage and Billing](/docs/gateway/usage-and-billing) for credit pricing details.
## Limitations
KiloClaw is currently in **beta**. Current constraints include:
- **One instance per account** — Each user can run a single KiloClaw instance
- **Model availability** — Some models may have rate limits during high demand
- **Session persistence** — Chat history may be cleared during beta updates
- **Feature parity** — Not all OpenClaw features are available in the hosted version yet
{% callout type="info" %}
Have feedback or running into issues? Join the [Kilo Discord](https://kilo.ai/discord) and share it in the KiloClaw channel.
{% /callout %}
## Related
- [Gateway Usage and Billing](/docs/gateway/usage-and-billing)
- [Agent Manager](/docs/automate/agent-manager)
- [OpenClaw Documentation](https://docs.openclaw.ai)
packages/kilo-docs/pages/code-with-ai/agents/using-modes.md
+121
View File
@@ -0,0 +1,121 @@
---
title: "Using Modes"
description: "Understanding and using different modes in Kilo Code"
---
# Using Modes
Modes in Kilo Code are specialized personas that tailor the assistant's behavior to your current task. Each mode offers different capabilities, expertise, and access levels to help you accomplish specific goals.
## Why Use Different Modes?
- **Task specialization:** Get precisely the type of assistance you need for your current task
- **Safety controls:** Prevent unintended file modifications when focusing on planning or learning
- **Focused interactions:** Receive responses optimized for your current activity
- **Workflow optimization:** Seamlessly transition between planning, implementing, debugging, and learning
{% youtube url="https://youtu.be/cS4vQfX528w" caption="Explaining the different modes in Kilo Code" /%}
## Switching Between Modes
Four ways to switch modes:
1. **Dropdown menu:** Click the selector to the left of the chat input
{% image src="/docs/img/modes/modes.png" alt="Using the dropdown menu to switch modes" width="400" /%}
2. **Slash command:** Type `/architect`, `/ask`, `/debug`, or `/code` in the chat input to switch modes. Type `/newtask` to create a new task, or `/smol` to condense your context window.
{% image src="/docs/img/modes/modes-1.png" alt="Using slash commands to switch modes" width="400" /%}
### Understanding /newtask vs /smol
Users often confuse `/newtask` and `/smol`. Here's the key difference:
| Command | Purpose | When to Use |
| ---------- | ----------------------------------------------------- | ----------------------------------------------------------------------- |
| `/newtask` | Creates a new task with context from the current task | When you want to start something new while carrying over context |
| `/smol` | Condenses your current context window | When your conversation is getting too long and you want to summarize it |
3. **Toggle command/Keyboard shortcut:** Use the keyboard shortcut below, applicable to your operating system. Each press cycles through the available modes in sequence, wrapping back to the first mode after reaching the end.
| Operating System | Shortcut |
| ---------------- | -------- |
| macOS | ⌘ + . |
| Windows | Ctrl + . |
| Linux | Ctrl + . |
4. **Accept suggestions:** Click on mode switch suggestions that Kilo Code offers when appropriate
{% image src="/docs/img/modes/modes-2.png" alt="Accepting a mode switch suggestion from Kilo Code" width="400" /%}
## Built-in Modes
### Code Mode (Default)
| Aspect | Details |
| -------------------- | -------------------------------------------------------------------------------------------------------- |
| **Description** | A skilled software engineer with expertise in programming languages, design patterns, and best practices |
| **Tool Access** | Full access to all tool groups: `read`, `edit`, `browser`, `command`, `mcp` |
| **Ideal For** | Writing code, implementing features, debugging, and general development |
| **Special Features** | No tool restrictions—full flexibility for all coding tasks |
### Ask Mode
| Aspect | Details |
| -------------------- | ------------------------------------------------------------------------------------------------- |
| **Description** | A knowledgeable technical assistant focused on answering questions without changing your codebase |
| **Tool Access** | Limited access: `read`, `browser`, `mcp` only (cannot edit files or run commands) |
| **Ideal For** | Code explanation, concept exploration, and technical learning |
| **Special Features** | Optimized for informative responses without modifying your project |
### Architect Mode
| Aspect | Details |
| -------------------- | ---------------------------------------------------------------------------------------------------- |
| **Description** | An experienced technical leader and planner who helps design systems and create implementation plans |
| **Tool Access** | Access to `read`, `browser`, `mcp`, and restricted `edit` (markdown files only) |
| **Ideal For** | System design, high-level planning, and architecture discussions |
| **Special Features** | Follows a structured approach from information gathering to detailed planning |
### Debug Mode
| Aspect | Details |
| -------------------- | ----------------------------------------------------------------------------------- |
| **Description** | An expert problem solver specializing in systematic troubleshooting and diagnostics |
| **Tool Access** | Full access to all tool groups: `read`, `edit`, `browser`, `command`, `mcp` |
| **Ideal For** | Tracking down bugs, diagnosing errors, and resolving complex issues |
| **Special Features** | Uses a methodical approach of analyzing, narrowing possibilities, and fixing issues |
{% callout type="tip" %}
**Keep debugging separate from main tasks:** When using Debug mode, ask Kilo to "start a new task in Debug mode with all of the necessary context needed to figure out X" so that the debugging process uses its own context window and doesn't pollute the main task.
{% /callout %}
### Orchestrator Mode
| Aspect | Details |
| -------------------- | ------------------------------------------------------------------------------------------------------------------- |
| **Description** | A strategic workflow orchestrator who coordinates complex tasks by delegating them to appropriate specialized modes |
| **Tool Access** | Limited access to create new tasks and coordinate workflows |
| **Ideal For** | Breaking down complex projects into manageable subtasks assigned to specialized modes |
| **Special Features** | Uses the new_task tool to delegate work to other modes |
### Review Mode
| Aspect | Details |
| -------------------- | --------------------------------------------------------------------------------------------------------------------------------- |
| **Description** | An expert code reviewer specializing in analyzing changes to provide structured feedback on quality, security, and best practices |
| **Tool Access** | Access to `read`, `browser`, `mcp`, and when permitted, `edit` |
| **Ideal For** | Catching issues early, enforcing code standards, accelerating PR turnaround |
| **Special Features** | Code review before committing, surfacing feedback across performance, security, style, and test coverage |
## Custom Modes
Create your own specialized assistants by defining tool access, file permissions, and behavior instructions. Custom modes help enforce team standards or create purpose-specific assistants. See [Custom Modes documentation](/docs/customize/custom-modes) for setup instructions.
<!--
EXISTING PAGES TO MIGRATE:
- `basic-usage/using-modes` - Modes documentation
Migrate the existing modes documentation here.
-->
packages/kilo-docs/pages/code-with-ai/platforms/cli.md
+8 -102
View File
@@ -169,6 +169,14 @@ Configuration is managed through:
- `/connect` command for provider setup (interactive)
- Config files in **`~/.config/kilo/`**: the CLI (Kilo CLI 1.0 from [Kilo-Org/kilo](https://github.com/Kilo-Org/kilo)) merges `config.json`, `opencode.json`, and `opencode.jsonc`. Use **`opencode.json`** (or `opencode.jsonc`) for provider, model, permission, and **MCP** settings. Restart the CLI after editing. See [Using MCP in the CLI](/automate/mcp/using-in-cli) for MCP config format.
- `kilo auth` for credential management
## Slash Commands
The CLI's interactive mode supports slash commands for common operations. The main commands are documented above in the [Interactive Slash Commands](#interactive-slash-commands) section.
{% callout type="tip" %}
**Confused about /newtask vs /smol in the IDE?** See the [Using Modes](/docs/code-with-ai/agents/using-modes#understanding-newtask-vs-smol) documentation for details.
{% /callout %}
## Permissions
@@ -351,108 +359,6 @@ to complete configuration with an interactive workflow on the command line.
You can also use the `/config` slash command during an interactive session, which is equivalent to running `kilocode config`.
{% /callout %}
## Parallel mode
### Available Permissions
Permissions are keyed by tool name, plus a couple of safety guards:
- `read` — reading a file (matches the file path)
- `edit` — all file modifications (covers edit, write, patch, multiedit)
- `glob` — file globbing (matches the glob pattern)
- `grep` — content search (matches the regex pattern)
- `list` — listing files in a directory (matches the directory path)
- `bash` — running shell commands (matches parsed commands like `git status --porcelain`)
- `task` — launching subagents (matches the subagent type)
- `skill` — loading a skill (matches the skill name)
- `lsp` — running LSP queries (currently non-granular)
- `todoread`, `todowrite` — reading/updating the todo list
- `webfetch` — fetching a URL (matches the URL)
- `websearch`, `codesearch` — web/code search (matches the query)
- `external_directory` — triggered when a tool touches paths outside the project working directory
- `doom_loop` — triggered when the same tool call repeats 3 times with identical input
### Defaults
If you don't specify anything, Kilo starts from permissive defaults:
- Most permissions default to `"allow"`.
- `doom_loop` and `external_directory` default to `"ask"`.
- `read` is `"allow"`, but `.env` files are denied by default:
```json
{
"permission": {
"read": {
"*": "allow",
"*.env": "deny",
"*.env.*": "deny",
"*.env.example": "allow"
}
}
}
```
### What "Ask" Does
When Kilo prompts for approval, the UI offers three outcomes:
- **once** — approve just this request
- **always** — approve future requests matching the suggested patterns (for the rest of the current session)
- **reject** — deny the request
The set of patterns that "always" would approve is provided by the tool (for example, bash approvals typically whitelist a safe command prefix like `git status*`).
### Agent Permissions
You can override permissions per agent. Agent permissions are merged with the global config, and agent rules take precedence.
```json
{
"$schema": "https://kilo.ai/config.json",
"permission": {
"bash": {
"*": "ask",
"git *": "allow",
"git commit *": "deny",
"git push *": "deny",
"grep *": "allow"
}
},
"agent": {
"build": {
"permission": {
"bash": {
"*": "ask",
"git *": "allow",
"git commit *": "ask",
"git push *": "deny",
"grep *": "allow"
}
}
}
}
}
```
You can also configure agent permissions in Markdown:
```markdown
---
description: Code review without edits
mode: subagent
permission:
edit: deny
bash: ask
webfetch: deny
---
Only analyze code and suggest changes.
```
{% callout type="tip" %}
Use pattern matching for commands with arguments. `"grep *"` allows `grep pattern file.txt`, while `"grep"` alone would block it. Commands like `git status` work for default behavior but require explicit permission (like `"git status *"`) when arguments are passed.
{% /callout %}
## Interactive Mode
Interactive mode is the default mode when running Kilo Code without the `--auto` flag, designed to work interactively with a user through the console.
packages/kilo-docs/pages/collaborate/enterprise/migration.md
+391
View File
@@ -0,0 +1,391 @@
---
title: "Migration"
description: "Migrate your team to Kilo Code Enterprise"
---
# Migration
Switch to **Kilo Teams** or **Kilo Enterprise** from other AI coding tools and experience transparent pricing, no vendor lock-in, and superior team management capabilities.
## Why Teams Switch to Kilo
### Transparency vs. Opacity
**Other AI coding vendors** hide their true costs behind opaque subscription models, leaving you wondering what you're actually paying for.
**Kilo Teams** and **Kilo Enterprise** show you exactly what each AI request costs - no markup, no hidden fees, complete transparency.
### No Rate Limiting
**Other tools** slow you down with rate limits and model switching when you need AI most.
**Kilo Teams** and **Kilo Enterprise** never limit your usage - pay for what you use, use what you need.
### True Team Management
**Other solutions** offer basic user management with limited visibility.
**Kilo Teams** provides comprehensive team analytics, role-based permissions, and detailed usage insights, while **Kilo Enterprise** adds advanced governance, audit logging, and enterprise-level security controls.
## Migrating from Cursor
### What You're Leaving Behind
- **Opaque pricing** - Never knowing true AI costs
- **Rate limiting** during peak usage periods
- **Limited team visibility** into usage patterns
- **Vendor lock-in** with proprietary systems
- **Hidden model switching** that degrades quality
### What You Gain with Kilo Teams or Kilo Enterprise
- **Transparent AI costs** - See exactly what providers charge
- **No rate limiting** - Use AI when you need it most
- **Comprehensive analytics** - Understand team usage patterns
- **Open source extension** - No vendor lock-in
- **Consistent quality** - No hidden model downgrades
- **Enterprise controls** _(Enterprise only)_ - SSO, audit logs, and advanced configuration options
### Migration Process
**Step 1: Team Assessment**
1. **Audit current Cursor usage** across your team
2. **Identify active users** and their usage patterns
3. **Calculate current costs** (if visible) vs. Kilo pricing
4. **Plan migration timeline** to minimize disruption
**Step 2: Kilo Setup**
1. **Create organization** at [app.kilocode.com](https://app.kilocode.com)
2. **Subscribe to Teams ($15/user/month)** or **Enterprise ([Contact Sales](https://kilo.ai/contact-sales))**
3. **Configure team settings** and usage policies
4. **Purchase initial AI credits** based on usage estimates
**Step 3: Team Migration**
1. **Invite team members** to Kilo
2. **Install Kilo Code extension** alongside Cursor initially
3. **Migrate projects gradually** starting with non-critical work
4. **Train team** on Kilo Code features and workflows
**Step 4: Full Transition**
1. **Monitor usage patterns** in Kilo dashboard
2. **Optimize settings** based on team feedback
3. **Cancel Cursor subscriptions** once fully migrated
4. **Uninstall Cursor** from team machines
### Cursor Feature Mapping
| Cursor Feature | Kilo Equivalent |
| ---------------------- | -------------------------------------------------------------- |
| AI Chat | Chat interface with multiple modes |
| Code Generation | Code mode with advanced tools |
| Code Editing | Fast edits and surgical modifications |
| Codebase Understanding | Codebase indexing and search |
| Team Management | Comprehensive team dashboard (Enterprise adds SSO, audit logs) |
| Usage Analytics | Detailed usage and cost analytics |
## Migrating from GitHub Copilot
### Limitations You're Escaping
- **Limited model choice** - Stuck with GitHub's model selection
- **Basic team features** - Minimal team management capabilities
- **No cost visibility** - Hidden usage costs in subscription
- **Microsoft ecosystem lock-in** - Tied to Microsoft services
- **Limited customization** - Few options for team-specific needs
### Kilo Advantages
- **Multiple AI providers** - Choose from 18+ model providers
- **Advanced team management** - Roles, permissions, and analytics
- **Transparent pricing** - See exact costs for every request
- **Provider flexibility** - Switch providers or use your own API keys
- **Extensive customization** - Custom modes and team policies
- **Enterprise-level governance** _(Enterprise only)_ - Model filtering, audit logging, and compliance support
### Migration Strategy
**Phase 1: Parallel Usage (Week 1-2)**
1. **Keep GitHub Copilot** active during transition
2. **Install Kilo Code** extension for team members
3. **Start with simple tasks** in Kilo Code
4. **Compare results** and team satisfaction
**Phase 2: Gradual Transition (Week 3-4)**
1. **Use Kilo Code** for new projects
2. **Migrate existing projects** one at a time
3. **Train team** on advanced features
4. **Optimize usage patterns** based on analytics
**Phase 3: Full Migration (Week 5+)**
1. **Disable GitHub Copilot** for most team members
2. **Cancel GitHub Copilot** subscriptions
3. **Optimize Kilo Plan** settings
4. **Document new workflows** and best practices
### GitHub Copilot Feature Comparison
| GitHub Copilot | Kilo | Advantage |
| ---------------- | -------------------------------- | ----------------------------- |
| Code suggestions | AI-powered code generation | ✅ More model choices |
| Chat interface | Multi-mode chat system | ✅ Specialized modes |
| Team admin | Comprehensive team management | ✅ Enterprise adds audit logs |
| Usage insights | Detailed usage and cost tracking | ✅ Transparent pricing |
| Model selection | 18+ AI providers and models | ✅ No vendor lock-in |
## Migrating from Other AI Coding Tools
### Common Migration Patterns
**From Tabnine**
- **Benefit:** More advanced AI models and team features
- **Process:** Export settings, migrate team, configure advanced features
- **Timeline:** 1-2 weeks for full transition
**From CodeWhisperer**
- **Benefit:** Escape AWS ecosystem lock-in, better team management
- **Process:** Parallel usage, gradual migration, team training
- **Timeline:** 2-3 weeks for enterprise teams
**From Replit AI**
- **Benefit:** Use in VS Code instead of web-based IDE
- **Process:** Export projects, set up local development, team onboarding
- **Timeline:** 3-4 weeks including development environment setup
### Universal Migration Checklist
**Pre-Migration Planning**
- [ ] Audit current AI coding tool usage
- [ ] Identify team members and their roles
- [ ] Calculate current costs vs. Kilo pricing
- [ ] Plan migration timeline and milestones
- [ ] Prepare team communication and training
**Migration Execution**
- [ ] Set up Kilo Organization
- [ ] Configure team settings and policies
- [ ] Invite team members and assign roles
- [ ] Install Kilo Code extension across team
- [ ] Start with pilot projects or non-critical work
**Post-Migration Optimization**
- [ ] Monitor usage patterns and costs
- [ ] Optimize team settings based on analytics
- [ ] Train team on advanced features
- [ ] Cancel previous AI coding tool subscriptions
- [ ] Document new workflows and best practices
## Technical Migration: Rules and Configurations
Kilo Code uses a compatible rules system that supports Cursor and Windsurf patterns. Migrating your custom rules and configurations is straightforward and typically takes 5-10 minutes per project.
**Quick Overview:**
- **Project rules**: `.cursor/rules/*.mdc` → `.kilocode/rules/*.md` (remove YAML frontmatter, keep Markdown content)
- **Legacy rules**: `.cursorrules` → `.kilocode/rules/legacy-rules.md`
- **AGENTS.md**: Works identically in Kilo Code (no conversion needed)
- **Global rules**: Recreate in `~/.kilocode/rules/*.md` directory
Kilo Code also supports mode-specific rules (`.kilocode/rules-{mode}/`), which Cursor and Windsurf don't have. This allows different rules for different workflows (e.g., Code mode vs Debug mode).
**👉 For detailed step-by-step instructions, format conversion examples, troubleshooting, and advanced migration scenarios, see our [Technical Migration Guide](/docs/getting-started/migrating).**
## Cost Comparison Analysis
### Hidden Costs in Other Tools
**Subscription Models Hide True Costs**
- Monthly fees regardless of actual usage
- No visibility into per-request costs
- Rate limiting forces inefficient workflows
- Model switching without notification
**Kilo Transparent Pricing**
- Pay exactly what AI providers charge
- See cost of every request in real-time
- No rate limiting or usage restrictions
- Choose optimal models for each task
### ROI Calculation Framework
**Current Tool Analysis**
1. **Monthly subscription costs** × team size
2. **Hidden productivity losses** from rate limiting
3. **Opportunity costs** from limited model access
4. **Management overhead** from poor team visibility
**Kilo Benefits**
1. **Transparent AI costs** (typically 30-50% lower)
2. **Productivity gains** from no rate limiting
3. **Better outcomes** from optimal model selection
4. **Reduced management time** with comprehensive analytics
## Team Training and Adoption
### Training Program Structure
**Week 1: Basics**
- Kilo Code extension installation and setup
- Basic chat interface and mode usage
- Understanding transparent pricing model
- Team dashboard overview
**Week 2: Advanced Features**
- Custom modes and specialized workflows
- Advanced tools and automation
- Team collaboration features
- Usage optimization strategies
**Week 3: Team Optimization**
- Analytics review and insights
- Cost optimization techniques
- Workflow integration and best practices
- Advanced team management features
### Adoption Best Practices
**Start Small**
- Begin with volunteer early adopters
- Use for non-critical projects initially
- Gather feedback and iterate
- Expand gradually across team
**Provide Support**
- Dedicated migration support channel
- Regular check-ins with team members
- Documentation and training resources
- Quick resolution of issues and questions
**Measure Success**
- Track usage adoption rates
- Monitor cost savings and efficiency gains
- Collect team satisfaction feedback
- Document success stories and best practices
## Common Migration Challenges
### Technical Challenges
**Extension Conflicts**
- **Issue:** Multiple AI coding extensions interfering
- **Solution:** Disable old extensions during transition
- **Prevention:** Staged migration with clear timelines
**Workflow Disruption**
- **Issue:** Team productivity dip during transition
- **Solution:** Parallel usage period with gradual migration
- **Prevention:** Comprehensive training and support
**Settings Migration**
- **Issue:** Lost customizations from previous tools
- **Solution:** Document and recreate important settings
- **Prevention:** Settings audit before migration
**Rules and Configuration Migration**
- **Issue:** Custom rules and configurations not migrating automatically
- **Solution:** Follow the [technical migration guide](/docs/getting-started/migrating) to manually migrate rules
- **Prevention:** Audit rules before migration, use version control for rules
### Organizational Challenges
**Change Resistance**
- **Issue:** Team members reluctant to switch tools
- **Solution:** Demonstrate clear benefits and provide training
- **Prevention:** Involve team in migration planning
**Budget Approval**
- **Issue:** Finance team concerns about new tool costs
- **Solution:** Provide detailed cost comparison and ROI analysis
- **Prevention:** Transparent pricing documentation
**Timeline Pressure**
- **Issue:** Pressure to migrate quickly without proper planning
- **Solution:** Phased migration approach with clear milestones
- **Prevention:** Realistic timeline planning with buffer time
## Migration Support
### Professional Migration Services
- **Migration planning** and timeline development
- **Team training** and onboarding support
- **Custom integration** development
- **Ongoing optimization** consulting
### Self-Service Resources
- **Migration guides** for specific tools
- **[Technical migration guide](/docs/getting-started/migrating)** for rules and configurations (Cursor/Windsurf)
- **Video tutorials** for common migration scenarios
- **Community support** through Discord and forums
- **Documentation** and best practices
### Getting Migration Help
- **Email:** migrations@kilo.ai
- **Discord:** Join our migration support channel
- **Consultation:** Schedule free migration planning call
- **Documentation:**
- [Business migration guide](/docs/plans/migration) (this page)
- [Technical migration guide](/docs/getting-started/migrating) (rules and configurations)
## Success Stories
### Mid-Size Software Company (25 developers)
**Previous:** Cursor Pro subscriptions
**Challenge:** High costs with limited visibility
**Result:** 40% cost reduction with better team insights
**Timeline:** 3-week migration with zero productivity loss
### Enterprise Development Team (100+ developers)
**Previous:** GitHub Copilot Enterprise
**Challenge:** Limited model choice and team management
**Result:** Improved code quality and team collaboration
**Timeline:** 6-week phased migration across multiple teams
### Startup Engineering Team (8 developers)
**Previous:** Multiple individual AI tool subscriptions
**Challenge:** Expense report chaos and no team coordination
**Result:** Centralized billing and improved team efficiency
**Timeline:** 1-week migration with immediate benefits
## Next Steps
- [Get started with your team](/docs/plans/getting-started)
- [Explore team management features](/docs/plans/team-management)
- [Understand billing and pricing](/docs/plans/billing)
- [Migrate your rules and configurations](/docs/getting-started/migrating) (technical guide)
Ready to make the switch? Contact our migration team at migrations@kilo.ai to plan your transition to transparent AI coding.
packages/kilo-docs/pages/collaborate/index.md
+61
View File
@@ -0,0 +1,61 @@
---
title: "Collaborate"
description: "Work together with Kilo Code team features"
---
# {% $markdoc.frontmatter.title %}
{% callout type="generic" %}
Kilo Code makes it easy to work together with your team. Share sessions, manage team settings, and track AI adoption across your organization.
{% /callout %}
## Sessions & Sharing
Sessions are your platform-agnostic interaction with Kilo. They remember your repository, task, and conversation so you can pause and resume work without losing context.
- [**Sessions & Sharing**](/docs/collaborate/sessions-sharing) — Share and collaborate on Kilo Code sessions
- Create sessions from the CLI, Cloud Agent, or IDE extensions
- Share read-only links with teammates
- Fork shared sessions to create your own copy
## Teams
Kilo Code's paid plans provide powerful team management features:
- [**About Plans**](/docs/collaborate/teams/about-plans) — Compare Teams and Enterprise plans
- **Teams ($15/user/month)** — Zero markup on AI costs, centralized billing, team analytics
- **Enterprise ([Contact Sales](https://kilo.ai/contact-sales))** — Model controls, audit logs, SSO, dedicated support
### Team Management
- [**Getting Started**](/docs/collaborate/teams/getting-started) — Set up your team
- [**Team Management**](/docs/collaborate/teams/team-management) — Manage members and roles
- [**Dashboard**](/docs/collaborate/teams/dashboard) — Team overview and activity
- [**Analytics**](/docs/collaborate/teams/analytics) — Usage insights and trends
- [**Billing**](/docs/collaborate/teams/billing) — Manage payments and invoices
- [**Custom Modes for Organizations**](/docs/collaborate/teams/custom-modes-org) — Share custom modes across your team
## Enterprise
Enterprise features for large organizations:
- [**Audit Logs**](/docs/collaborate/enterprise/audit-logs) — Track and audit team activity
- [**SSO**](/docs/collaborate/enterprise/sso) — Single sign-on with OIDC and SCIM
- [**Model Access Controls**](/docs/collaborate/enterprise/model-access-controls) — Limit models and providers
- [**Migration**](/docs/collaborate/enterprise/migration) — Migrate from other AI coding tools
## Adoption Dashboard
Understand how your team is using AI:
- [**Overview**](/docs/collaborate/adoption-dashboard/overview) — AI Adoption Score introduction
- [**For Team Leads**](/docs/collaborate/adoption-dashboard/for-team-leads) — Using adoption metrics
- [**Improving Your Score**](/docs/collaborate/adoption-dashboard/improving-your-score) — Tips to boost adoption
- [**Understanding Your Score**](/docs/collaborate/adoption-dashboard/understanding-your-score) — How the score is calculated
## Get Started with Teams
1. [Install Kilo Code](/docs/getting-started/installing) in your preferred environment
2. [Connect an AI provider](/docs/ai-providers)
3. [Choose a plan](/docs/collaborate/teams/about-plans) that fits your needs
4. Invite your team members and start collaborating
packages/kilo-docs/pages/community/index.md
+35
View File
@@ -0,0 +1,35 @@
---
title: "Community Projects"
description: "Community-maintained resources and projects that work with Kilo Code"
---
# Community Projects
This page highlights community-driven resources that are relevant for Kilo Code users.
{% callout type="note" title="Community-Maintained" %}
These resources are maintained by the community unless explicitly noted otherwise. Verify compatibility and security before using them in production environments.
{% /callout %}
## Recommended Starting Points
- **[Kilo Marketplace](https://github.com/Kilo-Org/kilo-marketplace)**
Share and install community-created Modes, Skills, and MCP servers.
- **[Kilo Code Show and Tell Discussions](https://github.com/Kilo-Org/kilocode/discussions/categories/show-and-tell)**
Real examples from users building workflows with Kilo Code.
- **[MCP Official Resources](https://github.com/modelcontextprotocol)**
Reference implementations and docs for MCP servers used with Kilo.
## Compatibility Checklist
Before adopting a community project, check:
1. Active maintenance (recent commits/releases)
2. Clear setup instructions for Kilo Code or MCP
3. License terms appropriate for your use case
4. Security posture (dependency hygiene, least-privilege permissions)
## Share Your Project
Built something useful with Kilo Code?
Share it in [Show and Tell](https://github.com/Kilo-Org/kilocode/discussions/categories/show-and-tell) or contribute it to the [Kilo Marketplace](https://github.com/Kilo-Org/kilo-marketplace).
packages/kilo-docs/pages/contributing/architecture/agent-observability.md
+1
View File
@@ -34,6 +34,7 @@ All of these contribute to the overall reliability and user experience of the sy
- Automated remediation
- A/B testing infrastructure
- Offline benchmarking and model/agent comparison (covered by [Benchmarking](/docs/contributing/architecture/benchmarking))
## Proposed Approach
packages/kilo-docs/pages/contributing/architecture/benchmarking.md
+306
View File
@@ -0,0 +1,306 @@
---
title: "Benchmarking"
description: "Design for benchmarking Kilo Code against models and other agents"
---
# Benchmarking
## Summary
This document proposes a benchmarking system for Kilo Code with two primary goals:
1. **Compare models against one another** using the same agent -- measuring task completion, token cost, and total time
2. **Compare agents against one another** using the same model -- e.g., Kilo Code vs Claude Code, or Kilo Code v1.0 vs v1.1
The design leverages existing open source infrastructure rather than building a custom harness:
- **[Harbor](https://harborframework.com)** as the evaluation framework, with **[Terminal-Bench](https://tbench.ai)** and other datasets for task definitions
- **[ATIF](https://harborframework.com/docs/agents/trajectory-format)** (Agent Trajectory Interchange Format) for structured, per-step trace logging
- **[Opik](https://www.comet.com/docs/opik)** for trace ingestion, step-level LLM judge evaluation, and root cause analysis
The key engineering deliverable is a **Kilo Code Harbor adapter** that runs Kilo CLI autonomously in containerized environments and emits ATIF-compliant trajectories.
{% callout type="info" %}
This is separate from [production observability](/docs/contributing/architecture/agent-observability), which monitors real user sessions via PostHog. Benchmarking is an offline evaluation system for comparing quality, cost, and performance across models and agents.
{% /callout %}
## Problem Statement
As Kilo Code evolves, we need systematic answers to questions like:
- Did our latest release make the agent better or worse?
- Which model gives the best results for our users at a given price point?
- How does Kilo Code compare to Claude Code, Codex, or other agents on the same tasks?
- When a benchmark score drops, what specific step or decision caused the regression?
Today we have no structured way to answer these questions. Manual testing is not reproducible, and our existing PostHog telemetry does not capture the turn-by-turn detail needed for easy comparative analysis.
## Goals
1. Run Kilo Code against standardized benchmark datasets in a reproducible, containerized environment
2. Compare model performance (same agent, different models) on task completion, token cost, and wall-clock time
3. Compare agent performance (same model, different agents or Kilo versions) on the same metrics
4. Capture detailed per-step traces for root cause analysis when results differ
5. Make it easy to create custom task sets for targeted evaluation or marketing purposes
**Non-goals:**
- Production monitoring (covered by [Agent Observability](/docs/contributing/architecture/agent-observability))
- Automated remediation based on benchmark results
## Architecture
```
┌─────────────────────────────────────────────────────────┐
│ Harbor Framework │
│ │
│ ┌──────────────┐ ┌─────────────┐ ┌─────────────────┐ │
│ │Terminal-Bench│ │ SWE-bench │ │ Custom Tasks │ │
│ │ 2.0 │ │ │ │ (Kilo-specific) │ │
│ └──────┬───────┘ └──────┬──────┘ └───────┬─────────┘ │
│ └────────────────┼─────────────────┘ │
│ ▼ │
│ ┌───────────────────────┐ │
│ │ Containerized Trial │ │
│ │ │ │
│ │ ┌─────────────────┐ │ │
│ │ │ Agent Under │ │ │
│ │ │ Test │ │ │
│ │ │ (kilo --auto) │ │ │
│ │ └────────┬────────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌─────────────────┐ │ │
│ │ │ Model API │ │ │
│ │ │ (Opus, GPT-5, │ │ │
│ │ │ Gemini, etc.) │ │ │
│ │ └─────────────────┘ │ │
│ └───────────┬───────────┘ │
│ │ │
│ ▼ │
│ ┌───────────────────────┐ │
│ │ ATIF Trajectory │ │
│ │ (per-step traces) │ │
│ └───────────┬───────────┘ │
└──────────────────────────┼──────────────────────────────┘
│
┌────────────┴────────────┐
▼ ▼
┌──────────────────────┐ ┌──────────────────────────┐
│ tbench.ai Dashboard │ │ Opik │
│ - Leaderboard │ │ - Step-level traces │
│ - Task pass/fail │ │ - LLM judge per step │
│ - Asciinema replay │ │ - Cost attribution │
│ - Aggregate scores │ │ - Root cause comparison │
└──────────────────────┘ └──────────────────────────┘
```
## Components
### Harbor Framework
[Harbor](https://harborframework.com) is the evaluation framework built by the Terminal-Bench team. It provides:
- **Containerized environments** for reproducible task execution
- **Pre-integrated agents**: Claude Code, Codex, Gemini CLI, OpenHands, Terminus-2
- **A registry of benchmark datasets**: Terminal-Bench, SWE-bench, LiveCodeBench, and more
- **Cloud scaling** via Daytona, Modal, and E2B for running trials in parallel
- **Automatic ATIF trajectory generation** for all integrated agents
Harbor is the standard evaluation framework used by many frontier labs. Rather than building our own harness, we write a Kilo Code adapter and plug into the existing ecosystem.
### ATIF (Agent Trajectory Interchange Format)
[ATIF](https://harborframework.com/docs/agents/trajectory-format) is a standardized JSON format for logging the complete interaction history of an agent run. Each trajectory captures:
- **Every step**: User messages, agent responses, tool calls, observations
- **Per-step metrics**: Token counts (prompt, completion, cached), cost in USD, latency
- **Tool call detail**: Function name, arguments, and observation results
- **Reasoning content**: The agent's internal reasoning at each step (when available)
- **Aggregate metrics**: Total tokens, total cost, total steps
This granularity is what enables step-level comparison between runs -- not just "did it pass or fail" but "at step 7, Agent A chose tool X while Agent B chose tool Y."
### Opik
[Opik](https://www.comet.com/docs/opik) (by Comet) provides trace ingestion and analysis with a first-class Harbor integration. Running benchmarks through Opik is as simple as:
```bash
opik harbor run -d terminal-bench@head -a kilo -m anthropic/claude-opus-4
```
Opik adds value beyond what the tbench.ai dashboard provides:
| Capability | tbench.ai Dashboard | Opik |
| ----------------------------- | ------------------- | ---- |
| Task-level pass/fail | Yes | Yes |
| Aggregate leaderboard | Yes | No |
| Asciinema replay | Yes | No |
| Step-level trace view | No | Yes |
| Step-level LLM judge | No | Yes |
| Cost attribution per step | No | Yes |
| Side-by-side trace comparison | No | Yes |
| Root cause analysis | No | Yes |
The two dashboards are complementary: tbench.ai for high-level leaderboard comparisons, Opik for drilling into why a specific run succeeded or failed.
### Datasets
Harbor's registry provides access to established benchmark datasets. The choice of dataset can vary depending on what you are evaluating:
| Dataset | Focus | Use Case |
| ------------------ | -------------------------------- | -------------------------------------------------- |
| Terminal-Bench 2.0 | CLI/terminal tasks (89 tasks) | General agent capability on hard, realistic tasks |
| SWE-bench | Real GitHub issues in real repos | Software engineering task completion |
| LiveCodeBench | Competitive programming problems | Code generation quality |
| Custom task sets | Whatever you define | Targeted evaluation, marketing, regression testing |
#### Creating Custom Task Sets
Creating a custom Harbor task set is straightforward. Each task consists of:
1. **A Dockerfile** defining the environment (OS, installed packages, repo state)
2. **A task description** (the prompt given to the agent)
3. **A verification script** (tests that determine pass/fail)
4. **Optionally, a reference solution**
This makes it easy to create task sets that target specific Kilo Code capabilities -- for example, a set of refactoring tasks, or a set of multi-file debugging scenarios. Custom sets can be published to the Harbor registry or kept private.
See the [Harbor task tutorial](https://www.tbench.ai/docs/task-tutorial) for a step-by-step guide.
## Deliverables
### 1. Kilo Code Harbor Adapter
The primary engineering deliverable. This adapter:
- **Installs Kilo CLI** in a Docker container
- **Configures autonomous execution** using `kilo run --auto`, which disables all permission prompts so the agent runs fully unattended
- **Translates Harbor task prompts** into Kilo CLI invocations
- **Emits ATIF-compliant trajectories** capturing every step, tool call, and metric
The adapter follows the same pattern as existing Harbor agents (see the [OpenHands adapter](https://harborframework.com/docs/agents/trajectory-format#openhands-example) for reference). The key implementation detail is the `populate_context_post_run` method that converts Kilo's execution log into ATIF format.
**Autonomous execution is critical.** Harbor runs containerized trials in parallel and expects agents to execute from start to finish without human intervention. The adapter must ensure:
- No interactive prompts for API keys (injected via environment variables)
- No permission dialogs for file writes, command execution, etc.
- Graceful timeout handling if the agent gets stuck
### 2. Custom Task Set Template
Documentation and examples for creating Kilo-specific task sets:
- Template Dockerfile and verification script
- Guidelines for writing good task descriptions
- Examples of tasks that highlight coding agent capabilities
- Instructions for publishing to Harbor's registry or running privately
This enables the team to create targeted benchmarks for marketing, regression testing, or capability evaluation.
### 3. Opik Integration
Configure the Opik-Harbor integration for Kilo Code benchmark runs:
- Set up `opik harbor run` with the Kilo Code adapter
- Define standard LLM judge criteria for step-level evaluation:
- **Tool choice correctness**: Did the agent use the right tool at each step?
- **Reasoning quality**: Was the agent's reasoning at each step sound?
- **Efficiency**: Were there unnecessary or redundant steps?
- Create saved views for common comparison scenarios (model-vs-model, version-vs-version)
### 4. CI Regression Detection
{% callout type="note" %}
Lower priority. Implement after the core benchmarking system is working.
{% /callout %}
Run a small subset of benchmark tasks (10-15) on release branches to catch regressions before shipping. Harbor supports this pattern natively. The subset should be chosen for:
- Fast execution (under 5 minutes per task)
- High signal (tasks that historically differentiate good and bad agent behavior)
- Stability (deterministic verification, not flaky)
## Example Workflows
### Comparing Models
Run the same Kilo Code agent against Terminal-Bench with different models:
```bash
# Run with Claude Opus
opik harbor run -d terminal-bench@2.0 -a kilo -m anthropic/claude-opus-4
# Run with GPT-5
opik harbor run -d terminal-bench@2.0 -a kilo -m openai/gpt-5
# Run with Gemini 3 Pro
opik harbor run -d terminal-bench@2.0 -a kilo -m google/gemini-3-pro
```
Compare results in tbench.ai for aggregate scores and in Opik for step-level analysis of where models diverge.
### Comparing Agents
Run different agents against the same dataset with the same model:
```bash
# Run Kilo Code
opik harbor run -d terminal-bench@2.0 -a kilo -m anthropic/claude-opus-4
# Run Claude Code
opik harbor run -d terminal-bench@2.0 -a claude-code -m anthropic/claude-opus-4
```
### Comparing Kilo Versions
Test a new release against the previous version:
```bash
# Run current release
opik harbor run -d terminal-bench@2.0 -a kilo@v2.0 -m anthropic/claude-opus-4
# Run candidate release
opik harbor run -d terminal-bench@2.0 -a kilo@v2.1-rc1 -m anthropic/claude-opus-4
```
Use Opik's trace comparison view to identify specific steps where the new version regressed or improved.
### Running a Custom Task Set
```bash
# Run against a custom Kilo-specific dataset
opik harbor run -d kilo-refactoring@1.0 -a kilo -m anthropic/claude-opus-4
```
## LLM Judge: Two Levels
Harbor provides task-level judging (did the agent solve the task?). Opik adds step-level evaluation:
| Level | Tool | What It Tells You |
| -------------- | ------ | -------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Task-level** | Harbor | Pass/fail, score, total time, total cost |
| **Step-level** | Opik | At step N, the agent chose tool X when it should have used tool Y. The reasoning was flawed because of Z. This step cost $0.03 and took 4 seconds. |
Step-level evaluation is where root cause debugging happens. When a benchmark score drops between versions, you can trace back to the exact decision point that caused the regression.
## Relationship to Production Observability
This benchmarking system is complementary to, but separate from, the [Agent Observability](/docs/contributing/architecture/agent-observability) system:
| Concern | Benchmarking | Production Observability |
| --------------- | ------------------------------------- | ------------------------------------- |
| **Purpose** | Offline evaluation of agent quality | Real-time monitoring of user sessions |
| **Data source** | Controlled benchmark tasks | Real user interactions |
| **Tools** | Harbor, Opik, tbench.ai | PostHog, custom metrics |
| **When** | Before release, on-demand | Continuously in production |
| **Output** | Leaderboard scores, trace comparisons | Alerts, dashboards, SLO tracking |
## References
- [Harbor Framework Documentation](https://harborframework.com/docs)
- [Terminal-Bench 2.0 Paper](https://huggingface.co/papers/2601.11868)
- [ATIF Specification (RFC)](https://github.com/laude-institute/harbor/blob/main/docs/rfcs/0001-trajectory-format.md)
- [Opik Harbor Integration](https://www.comet.com/docs/opik/integrations/harbor)
- [tbench.ai Dashboard](https://www.tbench.ai/docs/dashboard)
- [Harbor Task Tutorial](https://www.tbench.ai/docs/task-tutorial)
packages/kilo-docs/pages/contributing/architecture/features.md
+1
View File
@@ -10,6 +10,7 @@ These pages document the architecture and design of current or planned features,
| Feature | Description |
| ---------------------------------------------------------------------------------------- | ------------------------------------------------ |
| [Agent Observability](/docs/contributing/architecture/agent-observability) | Observability and monitoring for agentic systems |
| [Benchmarking](/docs/contributing/architecture/benchmarking) | Benchmarking Kilo Code across models and agents |
| [Annual Billing](/docs/contributing/architecture/annual-billing) | Annual subscription billing |
| [Enterprise MCP Controls](/docs/contributing/architecture/enterprise-mcp-controls) | Admin controls for MCP server allowlists |
| [MCP OAuth Authorization](/docs/contributing/architecture/mcp-oauth-authorization) | OAuth 2.1-based authorization for MCP servers |
packages/kilo-docs/pages/customize/agents-md.md
+2
View File
@@ -12,6 +12,8 @@ The Kilo Code **memory bank** feature has been deprecated in favor of AGENTS.md.
**Existing memory bank rules will continue to work.**
Legacy Memory Bank status indicators such as `[Memory Bank: Active]` and `[Memory Bank: Missing]` can still appear, but they are not guaranteed across all clients or modes.
If you'd like to migrate your memory bank content to AGENTS.md:
1. Examine the contents in `.kilocode/rules/memory-bank/`
packages/kilo-docs/pages/getting-started/troubleshooting/index.md
+12
View File
@@ -0,0 +1,12 @@
---
title: "Troubleshooting"
description: "Guides for diagnosing and resolving issues with Kilo Code"
---
# Troubleshooting
This section contains guides for diagnosing and resolving common issues with Kilo Code.
## Guides
- [**Extension Troubleshooting**](/docs/getting-started/troubleshooting/troubleshooting-extension) - How to capture console logs and report issues with the Kilo Code extension
packages/kilo-docs/pages/getting-started/troubleshooting/troubleshooting-extension.md
+57
View File
@@ -0,0 +1,57 @@
---
title: "Troubleshooting IDE Extensions"
description: "How to capture console logs and report issues with Kilo Code"
---
# Capturing Console Logs
Providing console logs helps us pinpoint exactly what's going wrong with your installation, network, or MCP setup. This guide walks you through capturing those logs in your IDE.
## Opening Developer Tools
{% tabs %}
{% tab label="VS Code" %}
1. **Open the Command Palette**: Press `Ctrl+Shift+P` (Windows/Linux) or `Cmd+Shift+P` (Mac)
2. **Search for Developer Tools**: Type `Developer: Open Webview Developer Tools` and select it
{% /tab %}
{% tab label="JetBrains" %}
### Enable JCEF Debugging
1. Open your JetBrains IDE and go to **Help → Find Action** (or press `Cmd+Shift+A` / `Ctrl+Shift+A`)
2. Type `Registry` and open it
3. Search for `jcef` and configure these settings:
- `ide.browser.jcef.debug.port` → set to `9222`
- `ide.browser.jcef.contextMenu.devTools.enabled` → check the box
4. Restart your IDE after making these changes
### Connect Chrome DevTools
1. Make sure the **Kilo Code panel is open** in your IDE (the debug target won't appear unless the webview is active)
2. Open Chrome (or any Chromium-based browser like Edge or Arc)
3. Navigate to `http://localhost:9222/json` to see the list of inspectable targets
4. Find the entry with `"title": "Kilo Code"` and open the `devtoolsFrontendUrl` link
5. Chrome DevTools will open connected to the Kilo webview—click the **Console** tab
{% /tab %}
{% /tabs %}
## Capturing the Error
Once you have the Developer Tools console open:
1. **Clear previous logs**: Click the "Clear Console" button (🚫 icon at the top of the Console panel) to remove old messages
2. **Reproduce the issue**: Perform the action that was causing problems
3. **Check for errors**: Look at the Console tab for error messages (usually shown in red). If you suspect connection issues, also check the **Network** tab
4. **Copy the logs**: Right-click in the console and select "Save as..." or copy the relevant error messages
## Contact Support
If you're unable to resolve the issue, please inspect the console logs, remove any secrets, and send the logs to **[hi@kilocode.ai](mailto:hi@kilocode.ai)** along with the following:
- The error messages from the console
- Steps to reproduce the issue
- Screenshots or screen recordings of the issue
- Your IDE and Kilo Code version
packages/kilo-docs/pages/getting-started/using-docs-with-agents.md
+34
View File
@@ -0,0 +1,34 @@
---
title: "Using Kilo Docs with Agents"
description: "Access the full Kilo Code documentation in machine-readable formats for LLMs and AI agents"
---
# Using Kilo Docs with Agents
You can access the full text of the Kilo Code documentation in machine-readable formats suitable for LLMs and AI agents. This is useful when you want an AI assistant to reference Kilo Code's documentation while helping you with a task.
## Full documentation
The complete documentation is available as a single text file at:
```
https://kilo.ai/docs/llms.txt
```
This file contains the full content of every page in the Kilo Code docs, formatted for easy consumption by language models.
## Individual pages
You can also fetch any individual documentation page as raw Markdown via the API:
```
https://kilo.ai/docs/api/raw-markdown?path=<url-encoded-path>
```
For example, to fetch the "Code with AI" overview page:
```
https://kilo.ai/docs/api/raw-markdown?path=%2Fcode-with-ai
```
The `path` parameter should be the URL-encoded path of the documentation page, without the `/docs` prefix.
packages/kilo-docs/public/img/kiloclaw/access-code-modal.png
BIN
View File
Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 28 KiB

packages/kilo-docs/public/img/kiloclaw/access-code-modal2.png
BIN
View File
Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 52 KiB

packages/kilo-docs/public/img/kiloclaw/create-instance.png
BIN
View File
Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 95 KiB

packages/kilo-docs/public/img/kiloclaw/instance-dashboard.png
BIN
View File
Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 153 KiB

packages/kilo-docs/public/img/kiloclaw/openclaw-dashboard.png
BIN
View File
Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 263 KiB

packages/kilo-docs/public/img/kiloclaw/profile-claw-nav.png
BIN
View File
Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 231 KiB