Continue.dev Review: Stable Async PR Agents for Automated Code Quality
8 min read
Updated
Review of Continue.dev v2.0.0 after its acquisition by Cursor. Learn about its async PR agents, CLI modes, features, pricing, and alternatives.
If you previously knew Continue.dev as an IDE extension for AI-powered autocomplete and chat, its focus shifted significantly. The tool evolved into a system focused on Continuous AI: an open-source CLI that runs async agents on every pull request, enforcing team rules, catching issues, and suggesting fixes.
Following Continue's acquisition by Cursor, the continuedev/continue repository is read-only, and v2.0.0 is the final release from the original team, with telemetry removed and authentication pulled out.
The tool still installs and runs. The CLI, the VS Code extension, and the JetBrains plugin remain available on their respective marketplaces. While there will be no more official roadmap from the original team, Continue.dev remains a stable, bring-your-own-LLM (BYO-LLM) tool that developers and the community can continue to run and maintain.
What is Continuous AI?
The core concept is to integrate AI into the development lifecycle to create self-improving loops rather than just assisting with real-time code completion.
Instead of waiting for a human reviewer to notice that a PR violates team conventions or contains minor issues, Continue.dev runs agents that:
- Watch every PR as it's opened.
- Check code against rules you've defined in your codebase.
- Flag issues silently (surfacing warnings only when something is wrong).
- Suggest fixes with precise diffs you can review and apply.
This bridges the gap between high-speed code generation and the final automated deployment.
Who should use Continue.dev?
Continue.dev fits teams and developers who:
- Have established coding standards they want to enforce automatically.
- Ship a high volume of PRs and need to accelerate review cycles.
- Want custom AI agents tailored to their specific codebase and conventions.
- Value open-source tools without vendor lock-in.
- Are comfortable with CLI-first workflows.
It is less ideal if you are looking primarily for real-time, in-IDE autocomplete or a plug-and-play setup. For those use cases, tools like GitHub Copilot or Cursor are better suited.
Key features
1) Async agents on every PR
The core feature is running background agents to review pull requests. These agents:
- Execute rules defined directly in code.
- Access the full codebase for context-aware reviews.
- Run in parallel with other background tasks.
- Surface issues only when problems are detected, minimizing notification noise.
Unlike traditional static linters, these agents analyze intent and logic rather than just syntax.
2) Two CLI modes
Continue.dev offers two ways to run the CLI:
- Headless mode: Run agents in the cloud or CI/CD environment without a graphical interface.
- TUI mode: An interactive terminal interface for synchronous, hands-on coding sessions.
3) Silent enforcement with fixes
When agents identify an issue, they provide:
- A clear explanation of the problem.
- A diff displaying the suggested change.
- The ability to apply the fix directly to your branch.
4) Developer tool integrations
Continue.dev connects with standard developer platforms and workflows:
- GitHub: Pull requests, repository access, and automated commits.
- Sentry: Error tracking integration.
- Snyk: Security scanning.
- Supabase: Database migrations and schemas.
- Slack: Real-time alerts routed upon PR creation.
- CI/CD pipelines: Custom automated steps.
5) Customizable agent workflows
You can customize agent behaviors by:
- Defining rules in code rather than configuration files.
- Building agents for specialized checks (e.g., security audits, performance profiling).
- Sharing rules and agents across multiple projects.
What changed from legacy versions?
| Aspect | Legacy Continue.dev | Continue.dev v2.0.0+ |
|---|---|---|
| Primary interface | IDE extensions | CLI (headless + TUI) |
| Main use case | Autocomplete + chat | PR agents + rule enforcement |
| Focus | Real-time coding help | Async workflow automation |
| IDE support | VS Code, JetBrains (primary) | Available, but de-emphasized |
| Target user | Individual developers | Teams with standards to enforce |
Pricing
Continue.dev is free and open-source (Apache 2.0 license). There are no paid tiers.
Associated costs include:
- LLM API fees: Paid directly to your provider of choice (OpenAI, Anthropic, DeepSeek, etc.) for running the agents.
- Compute resources: Costs to run the CLI on your local machine, self-hosted servers, or CI/CD infrastructure.
What's not great
- No active official maintenance: The repository is read-only. Updates, bug fixes, and new model integrations rely on community forks.
- Steeper learning curve: A CLI-first workflow requires more initial configuration than standard IDE extensions.
- Less polished IDE experience: The extensions remain available but do not receive ongoing updates from the original team.
- Terminal-only: There is no dedicated web or mobile interface.
- No formal compliance certificates: Lacks native enterprise certs like SOC 2 or ISO.
Note: The v2.0.0 release removed anonymous telemetry and authentication requirements, ensuring the codebase is fully standalone.
Continue.dev vs Claude Code CLI
| Aspect | Continue.dev | Claude Code CLI |
|---|---|---|
| Focus | PR agents + rule enforcement | Terminal coding agent |
| Price | Free + LLM costs | Paid ( Anthropic usage / subscription ) |
| Async agents | Yes (core feature) | No (synchronous focus) |
| Model choice | Any LLM | Anthropic models only |
| Best for | Team PR automation | Individual power users |
Continue.dev vs Aider
| Aspect | Continue.dev | Aider |
|---|---|---|
| Focus | PR review and rules | Multi-file codebase editing |
| Interface | CLI (headless + TUI) | CLI only |
| Async agents | Yes | No |
| Git integration | PR-focused | Commit-focused |
| Best for | Team automation | Individual pair programming |
Continue.dev vs Windsurf
| Aspect | Continue.dev | Windsurf / Devin Desktop |
|---|---|---|
| Type | CLI + async agents | Full IDE |
| Focus | Async PR automation | Real-time agentic coding |
| Price | Free + LLM costs | Free tier + paid subscriptions |
| Deployment | Self-hosted | Cloud / hybrid options |
| Best for | Teams with existing CI/CD | Developers wanting a dedicated IDE |
Continue.dev vs Cursor
| Aspect | Continue.dev | Cursor |
|---|---|---|
| Type | CLI agents for PR review | AI-native IDE |
| Focus | Async rule enforcement on PRs | Real-time code generation and editing |
| When it runs | Background (after you push) | Inline (while you write code) |
| Price | Free + LLM costs | Free tier / paid subscriptions |
| Code generation | No (reviews existing code) | Yes (generates and edits code) |
| Best for | Automated quality gates | AI-assisted code writing |
Continue.dev vs Google Antigravity
| Aspect | Continue.dev | Google Antigravity |
|---|---|---|
| Type | CLI + async agents | Full agentic IDE |
| Focus | PR review automation | Agent-first development |
| Autonomy | Runs checks on pushed PRs | Agents plan and execute tasks end-to-end |
| Models | BYO (any LLM provider) | Gemini + Claude/OpenAI |
| Price | Free + LLM costs | Free (public preview) |
| Best for | Quality gates and rule enforcement | Developers wanting autonomous agent workflows |
How to get started
Install the CLI
Install the package globally via npm:
npm install -g @continuedev/cli
Or install via curl:
curl -fsSL https://continue.dev/install.sh | bash
Configure your first agent
Create a .continue/rules directory in your repository and define your rules in plain text or markdown format. For example, a file named no-console-logs.md:
# rule: no-console-logs
Check for console.log statements in production code.
Flag any console.log that isn't in a test file or development helper.
Suggest replacing with a proper logging utility.
Run in headless mode
To integrate Continue.dev into your CI/CD pipeline:
continue run --headless --on-pr
Run in TUI mode
For interactive terminal sessions:
continue tui
Practical workflows
- Automated PR reviews: Set up GitHub Actions to trigger Continue.dev when a pull request opens. The agent runs your custom rule suite and posts feedback as comments, letting human reviewers focus on overall architecture instead of minor style issues.
- Parallel agent runs: Configure separate, specialized agents to run concurrently: a security agent checks for vulnerabilities, a performance agent flags slow operations, and a test coverage agent checks for missing unit tests.
- Overnight tasks: Queue up complex refactoring tasks or rules check before leaving, letting the async agents run and generate pull requests overnight for human review in the morning.
Security and privacy
- Continue.dev operates local-first when running the CLI.
- If you configure cloud LLMs (such as OpenAI or Anthropic), code snippets required for context are sent to those external APIs.
- You can run local LLMs (via Ollama or similar local servers) to keep all codebase data entirely on your local machine or private network.
- Telemetry is enabled by default but can be disabled in configuration settings.
- It does not include native enterprise compliance certifications; organizations needing SOC 2 or ISO validation must handle this at the infrastructure level.
Alternatives
- Similar CLI agents: Claude Code CLI, Aider, OpenAI Codex CLI
- Full IDE experiences: Windsurf, Cursor
- Open-source coding assistants: Goose, Devika
Verdict
Continue.dev's focus on Continuous AI targets a key bottleneck: automating rule enforcement and code reviews asynchronously on pull requests. Although the Cursor acquisition marks the end of official updates from the original team, the final v2.0.0 release is highly functional, telemetry-free, and suitable as a stable, self-hosted, bring-your-own-LLM tool.
For solo developers looking for an easy, real-time coding companion, Cursor, Copilot, or Windsurf are the standard starting points. However, for engineering teams that want to automate PR quality gates using a custom, open-source rule engine, Continue.dev v2.0.0 provides a reliable, self-hostable framework.