Guide
AI Coding Agents in Project Management: How to Run Them From Your Board
By the Fairlx team · Updated · 11 min read
Short answer
An AI coding agent takes a ticket, plans the change, writes code in an isolated sandbox, runs checks and opens a pull request for a person to review. Run it from your board: write tickets with acceptance criteria, approve the plan, review the preview and the diff. Fairlx includes this loop in the $8 Plus license with 6,000 credits; Jira and Linear offer coding agents metered by separate credits.
What is an AI coding agent?
An AI coding agent is a language model that can work on a codebase in a loop: read the task, explore the repository, plan a change, edit files, run commands and tests, look at the result and keep going until the task is done or it needs a person. That loop is what separates it from autocomplete or a chat assistant. An assistant suggests code for you to paste; an agent produces a branch and a pull request.
Most coding agents now run in the cloud. Each task gets its own sandbox — a container or VM with the repository cloned and dependencies installed — so the agent can run the app and its tests without touching anyone's machine or production.
Why run coding agents from the project board?
You can start an agent from an IDE, a chat window or the command line. Starting it from the board means the ticket becomes the brief and the board becomes the record: everyone sees which items an agent owns, what it planned and where it waits for a person, and sprint reports keep working because agent work moves through the same statuses.
- Context comes free. The description, acceptance criteria, comments, linked epic and linked repository are already on the item.
- Approvals live in the workflow. A plan approval or a review is a step on the item, visible to the team, not a message in someone's private chat.
- Results map to work. The agent's pull request is tied to the item it was assigned, so you judge output per ticket, not per chat session.
How does an AI coding agent work, from ticket to pull request?
The details differ between products, but a safe loop has the same shape everywhere: ticket → plan approval → sandbox → preview → checks → pull request → human review. Here is what each step should do.
| Step | What happens | Who decides |
|---|---|---|
| 1. Ticket | A work item with a goal, scope and acceptance criteria is assigned to the agent | A person assigns it |
| 2. Plan | The agent reads the item and the repository and proposes which files it will change and how | A person approves or edits the plan |
| 3. Sandbox | An isolated environment is created, the branch is cloned and dependencies are installed | Automatic |
| 4. Preview | The app starts and a preview link lets people see the change running | Anyone with the link can look |
| 5. Checks | Tests, linters and browser checks run; failures are fixed and re-run in the same sandbox | Automatic, visible on the item |
| 6. Pull request | The agent pushes its branch and opens a pull request linked to the item | Automatic once the plan was approved |
| 7. Review and merge | A person reviews the diff, comments, requests changes or merges | A person, unless you opt into auto-merge |
The loop in Fairlx, step by step
Here is how the same loop runs in Fairlx on the Plus plan, described from the product itself.
- Assign. You assign a work item to the agent on the board, or start the same coding session from Slack with
/fairlxon a licensed Plus seat. - Approve the plan. The agent proposes a plan. Nothing is implemented until you approve it.
- Sandbox. Fairlx creates an isolated cloud VM, clones the GitHub branch into
/workspace, installs dependencies and starts the dev server. Shell commands run inside the sandbox, not on the Fairlx host. - Live preview. The preview URL can be reserved early and becomes shareable once the health check passes. You can look at it as a desktop or as a phone. If the page is up but showing a compile error, the session stays open so the agent can fix it.
- Checks and self-healing. The agent runs project commands and browser checks, including Playwright. When a check fails, it changes the code and runs again in the same VM. When the preview throws a compile or runtime error — a font import or a missing build chunk — it edits the source and Fairlx restarts the dev server without destroying the VM, so uncommitted work stays.
- Pull request. The agent opens the pull request from the sandbox branch. Other privileged GitHub writes wait for you to Accept.
- Review Studio. Each project's inbox lists open, draft, merged and closed pull requests. You approve, request changes or comment on a single line of the diff. The diff can be the pull request, the live sandbox including uncommitted files, or any two branches, unified or side by side.
- Merge. A merge waits until the pull request is open, not a draft, has no conflicts, no open change requests, and checks are in. You squash, merge or rebase from Fairlx. Merges wait for a person unless the agent runs Autonomous with Auto Merge on.
You cannot approve your own pull request on GitHub, so a teammate reviews the agent's work. The personal agent can hand parts of a task to specialist workers — planner, builder, reviewer — and skills, saved instructions the agent can load, encode team conventions once. See AI features and GitHub integration.
How do you write tickets an AI agent can finish?
Agents fail on the same tickets people find frustrating: vague goals, hidden context, no definition of done. A person asks; an agent may guess. Good agent tickets are simply good tickets, written down.
- One outcome per ticket. Fix this bug, add this field, upgrade this dependency. Split anything that touches several features.
- Acceptance criteria as checks. Write them so they can be verified: Given a user with no projects, the dashboard shows the empty state with a Create project button.
- Reproduction steps for bugs. Steps, expected result, actual result, and the error message or log line if you have it.
- Scope and boundaries. Name the area of the code if you know it, and say what must not change: no schema changes, no new dependencies, keep the public API.
- How to verify. The command to run, the page to open in the preview, the test file that should cover it.
- Links, not memory. Link the design, the related item, the earlier pull request. The agent cannot read your mind or last week's meeting.
| Weak ticket | Agent-ready ticket |
|---|---|
| Login is broken on mobile | On a 375 px wide viewport, the Sign in button on /login sits under the footer and cannot be tapped. Expected: button visible above the fold. Repro: open /login in the phone preview. Do not change the desktop layout. Done when a Playwright check at 375 px taps the button. |
| Add export | Add a CSV export button to the Timesheets table. Columns: date, person, work item key, hours. Respect the current filters. No new dependencies. Done when the downloaded file matches the visible rows. |
Start with work where success is easy to check: bugs with repro steps, small UI and copy changes, test coverage, dependency bumps, lint and type fixes. Leave architecture, ambiguous product decisions and anything touching billing, auth or data migrations to people, or to plans a senior engineer reviews closely.
Are AI coding agents safe? Guardrails that matter
An agent with a shell and write access to your repository deserves the same care as a new contractor with the same access. These are the guardrails to require, whichever tool you use:
- Isolated sandboxes. Code runs in a throwaway VM or container per task, never on your servers or a shared machine. In Fairlx, shell commands run in the sandbox, not on the Fairlx host.
- A plan approval gate. You see and approve the approach before code is written. It is the cheapest place to catch a misunderstanding.
- Human review before merge. Keep branch protection on. Do not let an agent merge its own work unless you have deliberately chosen that for a low-risk project; in Fairlx, auto-merge is off unless you run the agent Autonomous with Auto Merge on.
- Least-privilege access. The agent should act with the permissions of the person or role that assigned it, and privileged writes — beyond its own branch and pull request — should wait for approval.
- Secrets kept out of the prompt. Give the sandbox only the environment variables it needs, never production credentials. Tokens for tools the agent calls should stay server-side; in Fairlx, MCP server tokens stay on the server card and are not written into the page.
- A visible record. Every plan, command, check and diff should be on the work item so the team can audit what happened.
See how Fairlx handles access and data on the security page.
How much do AI coding agents cost?
Coding agents spend model tokens while they read code, plan and iterate, and some vendors also charge for sandbox time. The three trackers with built-in coding agents price this in different ways:
| Fairlx Plus | Linear | Jira Standard | |
|---|---|---|---|
| Seat | $8 / license / month | $12 / user / month on Basic ($10 annual) | $9.70 / user / month for up to 100 users |
| AI allowance | 6,000 credits per license, included in the seat | Linear Agent on every plan; coding sessions use a separate prepaid balance | 25 Rovo credits per user a month |
| How agent work is metered | 1 credit = $0.001 of model list cost, no token markup; smallest bill 0.1 credit | Tokens at provider rates, no markup, plus $0.25 per 20-minute sandbox block | Jira Coding Agent and Rovo agents spend Rovo credits |
| When the allowance runs out | The agent pauses until the next billing date; boards, sprints and docs keep working; nothing billed on top | Top up the prepaid balance | Governed by the Rovo credit grant |
Fairlx's unit is simple to reason about. Because a credit is $0.001 of the model's list price, 6,000 credits equal $6 of model usage per license each month, and a turn whose model calls cost $0.40 at list price spends 400 credits. On the free Normal plan, personal accounts get 500 credits a month on DeepSeek V4 Flash; the agent can plan, answer and code through the GitHub API, but there is no sandbox live preview or agentic coding session.
With Linear, the bill has two parts: tokens at provider rates and sandbox time in 20-minute blocks at $0.25 each, paid from a prepaid balance separate from seats. With Jira, the coding agent draws from the same Rovo credit grant as other Rovo agents, so heavy coding use competes with everything else Rovo does. Compare the full plans on Fairlx pricing, Fairlx vs Linear and Fairlx vs Jira.
How do you measure whether an AI coding agent is working?
Judge an agent like any contributor, on the work that ships, not on demos. Track these per sprint in a small pilot:
- Merge rate: the share of agent pull requests merged, and how many needed only small changes in review.
- Review time: how long a person spends reviewing an agent pull request compared with a human one of similar size.
- Rework and reopen rate: how often agent-closed items come back as bugs.
- Cost per merged pull request: credits or tokens spent divided by pull requests that shipped.
- Plan rejection rate: how often you reject or rewrite the plan — a signal that tickets need better acceptance criteria.
Because agent work moves across the same board, Fairlx's reporting on sprint points, velocity and workload lets you compare sprints before and after the pilot with your own numbers.
Which AI coding agent should you use?
1. Fairlx+ (Fairlx Plus)
- Best for:
- Teams that want the agent, the board and code review in one tool, priced into the seat
- Pricing:
- $8 / license / month with 6,000 credits included. Free personal plan without sandbox.
Assign a work item, approve the plan, and the agent codes in an isolated cloud VM with a live preview, runs checks including Playwright, self-heals preview errors and opens a pull request you review in Review Studio.
Strengths
- Whole loop on the work item: plan, sandbox, preview, checks, pull request, review and merge
- AI credits included in the seat; agent pauses rather than overbilling
- Skills, a delegating personal agent, Fairlx MCP plus your own HTTP MCP servers, Slack
/fairlx
Trade-offs
- In beta; one GitHub repository per project
- No one-click import from Jira, so moving your backlog takes some setup
- Free plan has no sandbox; organizations start on Plus
2. Jira Coding Agent
- Best for:
- Teams already running Jira and Atlassian who want an agent inside their existing tracker
- Pricing:
- Jira Standard $9.70 / user / month (up to 100 users); the coding agent uses Rovo credits (25 per user a month on Standard).
Atlassian's coding agent runs in a cloud sandbox on Jira Standard and spends Rovo credits. If your question is how to assign a Jira ticket to an AI agent without leaving Jira, this is the native answer, alongside Rovo agents and the Rovo MCP Server.
Strengths
- Native to Jira workflows and permissions
- Part of the wider Rovo and Atlassian ecosystem
Trade-offs
- Shares a pooled Rovo credit grant with other AI use
- Rovo is off on Jira's Free plan
3. Linear coding sessions
- Best for:
- Linear teams who want agent coding on any plan, paid as they go
- Pricing:
- Basic $12 / user / month ($10 annual). Coding: tokens at provider rates plus $0.25 per 20-minute sandbox block, prepaid.
Linear Agent is on every plan, Free included, and coding sessions run in a sandbox paid from a separate prepaid balance. Linear also lets you route issues to third-party coding agents.
Strengths
- Available on every plan, including Free
- No markup on provider token rates
Trade-offs
- Separate balance to fund and watch
- Free plan stops at 250 issues and 2 teams
4. GitHub Copilot coding agent
- Best for:
- Teams that plan in GitHub Issues and want the agent next to the code
- Pricing:
- Included with paid Copilot plans; see GitHub's pricing page.
You assign a GitHub issue to Copilot; it works in an ephemeral cloud environment, pushes a branch and opens a draft pull request for review, subject to your repository's protections.
Strengths
- Lives where the code and CI already are
- Uses normal branch protection and review
Trade-offs
- Planning, sprints and reporting are light compared with a full agile tool
- Billing follows Copilot plans, separate from your tracker
5. Cursor background agents
- Best for:
- Developers who live in the Cursor editor and want to hand off tasks to run in the cloud
- Pricing:
- Usage follows Cursor's plans; see Cursor's pricing page.
Cursor's background agents run tasks in remote environments on their own branch while you keep working, and can be started from the editor and from connected tools. They are developer-centric: great for a single engineer's queue, with planning left to whatever tracker you use.
Strengths
- Tight loop with the editor developers already use
- Good for parallel, developer-driven tasks
Trade-offs
- Not a project management tool; the board lives elsewhere
- Team-level visibility depends on your tracker integration
How to roll out an AI coding agent in your team
- Pick one project with good tests. Agents verify their work with your checks; weak test coverage means more review effort.
- Write a short skill or contributing note. Conventions, commands to run, folders to avoid. In Fairlx, save it as a skill the agent can load.
- Label agent-eligible work. Tag five to ten well-scoped bugs and small features in the backlog and rewrite them with acceptance criteria.
- Keep human review on. Run the first sprint with plan approval and manual merge for everything.
- Review the numbers after one sprint. Merge rate, review time, rework and cost per merged pull request decide whether to widen the scope.
- Expand gradually. More ticket types, more projects, and only then consider auto-merge for low-risk repositories.
Frequently asked questions
Can I assign a Jira ticket to an AI agent?
Yes. Atlassian's Jira Coding Agent runs in a cloud sandbox on Jira Standard and spends Rovo credits (25 per user a month on Standard). Third-party agents can also connect to trackers. In Fairlx you assign a work item to the agent directly, approve its plan, and it opens a pull request.
What is the difference between an AI coding assistant and an AI coding agent?
An assistant suggests code inside your editor or a chat, and you apply it. An agent takes a task, works in its own environment, edits files, runs commands and tests, and delivers a branch or pull request for review.
Will an AI coding agent merge code without review?
Not if you keep the gates on. Good setups require plan approval and human review before merge. In Fairlx, merges wait for a person unless you deliberately run the agent Autonomous with Auto Merge on.
How much does it cost to run an AI coding agent?
It depends on the vendor's metering. Fairlx Plus includes 6,000 credits per $8 license, at 1 credit = $0.001 of model list cost. Linear charges tokens at provider rates plus $0.25 per 20-minute sandbox block from a prepaid balance. Jira's coding agent uses Rovo credits, 25 per user a month on Standard.
What tasks are AI coding agents good at?
Well-scoped work with clear success checks: bugs with reproduction steps, small features with acceptance criteria, UI and copy fixes, test coverage, dependency upgrades and lint or type errors. Architecture changes and ambiguous product decisions still need people.