A practical definition

A coding agent is software that uses a language model to pursue a coding goal over multiple steps. It reads context, forms a plan, calls tools, observes the results and decides what to do next. “Autonomous” describes how much of that loop it can run without a human in the middle.

That is different from code completion. Completion predicts the next token or line. An agent can inspect a repository, edit several files, run tests, read the output and revise its approach.

Levels of autonomy

Autonomy is a spectrum. A useful working model is:

  1. Completion: suggests code inline; the developer accepts or rejects it.
  2. Chat-assisted: explains code or proposes a patch; the developer applies it.
  3. Tool-using agent: reads files and runs approved tools, but asks before edits or commands.
  4. Plan-and-execute agent: plans a multi-step task and runs it with checkpoints or scoped auto-approval.
  5. Unsupervised agent: operates for long periods with minimal confirmation, ideally in a sandbox.

Level 5 is the exception, not the default. The useful question is not “is it autonomous?” but “which actions require approval, and how do I stop or undo a run?”

What the agent needs

  • Context: file tree, symbols, diagnostics, terminal output and relevant docs.
  • Planning: a visible plan that can be reviewed before execution.
  • Tools: file edits, search, terminal, browser, MCP servers and test runners.
  • Approval: a clear boundary around reads, writes, commands and network access.
  • Recovery: diffs, checkpoints, Git history or a sandbox snapshot.
  • Model access: a provider, a local model or a hosted model, with keys stored safely.

Where autonomy goes wrong

Long-running agents can make plausible but incorrect changes, run destructive commands, leak secrets, install untrusted packages or broaden their own permissions. The risk grows when approvals are disabled and the workspace has production credentials.

Practical controls include a disposable branch, least-privilege API keys, explicit approval for terminal and network tools, secret scanning, sandboxed execution and a reviewable diff before merge.

How Bytos approaches it

Bytos is a VS Code agent with a plan-first workflow. It shows the plan, edits files as reviewable diffs, runs commands in a VS Code terminal and calls MCP tools with approval. Auto-approval is opt-in per category, not the default.

Sequential Auto Phase lets you define up to ten phases, each with its own provider, model, prompt, attachments and MCP allowlist. The phases run in order, not in parallel, and a run can be stopped. This is deliberate: sequential orchestration is easier to inspect and recover than an unbounded swarm.

Bytos is open source and bring-your-own-key. Provider keys are stored in VS Code SecretStorage; model requests go from your machine to the provider you choose. The extension does not require a Bytos account.

A supervised workflow example

A practical supervised loop looks like this: describe a failing test, let the agent read the relevant files, review its plan, approve the file edit, approve the test command, inspect the failure, and let it propose a second change. The human decides when the loop stops and whether the final diff is merged.

That loop is slower than a single completion, but it is still much faster than doing every step manually. The value comes from the agent handling context gathering and repetitive tool calls while the developer keeps control of scope, permissions and the final review.

Autonomy checklist

  • Can you stop the run immediately?
  • Are file edits shown as diffs before they are accepted?
  • Do terminal and network tools require approval?
  • Are API keys scoped to a single provider and spend limit?
  • Can you restore the workspace with Git or a checkpoint?
  • Is the agent limited to the workspace it was given?

Related guides

Try Bytos in VS Code

Bytos is an open-source, bring-your-own-key AI coding agent for Visual Studio Code. It plans first, asks before risky actions, and keeps your provider key in VS Code SecretStorage.

FAQ

Are autonomous coding agents safe?

They can be useful, but they are not risk-free. Safety depends on approvals, sandboxing, key permissions, review and rollback. Treat a new agent like a new contributor with limited access.

Do I need a fully autonomous agent?

Most developers do not. A supervised plan-and-execute agent often captures most of the value while keeping a human checkpoint before risky actions.

Is Auto Phase a multi-agent system?

No. Bytos Auto Phase is sequential: phases run one after another. It is not a parallel multi-agent swarm.

Sources and verification

Product details change. This guide was reviewed on 11 November 2026 against the linked official documentation; verify current features, pricing and licensing before choosing a tool. No benchmark scores or independent performance claims are used here.