# Overview **On this page** * [What is CodeMate?](#what-is-codemate) * [What sets CodeMate apart?](#what-sets-codemate-apart) * [What data is collected and how it's used?](#what-data-is-collected-and-how-its-used) * [Join our community](#join-our-community) ## What is CodeMate CodeMate is an AI-native SDLC agent that understands your entire codebase and automates research, prototyping, development, testing and reviewing across the software lifecycle. Unlike traditional coding assistants that operate on isolated files or prompts, CodeMate builds a persistent understanding of your codebase and product documentation. This enables it to identify logical, syntax, and runtime issues, suggest fixes, and generate improvements with full system context similar to autocorrect, but for entire codebases. CodeMate reduces hours of manual debugging, code review, and test creation into minutes through intelligent, context-aware suggestions. It supports tasks such as error fixing, code review, optimization, test case generation, and backend scaffolding via its Swagger agent. It integrates seamlessly with IDEs such as VS Code and JetBrains, also platforms like GitHub, GitLab, Bit Bucket fitting directly into existing developer workflows. CodeMate has onboarded **500,000+ users** across **52+ countries** on six continents, with strategic partnerships across hardware, cloud, and enterprise sectors. ### What sets CodeMate apart? **Unmatched Code Understanding:** * **AI-driven technology:** CodeMate goes deep into your entire codebase, understanding not only the lines of code but also the context and intent behind them. This allows it to understand the intricate relationships between different aspects of your code and identify even the most subtle & logical errors. * **Vast knowledge base:** Beyond your codebase, CodeMate taps into a vast reservoir of open-source code and your organization's internal knowledge base. This gives it access to a wealth of information that further enhances its ability to solve complex problems and suggest optimal solutions. * **Extensive training data:** CodeMate is constantly learning and evolving thanks to its access to massive amounts of code & related data. This allows it to identify patterns and trends, anticipate potential issues, and continuously improve its accuracy and effectiveness. **A glimpse of the Feature Set:** * **Agentic Coding:** Unlike other Agentic coding tools, CORA is designed specifically to write enterprise level production code with AI guardrails. This can be achieved by our suite of in-house LLMs that are trained specifically for code generation, code reviewing, debugging and context awareness. * **Code Review:** After code generation, comes the most important part of code review before it is pushed to the production, CORA and C0 help you detect security vulnerabilities, issues in code quality and code understanding. After finding the vulnerabilities, CodeMate fixes it and tests it again to make sure every part of the code is ready to be pushed to prod. * **Integrations:** Enterprises and teams all over the globe use Jira for managing agile software development, tracking issues, and streamlining workflows across various departments. CodeMate's suite of products integrate with Jira and enables teams move faster and efficiently over their entire software development life cycle. Along, with that CORA and C0 are integrated with IDEs such as VS code and JetBrains, this allows dev teams to move with out changing their existing workflow. * **Utilities:** Currently in the version-3.5, CORA has support of [MCP servers](/cora/configuration/mcp-servers), [Skills](/cora/configuration/skills), [Rules](/cora/configuration/rules) and other utilities that boosts developer productivity without leaving their work space. In the recent release, C0 has now capabilities of [CodeMaps](/c0/code-maps) and [DeepWiki](/c0/deep-wiki). ### What Data is Collected and How It's Used? CodeMate collects and uses data responsibly and transparently. We are committed to protecting your privacy and security, and we take all necessary precautions to ensure that your data is handled securely. Here's a breakdown of the data we collect and how it's utilized: 1\. **Prompts and responses**: When you use CodeMate, it collects your prompts and responses and it gets stored for 30 seconds in our systems in encrypted format. CodeMate never access or use any of your data to train models. 2\. Usage data and feedback: We also collect general usage data such as the features you use and the time you spend using CodeMate. This data is used to: * Track overall usage: We monitor how CodeMate is being used to identify trends and improve the platform. * Troubleshoot issues: We use usage data to diagnose and fix any technical problems that may arise. * Develop new features: We use user feedback and usage patterns to identify new features that would be valuable to our users. If you wish to opt out to any of the collected data, You may opt out of it by mailing us at . [Read more about CodeMate Usage and Privacy policy here →](https://docs.codemate.ai/policies/privacy-policy) ### Join Our Community CodeMate is more than just a tool; it's a community of developers who are passionate about coding and committed to helping each other succeed. By joining our community, you can: * Connect with other CodeMate users: Share your experiences, ask questions, and get help from fellow developers. * Get access to exclusive content: Learn about new features, tips, and tricks for using CodeMate effectively. * Contribute to the development of CodeMate: Share your feedback and suggestions to help shape the future of the product. * Get support: Raise a support ticket & our team will get in touch to fix the issue. * Participate in fun activities and events: Join coding challenges, hackathons, and other community events. Stay connected with our community: * Follow us on social media: * [Twitter](https://twitter.com/codemateai) * [Instagram](https://instagram.com/codemateai) * [LinkedIn](https://www.linkedin.com/company/codemateai/) * [YouTube](https://www.youtube.com/@codemateai) We look forward to seeing you there! # Essentials ### What is CodeMate? CodeMate is an on-device AI agent for the Software Development Lifecycle (SDLC). It runs entirely within your developer environment and is equipped with built-in Responsible AI safeguards meaning your code and organizational knowledge never leave your machine. *** ### Who Should Use CodeMate? CodeMate is built for: * **Individual developers** who want AI assistance that understands their codebase deeply, not just the file they have open. * **Engineering teams** that need consistent code quality, shared standards enforcement, and faster onboarding for new members. * **Enterprises** that require on-premise or VPC deployment, governance guardrails, and security compliance built into their AI tooling. * **Students, educators, and institutions** looking to close the gap between academic learning and industry-ready development practices. *** ### Why CodeMate? Two problems slow down most software teams today: * **66%** of developers cite "almost correct" AI suggestions as their biggest time sink. * **72%** of developers take 1–2 months to make meaningful contributions to a large, unfamiliar codebase. The root cause isn't the AI model it's the lack of context. Most tools don't understand your project's structure, your team's patterns, or your personal coding style. CodeMate solves this with a suite of products that build and maintain that context continuously, all orchestrated through a single desktop application. *** ### Products CodeMate is a suite of products covering the entire development lifecycle, tied together by **Toolbox** the central orchestration layer that runs on your machine. | Product | Description | Link | | ----------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------- | | **Toolbox** | The central hub that launches, coordinates, and manages all CodeMate products from a single desktop app | [Learn more](https://app.codemate.ai/download) | | **CORA** | Autonomous coding agent that converts natural language prompts into structured, dependency-aware execution plans | [Learn more](https://app.codemate.ai/download) | | **C0** | Deep codebase intelligence for reviews, debugging, and test case generation | [Learn more](https://marketplace.visualstudio.com/items?itemName=AyushSinghal.Code-Mate) | | **Build** | Convert Figma designs, prompts, and BRD files into working MVPs | [Learn more](https://build.codemateai.dev/build) | |

PR Review Agent
(Enterprise Only)

