Skip to content

Core Concepts

Autonomous Coding Agent is currently in beta. The service is usable, but teams should expect changes while the product, onboarding process, and supported workflows continue to evolve.

During the beta phase:

  • Features and user flows may change.
  • Some errors may require support investigation.
  • Agent behavior may not be fully predictable in every repository.
  • Documentation may lag behind the latest implementation.
  • Teams should start with small, well-scoped tasks before using the agent on more complex work.

Treat the agent as a development assistant, not as an unattended replacement for engineering review.

Agent

An agent is an AI software engineering assistant. It can read task context, inspect code, make changes, run commands, and report what it did.

Different agents can have different specialities. Default agents are provided for common use cases, such as fixing audit findings or vulnerabilities. Teams can also create their own agents from scratch or by using a provided template. Use the chat client to create and configure team-specific agents.

Run Modes

The agent can run in two modes.

Interactive Runs

When started from the chat client, the agent runs interactively. Users can provide context, answer questions, clarify the request, and continue the conversation while the agent works.

This mode is useful when the task is exploratory or when the agent may need more information before making changes.

Autonomous Runs

When triggered from Jira, the agent runs autonomously. The Jira automation rule sends the request to the agent, and the agent works from the Jira issue context and the initial prompt provided by the automation.

This mode is useful for repeatable workflows, such as asking the agent to process a ticket when a comment or status change matches the team's automation rules.

Workspace

Each agent run happens in a dedicated container. The container is created for the task and provides an isolated workspace where the agent can inspect files, clone repositories, create branches, and run commands.

If a Jira issue mentions GitHub repositories, and the team has granted access to those repositories during onboarding, the agent can clone them into the container.

Jira Context

The agent can read the Jira issue that triggered the task and follow the instructions written there.

If you want the agent to run tests, build the project, follow a specific workflow, or use a particular branch naming convention, put that instruction in the Jira ticket or in the automation prompt.

Jira access is performed through a technical user with read-only access to issue content. The technical user can also leave comments so the agent can report status or results back to the ticket.

GitHub Work

When the task requires repository changes, the agent can:

  • Clone approved repositories into its container.
  • Create a branch.
  • Commit code changes.
  • Create a pull request for human review.

The agent can create branches and pull requests, but it should not be treated as an actor that owns merging or releasing changes.

Teams must protect important branches, such as master, main, default branches, and release branches. At minimum, protect them from deletion and require pull requests and approval before merging.

Task

A task is the work you ask the agent to perform. Good tasks are specific, bounded, and verifiable.

Good task instructions usually include:

  • The Jira ticket or business context.
  • The repository or component involved.
  • The expected behavior or acceptance criteria.
  • Tests or checks the agent should run.
  • Any constraints the agent should respect.

Large or ambiguous tickets should be split into smaller tasks before assigning them to the agent.

Verification

Verification is the set of checks used to confirm the task was completed correctly. Examples include tests, builds, linters, type checks, or manual review steps.

The agent can install dependencies and run tests inside its container when the repository allows it. If a specific test command should be used, include it in the Jira ticket or chat request.

If the agent cannot run a verification step, users should review the reason and run the required checks manually before merging the work.

Ownership And Review

Autonomous Coding Agent should be treated as a collaborator. Users remain responsible for reviewing changes before merging or deploying them.

Developers own the code created with help from the agent. The agent can prepare changes and open a pull request, but the team is still responsible for:

  • Reviewing the diff.
  • Checking that the implementation is correct.
  • Confirming tests and builds pass.
  • Ensuring security, compliance, and coding standards are met.
  • Deciding whether the pull request should be merged.