What Are Continue Agents? Any Workflow, Your Team's Way

Don't fall into the request-response trap: ask a question, get an answer, copy it, paste it, realize it doesn't quite work, go back, ask again, copy, paste, debug. Rinse and repeat until you've spent 30 minutes on something that should have taken 5. Continue Agents can do the work for you.

Any Agent, Any Way You Work

GitHub recently framed their approach as "Any agent, any way you work." We've been using that same philosophy and making it concrete for development teams:

Any workflow, your team's way—standardized, repeatable, automated.

An agent on the Continue platform is your team's specialist workflow. It's a combination of:

• Prompt (the mission)
• Tools & MCPs (the capabilities)
• Rules (your team's standards)

Shareable, remixable, and ready to run from CLI, mission control, or automation. Designed to solve a specific task with your team's standards built-in.

What Exactly Is an Agent?

Think about calling a repair technician to fix a leaky faucet. You don't teach them how to hold a screwdriver every time. They show up with:

• A tool belt (the right tools for the job)
• A checklist (standard process and safety rules)
• Your instructions (fix the leak in bathroom 2)

That's exactly what a Continue Agent does for your team's workflows.

An agent is a standardized workflow that anyone on your team can invoke with a specific prompt. It doesn't just suggest what to do (unless that's the prompt you give it), it does it. It uses tools, makes decisions, follows your rules, and works through problems the way your team would.

Once you define an agent, anyone can run it depending on the permissions you give.

Why Agents Matter

🔁 Consistency

No matter who runs it, the output follows your team's format and rules. When your security agent scans code, it uses the same severity thresholds, creates issues in the same format, and follows the same remediation patterns, whether it's run by a junior developer or triggered automatically in CI.

📤 Shareability

Define once, use everywhere. Create an agent in the Hub, and your entire team can invoke it from CLI, Continue Mission Control, or automation. No need to re-explain your team's standards every time someone needs to run the workflow.

⚡ Speed & Scale

Build a standardized agent once, then teammates or automation can invoke it with a specific prompt. Need to run security scans across 50 repositories? One agent, 50 invocations. Need three different people to update documentation? Same agent, different contexts.

🛡️ Governed & Auditable

Agents embed your rules, guardrails, and tools, making automation safe and reliable. You've defined what "right" means for your team, and the agent follows those standards every time.

Agents You Can Run Right now

1. First install the CLI if it's not already:

npm i -g @continuedev/cli

2. Run a command from the CLI command table below in your terminal:

How an Agent Works: The Three Components

Every Continue Agent is built from three essential pieces:

1. Prompt: The Mission

Every agent has one base prompt, which is essentially its core mission. This defines what the agent is built to do and provides the foundation for all its work.

But here's where it gets powerful: you can drill down on that prompt with additional context each time you use the agent.

Example: Linear Agent

Base prompt:

You are an agent which is assigned to solve tasks in Linear. 
You are added as an assignee to the ticket, which triggers this job. 
Being careful to follow the provided Linear rules, solve the following task.

When you invoke it:

cn --agent my-team/linear-agent "Look at all features shipped over the weekend and cross-reference with docs. If documentation needs updating, create a Linear issue and assign to the PR author."

The agent combines its understanding of how to work with Linear (base prompt) with what you need right now (your specific instruction) to accomplish the task.

2. Tools & MCPs: The Capabilities

Tools are what make agents actionable. They're the difference between an agent that describes what should happen and an agent that makes it happen.

Continue Agents have access to:

Built-in Tools:

• File operations (read, write, modify files)
• Codebase search (find definitions, references, patterns)
• Terminal commands (run tests, linters, scripts)
• Git operations (commit, branch, push)

Model Context Protocol (MCP) Connections:

• Linear (create and manage issues)
• Supabase (database operations)
• Snyk (security scanning)
• Slack (notifications and updates)
• MCP Servers in Continue

By default, agents ask permission before using tools. But you can configure tool policies to make certain operations automatic (like running tests) while requiring approval for others (like pushing to main).

3. Rules: Your Team's Standards

Rules are like your team's coding standards and best practices, baked into the agent. They guide how your agent approaches tasks and keep output consistent.

Example: Security Scanning Agent Rules