| Automated pull request checks and code reviews before production | [Learn more](/pull-request-review-agent) | | **CodeMate for Education** | AI-powered development tools for students, educators, and institutions with offline support and free academic plans | [Learn More](https://edu.codemate.ai/) | > **Start with Toolbox.** It runs the local subsystem process that powers C0 and CORA in your IDE, manages authentication across all products. > > Download it at [app.codemate.ai/download](https://app.codemate.ai/download). *** ### Key Differentiators **Local-First:** CodeMate runs entirely on the developer's machine via the Toolbox subsystem. No data is sent to external servers, giving you full on-device privacy. **Persistent Organisational Memory:** Unlike tools that reset context each session, CodeMate retains memory across sessions understanding team style, dependency trees, and project history. **Responsible AI Built-In:** Every workflow includes governance guardrails and security checks, not as an afterthought, but as a core part of the system. **Enterprise-Grade Deployment:** Supports on-premise, VPC, and edge deployments making it suitable for regulated industries and security-sensitive environments. *** ### [Performance Benchmarks](https://blog.codemate.ai/cora-achieves-sota-with-76-resolution-rate-on-swe-bench-verified-subset-outperforming-industry-leaders-2/) On the SWE-bench verified dataset (a global standard for evaluating software engineering AI), CodeMate's CORA agent leads the field: | Tool | SWE-bench Score | | ------------------- | --------------- | | **CORA (CodeMate)** | **76%** | | GitHub Copilot | 71% | | Cursor (Auto) | 51% | *** ### Business Model CodeMate is available through three licensing models to suit teams of all sizes: * **Subscription License:** Recurring per-seat access * **Pay-As-You-Go:** Usage-based billing * **Perpetual Licenses:** One-time purchase for enterprise deployments *** ### Use Cases **Enterprise Code Development :** CodeMate enables organizations to maintain enterprise-grade code quality under strict privacy constraints. As a fully self-hosted, SOC 2 and ISO certified solution, it allows teams to leverage powerful AI code reviews without sending sensitive code outside their infrastructure. **Code Reviews:** CodeMate replaces manual review bottlenecks with continuous, consistent quality checks during development. **Reducing Delivery Cycles:** By catching errors earlier and automating repetitive tasks, teams ship faster. In production use, delivery cycles have been reduced by up to 83%. **Developer Onboarding:** New engineers get up to speed faster with context-aware answers about the codebase, reducing the typical 1–2 month ramp-up period significantly. **Academic & Classroom Use:** Educators integrate AI-assisted tools into coursework and live coding sessions, while students build industry-ready habits from day one even in low-connectivity environments. # What We Do ### Automating the Entire Software Development Lifecycle CodeMate is an AI-powered SDLC agent that covers every stage of software development from the first business requirement all the way to production deployment. It works both assistively (alongside developers) and autonomously (executing tasks end-to-end), always within a governance and security guardrail layer. Everything runs through a single desktop application called **Toolbox**, which orchestrates all products locally on your machine no cloud dependency, no context switching. *** ### The CodeMate Product Suite #### [Toolbox](/toolbox) (The Central Orchestration Layer) **What it does:** A desktop application that launches, coordinates, and manages the entire CodeMate product suite from one place. Toolbox is the foundation everything else is built on. It runs a local subsystem process that bridges your IDE extension with CORA and C0, handles authentication across all products, and provides a fully customizable widget dashboard so you can monitor what matters to you. Without Toolbox running, the AI features in your IDE are inactive. With it running, every CodeMate product is available, connected, and ready no terminal commands required. **Available on:** Windows, macOS, Linux download at [app.codemate.ai/download](https://app.codemate.ai/download) **Includes:** * Subsystem management (start, stop, auto-start on launch) * Unified login shared across all products * IDE extension coordination for VS Code and compatible editors *** #### [CORA](/cora) (Agentic Architect) **What it does:** An autonomous coding agent that converts natural language prompts into structured, dependency-aware execution plans and implements them end-to-end. CORA is CodeMate's most powerful product. Built on the Toolbox subsystem and governed by project-specific Skills, Rules, and Workflows, CORA handles the full development loop from understanding requirements and designing architecture through writing, testing, reviewing, and documenting code. It connects to external tools via MCP servers, making it genuinely capable of acting like a developer rather than just assisting one. **Agents included:** Code Writing, Documentation, Code Review, Security Testing, QA **Integrated with:** VS Code, JetBrains IDEs, terminal environments, MCP servers *** #### [C0](/c0) (AI Coding Assistant) **What it does:** Deep codebase intelligence for code reviews, debugging, and test case generation, delivered directly inside your IDE. C0 is orchestrated via the Toolbox subsystem, which enables full codebase indexing, contextual retrieval, and persistent knowledge across your entire repository. Rather than working file-by-file like most AI assistants, C0 understands the structure, history, and relationships across your whole project and surfaces that understanding through a conversational interface in your editor. **Capabilities include:** code generation, debugging, code review, and documentation synthesis. **Integrated with:** VS Code, JetBrains IDEs (WebStorm, PyCharm, IntelliJ, and more) *** #### [Build](/build) (Web App Builder) **What it does:** Converts Figma designs, prompts, and BRD files into working MVPs, accessible directly from Toolbox. CodeMate Build bridges the gap between product and engineering. Hand it a Figma file, a product requirements document, or a plain-language prompt, and it generates a functional web application ready for further development all AI-assisted and fully integrated with your CodeMate account. **Integrated with:** Figma, file uploads *** #### [PR Review Agent](/pull-request-review-agent) (Automated Pre-Production Checks) **What it does:** Automated pull request checks and code reviews before code reaches production. The PR Review Agent acts as a consistent reviewer on every pull request. It checks for code quality issues, security vulnerabilities, test coverage gaps, and adherence to team standards giving developers fast, reliable feedback without waiting for a human reviewer. CodeMate is currently available exclusively as an **Enterprise solution**. **Integrated with:** GitHub, Bitbucket, GitLab, Azure DevOps *** #### [CodeMate for Education](/codemate-for-education) (AI Tools for Academic Environments) **What it does:** Extends the full CodeMate product suite to students, educators, coding clubs, and institutions with offline support and preferential academic pricing. The gap between academic learning and industry readiness is one of the biggest challenges in computer science education. Students graduate with theoretical knowledge but often lack exposure to modern tooling, workflows, and collaborative development practices. CodeMate for Education bridges this gap by bringing real-world AI development tools into the classroom from day one. **Available through:** [CodeMate Web App](https://edu.codemate.ai/) *** ### End-to-End SDLC Coverage Each product maps to a specific phase of the software lifecycle, with Toolbox underpinning all of them: | Phase | CodeMate Product | What It Does | | ----------------------- | -------------------------- | -------------------------------------------------- | | Foundation | **Toolbox** | Local subsystem, auth, IDE coordination, dashboard | | Development | **CORA** | AI-powered autonomous software development | | Verification & Quality | **CORA** | Security testing, QA, and quality alignment | | Discovery & Research | **C0** | Codebase intelligence and feasibility analysis | | Planning & Architecture | **Build** | Design-to-prototype, roadmap and infra planning | | Deployment & Release | **PR Review Agent** | Automated review, deployment, and feedback loops | | Education & Onboarding | **CodeMate for Education** | Academic access, offline learning, educator tools | *** ### Real-World Impact When deployed in enterprise environments, CodeMate has delivered measurable results: * **\~83% reduction** in delivery cycle time * **\~30% reduction** in development costs * **42%** of bad code caught before reaching production * **88%** of developers reported feeling more productive *** ### Global Reach CodeMate has onboarded **500,000+ users** across **52+ countries** on six continents, with strategic partnerships across hardware, cloud, and enterprise sectors. # Toolbox The unified desktop application that orchestrates the entire CodeMate ecosystem from AI coding assistants to your personal developer dashboard. **Platform:** Windows · macOS · Linux\ **Download:** [app.codemate.ai/download](https://app.codemate.ai/download) *** ### Overview CodeMate Toolbox is the central orchestration layer for the CodeMate product suite. Rather than managing disparate developer tools across different interfaces, Toolbox brings every CodeMate product under a single desktop application letting you launch services, monitor your environment, manage credentials. Toolbox is not just a launcher. It runs a local subsystem process that coordinates communication between the products (CORA and C0) and your IDE extension, handles authentication state across all products, and provides a fully customizable widget dashboard for monitoring what matters to you. *** ### Installation Toolbox is available as a native desktop application for all major operating systems. Download the build that matches your architecture from [app.codemate.ai/download](https://app.codemate.ai/download). > **macOS note:** On first launch, macOS may show a security prompt. Go to **System Settings → Privacy & Security** and click "Open Anyway" to proceed. Before Downloading your installer, Please Follow the installation Guide Video present over the [app.codemate.ai/download](https://app.codemate.ai/download) page. *** ### Integrated Products #### C0 (AI Coding Assistant) CodeMate’s AI coding assistant, C0, is an IDE-native system designed to integrate directly into the developer workflow. It is orchestrated via the Toolbox subsystem, which enables full codebase indexing, contextual retrieval, and persistent knowledge. By leveraging this structured understanding of the repository, C0 supports a range of development tasks including code generation, debugging, static analysis, code review, and documentation synthesis. All interactions are exposed through a conversational interface within the IDE, eliminating the need for context switching. #### CORA (Agentic Architect) Cora is an IDE-native orchestration layer built on the CodeMate Toolbox subsystem that converts natural language prompts into structured, dependency-aware execution plans and implement them for you. Integrated with external tools via MCP servers and governed by project-specific and global Skills, Rules, and Workflows, Cora enables end-to-end application design, generation, and analysis through a conversational interface, without requiring context switching. #### Build (Web App Builder) A visual web application builder accessible directly from Toolbox. Build lets you prototype and ship web apps without leaving the CodeMate ecosystem, AI-assisted and fully integrated with your CodeMate account. #### Developer Dashboard Your personalized developer command center. Dashboard surfaces the metrics, tools, and data streams you care about through a widget system. Accessible from Toolbox with your CodeMate account. *** ### Subsystem Management The subsystem is the process that bridges Toolbox with your IDE extension, coordinating CORA and C0. It must be running for AI assistance in your editor to function. You manage it entirely from within Toolbox no terminal commands required. #### Starting the subsystem Open Toolbox and Click **Start** to initialize the local process. Toolbox will show a **online** status indicator once the subsystem is ready to accept IDE connections. > Recommended: set the subsystem to start automatically on Toolbox launch from **Settings → Subsystem → Auto-start**. #### IDE extension connection Once the subsystem is running, your IDE extension (VS Code or compatible editor) automatically connects to it. CORA and C0 become available in the editor sidebar. No additional configuration is needed if you're already logged in to Toolbox. #### Stopping the subsystem Click **Stop** in the Subsystem panel. This gracefully terminates all connected AI processes. Your IDE extension will show a disconnected state until the subsystem is restarted. *** ### Dashboard & Widgets Toolbox includes a built-in customizable dashboard. You choose which widgets appear and what data they surface. The dashboard persists your layout across sessions and is tied to your CodeMate account, so it follows you across devices. #### Pre-built widgets | Widget | Description | | ---------------- | --------------------------------------------------- | | Clock | Displays current time; supports multiple time zones | | Hacker News | Live feed of top Hacker News stories | | GitHub Activity | Your GitHub contribution graph and recent events | | CPU Activity | Real-time CPU usage graph | | Memory Usage | System RAM utilization | | Project Hub | Quick access to your indexed development projects | | System Resources | Combined system health overview | | Time Tracker | Track time spent on tasks and projects | #### Customizing the dashboard Widgets can be added and removed from the personalize editor. Each widget exposes its own settings panel for configuration for example, the GitHub Activity widget connects to your GitHub account. *** ### Quickstart Guide Get from download to a working AI-assisted development environment in under five minutes. **Step 1 - Download and install Toolbox** Download the installer for your OS and architecture from [app.codemate.ai/download](https://app.codemate.ai/download). Run the installer and launch the application. **Step 2 - Sign in to your CodeMate account** Click the login button in the top-right corner of Toolbox. Your session will be shared across all integrated products automatically. **Step 3 - Start the subsystem** Go to the **Subsystem** panel and click **Start**. Wait for the status indicator to show a **online** status. This activates C0 and CORA. **Step 4 - Install the IDE extension** Install the CodeMate extension from the integrations panel in Toolbox, or from your editor's marketplace (VS Code or compatible editor). Once installed, the extension connects to the running subsystem automatically. *** # CORA Cora is CodeMate’s agentic architect mode that turns natural language prompts into complete, production-ready projects through intelligent planning and code generation. Most AI coding tools help you type faster. Cora does the work that happens before typing and help you type faster: understanding the real requirements behind a prompt, making architectural decisions, planning what depends on what, and then executing the build in the correct order. Cora runs inside your Code Editor as an extension. It has access to your full codebase, can use external tools via MCP servers, and follows project-specific rules, skills, and workflows you define. *** ### What Cora does Given a prompt like : `Build a SaaS analytics dashboard with multi-tenant support and real-time charts` Cora doesn't start writing files. It first maps the problem including requirements nobody mentioned but everyone will eventually need, like an invitation system, API key management for machine-to-machine auth, and tenant-scoped queries on every database call. Then it picks a stack with explicit reasoning. Then it produces a dependency-ordered task graph. Then it builds, layer by layer, validating each layer before the next. The output is a complete, architecturally sound codebase not a template with placeholders, not disconnected snippets, not a scaffold that still requires days of wiring. *** ### Modes Cora operates in five modes. Each one is suited to a different kind of task. You select the mode before sending a message, or let Auto choose for you. | Mode | What it does | | ---------- | ---------------------------------------------------------------------------------------------------------------------- | | **Auto** | Orchestrator mode. Cora chooses Plan, Ask, Code, or Review based on what the prompt requires, and can switch mid-task. | | **Plan** | Produces architecture documents, stack decisions, and task breakdowns without writing code. | | **Ask** | Answers questions about your codebase, explains decisions, and gives context without making changes. | | **Code** | Writes, modifies, and refactors code. The primary execution mode. | | **Review** | Audits changes for correctness, consistency, and architectural alignment. | *** ### Configuration Cora's behavior can be shaped with four types of configuration files you add to your project: | Type | Format | Purpose | | ----------- | -------- | ------------------------------------------------------------------------------------------------------------ | | Skills | Markdown | Domain knowledge Cora can call on API patterns, component conventions, testing approaches | | Rules | Markdown | Hard constraints that apply to every interaction naming conventions, forbidden patterns, required structures | | Workflows | Markdown | Step-by-step processes for recurring tasks feature scaffolding, PR prep, database migrations | | MCP servers | JSON | External tool integrations GitHub, Slack, databases, APIs, custom internal tools | # Quickstart Install Cora, open a project, and run your first prompt. ### Install the extension To use the CORA in your IDE(VS Code, JetBrains, Antigravity, Cursor), ToolBox will act as a centralized hub, to install them and update them whenever required. #### CodeMate Toolbox Already have Toolbox installed? Install CORA without touching the marketplace. 1. Open **CodeMate Toolbox**. 2. Navigate to **CORA → Install Extension**. 3. Toolbox detects your installed editors and installs the extension automatically. Don't have Toolbox yet? [Download it here](https://app.codemate.ai/download). *** ### Run your first prompt 1. Open a project folder in your IDE, or start with an empty folder for a new project. 2. Open the Cora panel and select a mode. For a new project, start with **Auto** Cora will plan before it builds. 3. Write a prompt describing what you want to build. Be specific about the domain, key features, and any technical requirements. ``` Build a multi-tenant SaaS analytics dashboard with user auth, role-based access, a data ingestion API, real-time charts, and an admin panel for managing organizations. ``` 4. Cora will output an architecture plan before writing any files. Review it this is where stack choices and implicit requirements are surfaced. You can push back or ask questions before execution begins. 5. Once you confirm, Cora builds the project layer by layer: foundation, then services, then data layer, then frontend, then integration. Files appear in your workspace as they're generated. *** ### Next steps After the initial build, continue the conversation to add features, ask questions about the codebase, or run a review pass on recent changes. # Modes Cora operates in five modes. Each one is optimized for a different kind of task understanding, planning, building, or reviewing. You select the mode before sending a message, or let Auto decide for Selecting the right mode matters. Ask mode never modifies files. Review mode never writes new code. Using the wrong mode for a task won't break anything, but it produces worse output than using the right one. *** ### The five modes | Mode | What it does | | -------------------------------- | ----------------------------------------------------------------------- | | [**Auto**](/cora/modes/auto) | Orchestrates the other modes picks and sequences them based on the task | | [**Plan**](/cora/modes/plan) | Produces architecture documents, stack decisions, and task breakdowns | | [**Ask**](/cora/modes/ask) | Answers questions about the codebase and explains how things work | | [**Code**](/cora/modes/code) | Writes, modifies, and refactors code | | [**Review**](/cora/modes/review) | Audits changes for correctness, security, and consistency | *** ### Choosing a mode **Auto** is the right default for most tasks. Use a specific mode when you know exactly what kind of output you want a read-only explanation, a plan with no code yet, or a targeted review of a specific file. Use **Plan** when you're starting something large and want to review the approach before any files are touched. Use **Ask** when you want to understand something without risking any changes. Use **Code** when you have a clear, scoped task and want direct execution. Use **Review** after any change to a security-sensitive area. # Auto Orchestrator mode. Cora selects and sequences the appropriate modes based on what the prompt requires. Auto is the default mode for open-ended or multi-step tasks. Rather than locking into a single mode, Cora evaluates the prompt and decides whether to plan first, write code, ask a clarifying question, or review what it just produced and can move between modes as the task unfolds.
*** ### When to use Auto Auto is the right choice when you're not sure which mode a task requires, or when a task is likely to span more than one mode. Building a new feature from scratch, for example, naturally involves planning the approach, writing the code, and reviewing the result Auto handles the sequencing without you having to switch manually. If you have a specific, well-scoped task : `explain this function` , `refactor this file`, `review this diff` , `Fix this bug` using a targeted mode directly is faster and more predictable. Auto adds value when the task is larger or less defined. *** ### How Auto mode works For a complex prompt, Auto typically follows this order: 1. If the task involves architectural decisions, it runs **Plan** first and surfaces the plan for your review. 2. Once you confirm, it switches to **Code** to execute. 3. After generating changes that touch security-sensitive areas, it runs a **Review** pass automatically. 4. At any point, it can pause in **Ask** mode if it needs clarification to proceed correctly. The current mode is always visible in the panel. You can see when Cora switches and why. > You can interrupt Auto at any mode transition. If the plan doesn't look right, push back before execution starts. If the code looks wrong mid-generation, stop and redirect don't let it finish and then ask it to redo. *** ### Auto vs. manual mode selection Auto does not always sequence all four modes. For a small, unambiguous task like adding a field to an existing model, it will skip Plan and go straight to Code. The planning overhead is proportional to the complexity of the task. If you want to force a planning step for a task Auto would otherwise execute directly, use Plan mode explicitly, review the output, then switch to Code. # Marshal The mode that plans, checks, builds, and verifies so nothing falls through the cracks. Marshal mode is CORA's structured execution mode. Instead of deciding on the fly what to do next, Marshal mode locks in a fixed sequence of stages **Plan, Reflect, Implement, Review**, and a final **Assessment** and works through them one at a time. It will not skip a stage, rush into code, or silently paper over a problem. Every step is visible, every transition is intentional. #### When to use Marshal Mode Marshal mode is built for tasks where doing it wrong is expensive where a missed edge case, an overlooked dependency, or an incorrect assumption could mean hours of rework. Use Marshal mode when: * You're making changes that touch multiple files, systems, or features at once * The task is complex enough that you want a written plan before any code is written * You've been surprised before by Auto mode making changes you didn't expect or didn't fully review * You're working on something that matters a critical feature, a migration, a refactor with wide blast radius * You want full visibility into what CORA is doing and why, at every step If your task is small or well-scoped `fix this bug`, `refactor this function`, `explain this code` a direct mode like Code or Plan is faster. Marshal mode adds structure that pays off on complex work, not simple tasks. #### How Marshal Mode works Marshal mode runs through five stages in order. It will not move to the next stage until the current one is complete. **1. Plan** CORA reads the codebase, asks questions if needed, and writes a clear implementation plan. Nothing is changed. The goal is to understand the full scope before touching anything. **2. Reflect** CORA re-reads its own plan and stress-tests it. It looks for gaps, risks, edge cases, and anything that could go wrong. The plan is revised until it's solid. **3. Implement** CORA executes the plan writing code, making changes, updating files. It follows the plan exactly as written. **4. Review** CORA checks its own work against the plan. If something doesn't match or a problem is found, it loops back to Implement and fixes it before continuing. **5. Assessment** A final, thorough review pass. CORA checks for regressions, missed cases, and anything that slipped through. Once this stage passes, the task is complete. > You can see which stage CORA is in at any point during the task. If you don't like what you see in the Plan or Reflect stage, push back or redirect before CORA starts making changes that's the right time to course-correct. *** #### Auto Mode vs Marshal Mode Auto mode is the right default for most tasks. It reads the prompt, figures out the best approach, and sequences things on its own planning when needed, jumping straight to code when not. It's flexible and fast, which is exactly what you want for everyday work. Marshal mode trades that flexibility for certainty. Every task starts with a written plan. That plan gets stress-tested before a single file is touched. Code only gets written once the plan is locked. Then it's reviewed, fixed if needed, and verified one final time. If you've ever had Auto mode surprise you mid-task with a change you didn't expect, Marshal mode is how you prevent that you see the full picture and sign off before execution begins. *** #### Running Marshal Mode Marshal mode works best when you describe the full scope upfront. The more context you give, the stronger the plan. ``` Migrate our authentication system from session-based to JWT. Update all protected routes, add refresh token support, and make sure nothing breaks in the existing user flow. ``` ``` Add a multi-tenant billing system. Each organization should have its own subscription, usage tracking, and invoice history. Don't touch the existing single-user billing until the new system is verified. ``` # Plan Produces architecture documents, stack decisions, and dependency-ordered task breakdowns. Does not write any code. Plan mode is for when you want the thinking without the execution to review, refine, or share a technical approach before committing to an implementation. It's useful at the start of a large feature, when evaluating architectural options, or when you want a structured breakdown of what needs to change before anything is touched.
*** ### What Plan produces A Plan mode output typically includes: * A summary of explicit requirements what was stated in the prompt * Implicit requirements things that follow logically but weren't mentioned (the ones that cause problems in week three if they're not accounted for) * Stack selection with explicit reasoning for each choice * A breakdown of services and how they interact * A dependency-ordered task graph, grouped by layer * Open questions or tradeoffs worth discussing before proceeding The output is prose and structured lists, not code. It's designed to be reviewed, pushed back on, or shared with a teammate. *** ### Iterating on a plan Plan output is a starting point. You can respond to any part of it before committing to execution: ``` We're already using MongoDB across the rest of the stack — design tenant isolation around that instead of PostgreSQL. ``` ``` The ingestion API and dashboard can share the same process for now. We'll split them later if we need to scale. ``` Cora will revise the plan based on your constraints. Once you're satisfied, switch to Code mode or use Auto, which will transition automatically after plan confirmation. *** ### Using Plan on existing codebases Plan mode is not only for new projects. You can run it against an existing codebase to get a structured description of what's there, identify architectural inconsistencies, or plan a large refactor before touching any files. ``` Review the current authentication system and plan a migration from session-based to JWT. List every file that will need to change and flag any breaking changes. ``` *** ### Treating the plan as a contract Once you've confirmed a plan and Code mode begins execution, Cora builds against it. If you want to change the approach mid-execution, say so explicitly and stop the current run rather than letting it continue. Partial execution against a plan you've mentally revised produces inconsistent code that's harder to clean up than starting the phase again. # Ask Answers questions about your codebase and explains how things work. Never writes, modifies, or deletes files. Ask mode has full read access to your project but makes no changes. Use it when you need to understand something before acting how a part of the system works, what a function does, what depends on what, or what would break if you changed something.
*** ### What Ask is for Ask is useful any time you need context before making a decision or a change. Some common uses: **Tracing data flow** ``` Where does the WebSocket event "metric:update" originate? Trace the full path from ingestion to the frontend chart component. ``` **Understanding dependencies** ``` What would break if I changed the shape of the Event model? List every file and function that reads from it. ``` **Debugging context** ``` We're getting a 401 on the /events endpoint for a specific API key. Walk me through how API key validation works what gets checked and in what order. ``` **Understanding existing decisions** ``` Why is the ingestion API a separate Express process instead of a Next.js API route? What would break if we merged them? ``` *** ### Ask vs. Plan The distinction is backward vs. forward looking. Ask explains what exists in the current codebase. Plan designs what should exist. If you're trying to understand the system as it is, use Ask. If you're trying to figure out how to change it, start with Plan or Auto. *** ### Ask before large changes A useful habit: run an Ask prompt before any change that touches core infrastructure. Understanding what depends on a thing before you modify it surfaces risks that aren't obvious from reading a single file. ``` Before I refactor the tenant middleware, what are all the places it's used, and are there any edge cases in how it's currently applied? ``` # Code Writes, modifies, and refactors code. The primary execution mode. Code mode makes changes to files. Before writing anything, it reads the existing codebase so that additions and modifications are consistent with what's already there matching the project's folder structure, naming conventions, import patterns, and code style.
*** ### Adding new features When adding a feature to an existing project, Code mode reads the current architecture before writing anything. New files follow the conventions already in use. New endpoints follow the pattern of existing endpoints. New components follow the pattern of existing components. ``` Add a webhook system so organizations can register HTTPS endpoints to receive alerts when a specific event type exceeds a threshold. Retry failed deliveries up to 3 times with exponential backoff. ``` Cora will add the `WebhookEndpoint` model to the schema, create the registration API and management UI, extend the aggregation pipeline to check thresholds, build a delivery service with retry logic, and update the admin panel in a style consistent with the surrounding code. *** ### Refactoring Code mode can refactor across multiple files simultaneously, maintaining consistency across the change. ``` The rate limiter logic is duplicated in three middleware files. Extract it into a shared utility and update all three to import from there. ``` ``` The dashboard API calls are scattered across components. Move them into a centralized api.ts client with typed return values. ``` *** ### Staying in scope Code mode works best with clear, scoped prompts. The smaller the scope, the more precise the implementation and the easier the diff is to review. For large features, break them into steps model changes first, then service logic, then API layer, then frontend and run Code mode once per step. > For changes that touch authentication, API key handling, tenant isolation, or database access patterns, follow up with a Review pass after Code completes. # Review Audits code changes for correctness, consistency, and architectural alignment. Does not write new code. Review mode reads code a recent diff, a specific file, or a set of files you point it at and produces a structured audit. It checks for logical correctness, security issues, consistency with the rest of the codebase, missing edge cases, and alignment with any rules or architectural decisions defined in the project.
*** ### What Review checks | Category | Examples | | ------------ | ------------------------------------------------------------------------------- | | Correctness | Logic errors, incorrect assumptions about data shapes, off-by-one errors | | Security | Missing auth checks, raw key storage, unsanitized inputs, tenant isolation gaps | | Consistency | Patterns that diverge from the rest of the codebase without reason | | Edge cases | Unhandled nulls, missing error states, race conditions | | Architecture | Changes that contradict decisions in the project's rules or plan documents | If you have rules files configured in `.cora/rules/`, Review mode enforces them flagging any code that violates a defined constraint. *** ### Running a review Point Review at a diff, a file, or describe what just changed: ``` Review the changes I just made to the ingestion pipeline and the aggregator service. Focus on tenant isolation — make sure orgId is scoped correctly at every database access point. ``` ``` Review the new API key management endpoints for security issues, particularly around key generation, hashing, and the revocation flow. ``` The output is a list of findings with severity levels, an explanation of each issue, and a suggested fix. You can ask Code mode to apply any of the fixes directly. *** ### When to run Review manually Run a manual Review pass after: * Any change to authentication or session handling * Any change to API key generation, validation, or revocation * Any change to multi-tenancy logic or tenant-scoped queries * Any significant schema change * Any new endpoint that handles user-supplied data It's faster to catch issues immediately after a change than after several more features have been built on top of it. # Configuration Cora's configuration lives on your local filesystem as plain text files. All settings skills, rules, workflows, MCP servers, system instructions, and auto-accept behavior can be read and edited direct ### Where settings are stored Cora has two configuration scopes: **global** and **project**. **Global settings** apply to every project you open. They live in extension storage directory: ``` ~/.config/Code/User/globalStorage/codemateai.codemate-agent/settings/ ``` **Project settings** apply only to the current workspace and take precedence over global settings when both exist. They live at the root of your project: ``` your-project/ .cora/ skills/ rules/ workflows/ mcp_settings.json ``` Both locations use the same file formats Markdown for skills, rules, workflows, and system instructions; JSON for MCP servers. *** ### Global settings directory The full structure of the global settings directory: ``` ~/.config/Code/User/globalStorage/codemateai.codemate-agent/settings/ skills/ api-conventions.md testing-approach.md rules/ security.md naming.md workflows/ new-feature.md pr-prep.md mcp_settings.json system-instructions.md ``` Because these are plain files, you can version-control them, sync them across machines with a dotfiles manager, or share a set of skills and rules across a team. *** ### Global vs. project settings Use **global settings** for conventions and tools that apply to everything you work on a personal coding style, preferred patterns, MCP servers for services you use everywhere like GitHub or Slack. Use **project settings** for things specific to a codebase its domain vocabulary, its particular API conventions, its security rules, the MCP server for its specific database. When both scopes define the same type of file (e.g., a `rules/security.md` in both global and project), the project-level file is used for that project. They don't merge line-by-line the project file takes precedence as a whole for that filename. *** ### Configuration types | Type | Format | Purpose | | ------------------- | -------- | ----------------------------------------------------------------- | | Skills | Markdown | Domain knowledge Cora draws on when relevant to the task | | Rules | Markdown | Hard constraints applied unconditionally to every interaction | | Workflows | Markdown | Step-by-step processes for recurring tasks | | MCP servers | JSON | External tool and service integrations | | System instructions | Markdown | Baseline behavior applied at the start of every session | | Auto-accept | Setting | Whether Cora applies file changes without asking for confirmation | # Skills Markdown files that give Cora domain knowledge specific to your project, stack, or technical conventions. A skill is a structured document that teaches Cora something it should know when working on your codebase. Skills are loaded into context when relevant to the current task, so they influence code generation and planning without you repeating the same information in every prompt.
*** ### Storage locations **Global skills** apply to every project: ``` ~/.config/Code/User/globalStorage/codemateai.codemate-agent/settings/skills/ ``` **Project skills** apply to the current workspace only: ``` your-project/.cora/skills/ ``` Project skills take precedence over global skills when a file with the same name exists in both locations. *** ### What goes in a skill Skills work best for knowledge that is specific, reusable, and stable the kind of thing you'd put in a team wiki or an onboarding doc every new developer needs to read. Good candidates: * How your API is structured authentication headers, error response shapes, pagination conventions * How your components are organized and when to use which one * How your testing approach works what to test, what to mock, naming conventions for test files * Domain vocabulary what a "tenant," "workspace," "pipeline," or "event" means in your product * Third-party integrations with non-obvious behavior an SDK with quirks, a service with particular rate limit semantics *** ### Creating a skill Create a `.md` file in the skills directory for the appropriate scope. The filename becomes the skill name. Write plain Markdown headers, code blocks, and lists as normal. Open the file with a single sentence describing what it covers. Cora uses this to decide whether the skill is relevant to the current task. **Example: `skills/api-conventions.md`** ```markdown # API conventions This skill describes the request and response patterns used across all backend endpoints in this project. ## Authentication All authenticated endpoints expect a Bearer token in the Authorization header. The token is a JWT signed with RS256. Machine-to-machine requests use an API key in the X-Api-Key header — never a JWT. The two auth flows are separate and must not be conflated. ## Error responses All errors return JSON in this shape: { "error": "human-readable message", "code": "MACHINE_READABLE_CODE", "status": 400 } The `code` field is always SCREAMING_SNAKE_CASE and safe to match on in client code. The `error` field is for display only. ## Pagination List endpoints use cursor-based pagination. The response includes `nextCursor` when more results exist. Pass it as `?cursor=` on the next request. There is no offset-based pagination in this project. ``` *** ### When skills are applied Cora reads the skill files at the start of each task and loads those relevant to what it's about to do. Writing a new endpoint loads `api-conventions.md`. Writing a component loads `component-patterns.md`. You don't need to reference skills in your prompt Cora matches them to tasks automatically using the opening description of each file. *** ### Editing skills directly Because skill files are plain Markdown on your filesystem, you can open and edit them in any editor: ```bash # Edit a global skill code ~/.config/Code/User/globalStorage/codemateai.codemate-agent/settings/skills/api-conventions.md # Edit a project skill code .cora/skills/api-conventions.md ``` When a convention in your project changes, update the corresponding skill file. Stale skill files produce output that matches old conventions rather than current ones. # Rules Markdown files that define hard constraints Cora applies to every interaction, without exception. Rules are the invariants of your codebase things that are always true regardless of what the prompt says. Unlike skills, which provide context Cora uses when relevant, rules constrain behavior unconditionally. Cora follows a rule even if a prompt implicitly suggests otherwise.
*** ### Storage locations **Global rules** apply to every project: ``` ~/.config/Code/User/globalStorage/codemateai.codemate-agent/settings/rules/ ``` **Project rules** apply to the current workspace only: ``` your-project/.cora/rules/ ``` Project rules take precedence over global rules when a file with the same name exists in both locations. *** ### What goes in rules Rules are best suited to constraints where a violation would cause a bug, a security issue, or a consistency problem that would need to be fixed before merging. Good candidates: * Security invariants: "every database query on tenant-owned data must include an orgId filter" * Forbidden patterns: things done wrong in the past that must not recur * Required structures: things every module of a given type must have * Import constraints: what can import from what, what must not be imported in certain contexts * Naming conventions that apply everywhere without exception *** ### Creating rules Create a `.md` file in the rules directory. Write rules as direct, unambiguous statements not explanations, but declarations of what Cora must or must not do. **Example: `rules/security.md`** ```markdown # Security rules Every Prisma query that accesses tenant-owned data must include a `where: { orgId }` clause. No exceptions, including admin endpoints. API keys must never be stored in plaintext. Always hash with bcrypt before writing to the database. Store the first 8 characters in a separate `prefix` field for UI display. The ingestion API must never accept JWT authentication. API key auth via X-Api-Key header only. Every Express route handler must validate the request body with a Zod schema before reading any properties from req.body. Never log full API keys, JWTs, or password hashes. Log the key prefix or a redacted placeholder instead. ``` **Example: `rules/naming.md`** ```markdown # Naming conventions Database models: PascalCase singular — User, Organization, ApiKey. Service files: camelCase — userService.ts, apiKeyService.ts. Route files: kebab-case matching the resource — api-keys.ts. React components: PascalCase. Filename matches the component exactly. Zod schemas: Schema suffix — CreateUserSchema, UpdateOrgSchema. Environment variables: SCREAMING_SNAKE_CASE with service prefix — DASHBOARD_DATABASE_URL, INGESTION_REDIS_URL. ``` *** ### Rules vs. skills Rules are unconditional. Skills are contextual. If you find yourself writing a skill that says "always do X" it belongs in a rules file instead. A practical test: if Cora violated this during a code generation pass, would you need to fix it before merging? If yes, it's a rule. *** ### Editing rules directly ```bash # Edit a global rule code ~/.config/Code/User/globalStorage/codemateai.codemate-agent/settings/rules/security.md # Edit a project rule code .cora/rules/security.md ``` All rule files in a given scope are loaded together on every task. There's no per-file scoping every rule applies everywhere within its scope. # Workflows Markdown files that define step-by-step processes for recurring tasks. A workflow is a reusable procedure Cora follows when you invoke it by name. Instead of re-explaining a multi-step process every time, you define it once and invoke it with a short prompt. Cora executes each step in order, substituting the specific details from your prompt.
*** ### Storage locations **Global workflows** available in every project: ``` ~/.config/Code/User/globalStorage/codemateai.codemate-agent/settings/workflows/ ``` **Project workflows** available in the current workspace only: ``` your-project/.cora/workflows/ ``` Global workflows are good for personal processes that apply everywhere PR prep, commit message generation, changelog updates. Project workflows are good for processes specific to a codebase the exact steps for adding a new feature given this project's structure. *** ### What goes in a workflow Workflows are most useful for tasks that are multi-step, touch multiple files in a specific order, or need to be done consistently every time. Good candidates: * Scaffolding a new feature: model, migration, service, route, tests, in the right order * Preparing a pull request: lint, typecheck, test, write the description * Adding a new database model: schema, migration, seed, typed repository class * Creating a new background job: registration, queue config, retry logic, error handling *** ### Creating a workflow Create a `.md` file in the workflows directory. Write steps as a numbered list with enough detail that Cora can execute each one without ambiguity. **Example: `workflows/new-feature.md`** ```markdown # New feature workflow Run when adding a new backend feature. Replace [feature-name] with the actual feature in each step. 1. Add the Prisma model to `prisma/schema.prisma`. Follow naming conventions in `.cora/rules/naming.md`. 2. Generate and apply the migration: `npx prisma migrate dev --name [feature-name]` 3. Update `prisma/seed.ts` if the new model needs local seed data. 4. Create a service at `src/services/[featureName].ts`. Export a class with typed methods. Define the interface at the top of the file. 5. Create a route at `src/routes/[feature-name].ts`. Validate all request bodies with Zod before reading any field from req.body. 6. Register the new route in `src/server.ts`. 7. Write integration tests in `tests/[featureName].test.ts`. Cover the happy path and at least two error cases. 8. Update `shared/types/index.ts` with any types shared between frontend and backend. ``` **Example: `workflows/pr-prep.md`** ```markdown # PR preparation workflow Run before opening a pull request. 1. Run `npm run lint` and fix all errors. 2. Run `npm run typecheck` and fix all type errors. 3. Run `npm test` — all tests must pass. 4. Check for changed files without test coverage and note them in the PR description. 5. Write the PR description: what changed, why, any breaking changes, how to test locally, and any follow-up work deferred. 6. Scan the diff for accidentally committed debug logging, commented-out code, or TODOs that should be filed as issues. ``` *** ### Invoking a workflow Reference the workflow by name in a prompt: ``` Run the new-feature workflow for a webhook subscription system. ``` ``` Run pr-prep on the changes from this session. ``` Cora follows the steps in the workflow file, filling in the specific details from your prompt. If a step requires a decision the workflow doesn't cover, Cora asks before proceeding rather than guessing. *** ### Editing workflows directly ```bash # Edit a global workflow code ~/.config/Code/User/globalStorage/codemateai.codemate-agent/settings/workflows/pr-prep.md # Edit a project workflow code .cora/workflows/new-feature.md ``` Workflow steps can reference other config files pointing at `rules/naming.md` or `skills/api-conventions.md` for the specifics. This keeps workflows short and avoids duplicating content. # MCP servers Connect external tools and services to Cora using the Model Context Protocol. MCP (Model Context Protocol) is an open standard for connecting AI agents to external tools. Cora supports MCP servers to give it access to systems beyond the local codebase GitHub, Slack, databases, CI pipelines, internal APIs, and anything else with an MCP server implementation.
*** ### Storage locations **Global MCP config** available in every project: ``` ~/.config/Code/User/globalStorage/codemateai.codemate-agent/settings/mcp_settings.json ``` **Project MCP config** available in the current workspace only: ``` your-project/.cora/mcp_settings.json ``` Use the global config for services you use across all projects GitHub, Slack, a personal database. Use the project config for services specific to a codebase the project's own database, its staging environment, its internal tools. *** ### Configuration format `mcp_settings.json` is a JSON file where each key is a server name and the value describes how to start it. ```json { "mcpServers": { "filesystem": { "command": "npx", "args": [ "-y", "@modelcontextprotocol/server-filesystem", "" ] }, "git": { "command": "uvx", "args": ["mcp-server-git"] }, "memory": { "command": "npx", "args": [ "-y", "@modelcontextprotocol/server-memory" ], "env": { "MEMORY_FILE_PATH": "/memory.jsonl" } }, "slack": { "command": "npx", "args": ["-y", "@jtalk22/slack-mcp"] } } } ``` Environment variable references in the format `${VAR_NAME}` are resolved from your shell environment when Cora starts. Never write credential values directly into the file. > If `mcp_settings.json` is inside a project directory, add it to `.gitignore` — even with environment variable references, the file may reveal internal service names or infrastructure details you don't want in a shared repository. *** ### Using MCP tools in prompts Once configured, MCP tools are available in any mode. Describe what you want in natural language Cora calls the appropriate tool without special syntax. ``` Check GitHub for open issues tagged "auth" and summarize what's blocking the multi-tenant login bug. ``` ``` Query the production database for the 10 organizations with the highest event volume in the last 7 days. ``` ``` Post a summary of today's merged PRs to the #deployments Slack channel. ``` ``` Create a GitHub issue for the rate limiting edge case we just found and assign it to the auth milestone. ``` *** ### Editing the config directly Because `mcp_settings.json` is a plain file on your filesystem, you can edit it directly: ```bash # Edit the global MCP config code ~/.config/Code/User/globalStorage/codemateai.codemate-agent/settings/mcp_settings.json # Edit a project MCP config code .cora/mcp_settings.json ``` Changes take effect the next time Cora starts a session. If you add a new server mid-session, reload the Cora panel to pick it up. *** ### Security MCP servers run as separate processes. Cora calls them over a local interface they don't have access to Cora's context or your environment beyond what you explicitly configure in the `env` block. Before adding an MCP server from a third party, verify it comes from a trusted source and review what permissions and credentials it requests. A server that only needs to read GitHub issues does not need a token with write access to your repositories. # Auto-accept Controls whether Cora applies file changes automatically or waits for your confirmation before writing to disk. **Cora has two main hands-off modes:** 1. **Auto-accept** (File changes / Write operations) 2. **Auto-approve** (All permission requests / YOLO Mode) *** #### 1. Auto-accept (File Write Auto-Apply) **What it does**\ By default, Cora shows you a diff of every proposed file change and asks for confirmation before writing to disk.\ When **Auto-accept is enabled**, Cora applies (writes) the changes to disk immediately after generation, skipping the review step. **Where to enable it** * IDE → Cora settings panel (easiest) * Or manually in settings files: **Global setting** (all projects): ```bash ~/.config/Code/User/globalStorage/codemateai.codemate-agent/settings/ ``` **Project-level setting** (overrides global): ```bash your-project/.cora/ ``` **Recommended use cases (Safe to enable)** * Working on a dedicated experimental branch * Small, well-scoped, repetitive tasks you’ve seen Cora do many times * Fast iteration on a new/throwaway project * Tests running in watch mode **Do NOT enable when** * Changing auth, security, API keys, or multi-tenancy code * Working on `main` / production branches * Large refactors or architectural changes * First time using Cora in a new codebase **Undo safety**\ Always use Git. Changes are just normal file writes: ```bash git diff git checkout -- git checkout -- . # discard all ``` > **Rule of thumb**: Never enable Auto-accept without being in a Git repository. *** #### 2. Auto-approve (Permission / YOLO Mode) This is more powerful and riskier. It controls whether Cora has to ask you for permission before performing actions. **Setting name**: "Auto-approve enabled" or "YOLO Mode" **What it does**\ Runs selected actions without asking for permission. You can enable it per category. **Available Permission Categories** | Category | What it allows automatically | | --------------------------- | --------------------------------------------------- | | **Read** | Reading files outside the workspace | | **Write** | Creating/editing files outside the workspace | | **Include protected files** | Editing `.coraignore`, `.cora/` config files etc. | | **Execute** | Running terminal commands | | **Browser** | Browser/MCP operations | | **Subtasks** | Creating subtasks automatically | | **Delete** | File/folder deletion | | **Question** | Time to wait before auto-selecting the first answer | # Browser Agent Give CORA control of a browser navigate pages, interact with your running app, scrape content, and test UI flows, all from a natural language prompt. ### Overview The Browser Tool lets CORA take control of a real browser session. Once enabled, you can tell CORA to open your local frontend, click buttons, fill forms, scroll pages, extract content, and interact with any web interface exactly as a user would, but driven by your instructions.
Common use cases: * **Start your frontend and test it** tell CORA to run `npm run dev`, open `localhost:3000`, and interact with the UI on your behalf. * **UI automation** navigate flows, trigger states, and verify behavior without writing test scripts. * **Web scraping** instruct CORA to visit a page and extract structured data. * **Visual debugging** CORA takes screenshots at each step so you can see exactly what it sees. *** ### Enabling the browser tool 1. Open **CORA** in your editor. 2. Click the **Settings** icon in the CORA panel. 3. Toggle **Enable browser tool** on. CORA will now have access to a browser session for any task that requires it. *** ### Settings #### Viewport size Controls the browser window dimensions CORA uses when taking screenshots and interacting with pages. | Option | Dimensions | Best for | | ------------- | ---------- | ---------------------------- | | Small Desktop | 900 × 600 | Default most desktop layouts | You can adjust this to match the viewport your app is designed for useful when testing responsive breakpoints. #### Screenshot quality Controls the fidelity of screenshots CORA captures at each browser step. | Setting | Trade-off | | ----------------- | ---------------------------------- | | Low | Fewer tokens, faster responses | | **75% (default)** | Balanced clarity and token usage | | High | Maximum clarity, higher token cost | Increase quality if CORA is misreading fine UI details. Lower it if you're running long browser sessions and want to reduce token consumption. *** ### Remote browser connection (CDP) By default, CORA launches a local browser session automatically. If you want CORA to connect to an **existing Chrome instance** instead for example, a browser already authenticated to a service, or a remote browser in a CI environment you can connect over the **Chrome DevTools Protocol (CDP)**. #### Enable remote connection 1. In CORA Settings, toggle **Use remote browser connection** on. 2. Enter your CDP host in the field provided. 3. Click **Test Connection**. CORA will attempt to connect and confirm the session is reachable. If you leave the field empty, CORA will auto-discover any Chrome instances running locally with remote debugging enabled. ### Example workflows #### Start and test a local frontend ``` Start the dev server with `npm run dev`, then open localhost:3000, click the Login button, and tell me if the form renders correctly. ``` CORA will run the dev server, open the browser, navigate to the page, interact with it, and report back with screenshots at each step. #### Scrape a page ``` Go to https://example.com/pricing and extract all plan names and prices into a JSON array. ``` #### Automate a UI flow ``` Open localhost:3000, sign in with test@example.com / password123, navigate to the dashboard, and click "Create new project". ``` # C0 C0 is an AI-powered coding assistant built into your IDE. It indexes your entire codebase, remembers what it learns, and helps you write, debug, review, document, and understand code all through natural conversation, without ever leaving your editor. *** ### What makes C0 different Most AI coding tools work in isolation. They don't know your project, your patterns, or your team's conventions. Every session starts from scratch. C0 is built around a **persistent knowledge base** that continuously indexes your codebase. It understands your functions, your dependencies, your architectural patterns, and how everything connects. That understanding carries across sessions, so C0 gets more useful the longer you use it not less. On top of that foundation, C0 offers a set of purpose-built **workflows** not a generic chat box, but specific modes designed around the things developers actually do all day: debugging, writing tests, reviewing code, documenting code and working from Jira tickets. *** ### Core workflows | Workflow | What it does | | ------------------- | -------------------------------------------------------------- | | Chat with code | Ask questions about your codebase in plain language | | Debug mode | Trace errors to their root cause and fix them | | Optimize mode | Improve performance, readability, and structure | | Generate test cases | Write meaningful tests for any function or module | | Code reviews | Catch bugs and issues before code is merged | | Deep Wiki | Generate rich documentation with usage notes and edge cases | | Code Map | Visualize code structure and system flow with Mermaid diagrams | | Swagger Agent | Agent works with Swagger documentation and API Specifications | *** ### Integrations | Integration | What it does | | -------------- | ---------------------------------------------------- | | Jira | Work directly from tickets without context-switching | | Knowledge base | The persistent memory layer that powers everything | *** ## Get Started with C0 > New to C0? Install the extension, connect your codebase, and run your first workflow in under five minutes. *** ### Choose your environment #### VS Code / Cursor / Antigravity Install the C0 extension directly from the Extension panel in the IDE. Before Installing download and Setup the CodeMate ToolBox in your device, this is crucial as all the CodeMate Products communicate with each other through the ToolBox. #### CodeMate Toolbox Already have Toolbox installed? You can install the C0 extension directly from within it no marketplace required. 1. Open **CodeMate Toolbox**. 2. Navigate to **C0 → Install Extension**. 3. Toolbox will detect your installed editors and install the extension automatically. Don't have Toolbox yet? [Download it here](https://app.codemate.ai/download). # Quickstart Get C0 installed, connected to your codebase, and running your first workflow in under five minutes. ### 1. Install C0 Open the Extensions view (`Cmd+Shift+X` on Mac, `Ctrl+Shift+X` on Windows/Linux) and search for **C0**. *** ### 2. Sign in On first launch, C0 will prompt you to sign in. Click **Sign in with C0** and complete authentication in your browser. Once signed in, you'll be returned to your IDE automatically. *** ### 3. Open a project and let C0 index it Open any project folder in your IDE. C0 will detect it and begin indexing your codebase automatically. You'll see a status indicator in the C0 panel: * **Indexing:** C0 is reading your files and building its knowledge base * **Ready:** indexing is complete; C0 now understands your codebase For small projects, indexing takes under a minute. For larger codebases, it may take a few minutes on the first run. After that, C0 only re-indexes files that have changed, so subsequent updates are nearly instant. > **Note:** You can start using C0 before indexing finishes. Results will improve as indexing progresses. *** ### 4. Try your first workflow Once indexing completes, try one of these to see C0 in action: **Ask a question about your code:** Open the C0 chat panel and type: ``` @