rules:
  - Use severity threshold "medium" or higher
  - Create Linear issues for all critical vulnerabilities
  - Format issue titles as: "[Security] Brief description"
  - Include file path and line number in issue body
  - Tag issues with "security" and "automated"
  - Run Snyk Code scan, not Snyk Open Source
  - Only propose fixes for top 3 issues per scan

Without rules, every person using the agent might approach the task differently. With rules, the agent produces consistent output that matches your team's expectations every time.

Rules can define:

• Coding standards and patterns
• Security requirements and thresholds
• Testing strategies
• Documentation formats
• Naming conventions
• Review processes

Rules are discoverable and shareable through the Continue Hub. Start with community rules, customize for your team, share with your organization.

Modes of Use: Interactive & Headless

Agents work in two fundamentally different ways, depending on what you need:

Interactive Mode (CLI TUI)

You open a prompt and work with the agent directly:

cn --agent my-team/debug-specialist "Why is the login endpoint returning 500?"

The agent investigates, shows you what it's finding, asks for permission to use tools, and works through the problem interactively. You're there, watching, guiding when needed.

When to use interactive mode:

• Testing agent configurations locally
• Debugging complex issues that need human judgment
• Learning how an agent approaches problems
• Quick one-off tasks while you're in the terminal

Headless Mode (Automation)

The agent runs without manual intervention—one-off or recurring tasks that happen automatically:

cn --agent my-team/snyk-agent -p "Run complete security scan and create issues for critical vulnerabilities"

The agent does its job based on your rules and tools, creates pull requests or issues, and reports back when done. You review the results when you're ready.

When to use headless mode:

• Scheduled security scans
• Post-merge documentation updates
• Automated triage of new issues
• Continuous integration checks
• Regular maintenance tasks

This is what we mean by "Continuous AI." It's AI that works the way modern development works, with processes running in the background, taking action automatically, and flowing through your existing workflows.

A Visual Model

Here's how to think about the relationship between components and execution:

┌────────────────────────────────────┐
│             Agent                  │
├────────────────────────────────────┤
│ 📝 Prompt — Core task              │
│ 🧰 Tools & MCPs — Systems          │
│ 📐 Rules — Team standards          │
└────────────────────────────────────┘
            ↓
     Where You Work
┌──────────────┬───────────────┐
│ CLI / TUI    | Automation    │
└──────────────┴───────────────┘

Or more simply:

Agent = Prompt + Tools + Rules → Your Team's Workflow Specialist

Where Agents Live: Hub, CLI, and Mission Control

The Hub: Where Agents Are Born

hub.continue.dev/agents is where you create and configure agents:

• Create new agents with custom configurations
• Share agents with your team or organization
• Configure models, rules, tools, and base prompts
• Kick off background agents to run continuously

The Hub is your agent management console and the central place where workflows become standardized and shareable.

The CLI: Agents in Action

Continue CLI lets you run agents directly from your terminal:

# Interactive mode - work with the agent in TUI
cn --agent my-team/linear-agent "Scan codebase and give me the top issue"

# Headless mode - give it a task and let it work
cn --agent my-team/security-scan - p "Scan entire codebase and create GitHub issues for any high priority issues."

The CLI is perfect for:

• Testing agent configurations locally before automation
• Quick tasks while you're already in the terminal
• Debugging and refining agent behavior
• Running one-off workflows

Mission Control: Agents at Scale

Mission Control is where you monitor and manage agents running in the background:

• Track active agents and their progress
• Review pull requests and issues created by agents
• Manage multiple agents across different projects
• Monitor performance and outcomes
• Audit agent actions and decisions

A Real-World Workflow: The Security Agent

Let me show you how agents work in practice with a complete example.

The Problem: Your team needs to run security scans regularly, but:

• Different developers use different tools inconsistently
• Security issues get formatted differently in Linear
• Some scans check the wrong things
• It's manual work that everyone forgets to do

The Agent Solution:

You create a Security Agent with:

Base Prompt:

You are a security specialist agent that runs code scans and creates 
actionable issues for vulnerabilities. Follow the team's security 
standards and issue format exactly.

Tools:

• Snyk MCP (for security scanning)
• Linear MCP (for creating issues)
• File operations (to read code)
• Terminal (to run additional checks)

Rules:

- Use Snyk Code 
- Severity threshold: medium or higher
- Issue title format: "[Security] Brief description"
- Include: file path, line number, severity, remediation
- Tag all issues: "security", "automated"
- Only propose fixes for top 3 critical issues
- Run tests on proposed fixes before committing

Running it interactively (testing):

cn --agent my-team/security-scan
# Agent asks: "What would you like me to scan?"
# You: "Run a full scan on the authentication module"

The agent:

1. Scans the auth module with Snyk
2. Finds 7 medium+ vulnerabilities
3. Proposes fixes for the top 3 critical issues
4. Runs tests on each fix
5. Shows you the results for review

Running it headless (automation):

# In your CI/CD pipeline
cn --agent my-team/security-scan "Scan all changes in this PR"

The agent runs automatically on every PR, creates issues for any new vulnerabilities, and comments on the PR with a summary. Your team never has to remember to run security scans because the agent handles it consistently, every time.

The Power of "Any Agent, Any Way You Work"

This is where Continue's approach to agents becomes powerful. The same agent definition works across every context:

For a Junior Developer:

cn --agent my-team/security-scan
# Interactive guidance, tool permission requests, explanations

For a Senior Developer:

cn --agent my-team/security-scan "Full scan, auto-create issues"
# Minimal interaction, trusted to handle it

For CI/CD:

cn --agent my-team/security-scan -p "Scan PR changes"
# Completely automated, results posted to PR

For Scheduled Jobs:

cn --agent my-team/security-scan "Weekly full codebase scan"
# Runs every Monday, issues appear in Linear automatically

Same agent. Same standards. Same quality. Different contexts.

Your team's way, standardized once, executed everywhere.

Getting Started: Your First Agent

If you're ready to create an agent, here's the simplest path:

1. Identify a repetitive workflow
   • Something your team does regularly
   • Has clear steps and standards
   • Produces consistent output
   • Examples: security scans, documentation updates, issue triage
2. Visit hub.continue.dev/agents
   • Create an agent from scratch
   • Write a clear base prompt (what the agent does)
   • Select the tools it needs (what it can access)
   • Set rules (how it should work)
   • See what it does in real-time
   • Refine the prompt and rules
   • Adjust tool permissions
3. Share with your team
   • Publish to your organization
   • Document when to use it
   • Gather feedback and iterate

Test locally in CLI TUI mode

cn --agent your-org/your-agent-name

Success with one agent builds understanding and confidence. Once your team sees the value of standardized workflows, you'll start finding opportunities everywhere.

What Agents Are Not

Agents are not replacements for developers. They're not magic. They're not going to make product decisions or architect your system.

Agents are standardized workflows that handle mechanical work so your team can focus on problems that require judgment, creativity, and deep thinking.

You're still responsible for:

• Defining what "good" looks like (the rules)
• Reviewing agent output (like any PR)
• Making architectural decisions
• Choosing what to ship
• Understanding your code

The agent just removes the friction of execution and ensures consistency.

Choice, Control, Consistency, Scale

GitHub's messaging around agents emphasizes four key principles. Continue agents embody all of them:

Choice: You pick your agent, you pick the tools, you pick the model. Continue supports multiple LLMs and MCPs, giving you full control over your stack.

Control: Agents follow your team's standards. Rules, tool policies, and review processes keep agents aligned with how your team works.

Consistency: Same format, whether you're in the CLI, Mission Control, or automation. An agent produces reliable output regardless of who runs it or when.

Scale: From one-off tasks to automated pipelines, agents scale with you. Define once, use thousands of times across repositories, teams, and workflows.

The Future Is Already Running

Real development is continuous. Tests run in the background. Builds trigger automatically. Deployments flow through pipelines.

Your AI should work the same way.

Continue Agents transform AI from a request-response tool into a standardized workflow system. They work the way you work: continuously, with context, following your team's standards.

Any workflow, your team's way: standardized, repeatable, automated.

The future of development is already running in the background.

Ready to create your first agent? Visit hub.continue.dev/agents and see what happens when your team's workflows become shareable, consistent, and scalable.

Want to dive deeper? Check out our MCP Cookbooks for ready-to-use agent configurations, from automated security scanning to continuous documentation updates. Or read How to Get the Most Out of Your AI Agent for practical tips on configuration and workflows.