Your backlog used to be a list you and a few teammates pulled from. You read the top item, you understood it, you did it. Triage was quick because the only question was “who has time?” Now some of those items can be picked up by a coding agent instead of a person, and the calm queue turns into a source of small, expensive mistakes: an agent starts on a task nobody finished writing, two agents grab overlapping work, and a “done” column fills with output no one asked for.
The problem isn’t the agents. It’s that a backlog built for humans quietly changed jobs. It stopped being a to-do list and became a dispatch queue that can launch execution. Once a line item can trigger real work, the moment you move a task and the moment you decide who owns it carry consequences they never used to.
This is the layer Sharkly sits in. You already have coding agents; Sharkly turns them into a team by giving the backlog a shared meaning. A Task is the main unit of work, Backlog is where uncommitted work waits, and Triage is a dedicated intake queue where incoming items sit until someone decides. This article walks through how to triage a mixed human-agent backlog without those queues turning into chaos, and ends with a checklist you can run today.
What backlog and triage mean once agents can do the work
Two definitions do most of the work here, so get them precise.
A backlog is the set of uncommitted work: tasks that exist but that no one has decided to start yet. Triage is the intake decision made on new or unclear items: accept it, decline it, mark it a duplicate, or snooze it until later. Humans have always done both informally. The change is that in a human-agent team, the outcome of triage now includes “which agent runs this,” and the act of committing a task can start a run.
Here’s the boundary that trips people up first: assigning an Agent to a task in Backlog does not start it. Backlog is a parking area where work gets prepared before execution. The run begins only when the task leaves Backlog for a status that’s ready for work, and a Computer and Runtime are available. So “assign the agent” and “start the agent” are two separate events, with the backlog status sitting between them as a gate.
One more boundary worth stating plainly: agents don’t keep a private backlog. There’s no hidden queue an Agent grinds through on its own. Every item an Agent will touch lives in the shared board, which is what makes triage possible instead of guesswork.
Where a DIY setup stops scaling
A spreadsheet plus a Kanban board plus a few terminals works fine for one person and two agents. It stops scaling at predictable points, and each one shows up as a specific failure.
The status column means nothing to the agents. On a manual board, moving a card to “In Progress” is a note to your teammates; nothing executes. So the board and the real work drift apart: a card says “In Progress” while the agent finished an hour ago, or “To Do” while an agent is already three commits deep because someone kicked it off in a terminal. Nobody trusts the board, so nobody uses it.
Triage decisions live in one person’s head. Whoever fields incoming requests remembers that a bug was already reported, that a feature was declined last quarter, that a task needs design input first. When that person is out, duplicates get created and agents start work that should have been declined at intake. The queue has no memory.
Assignment and scope get decided in the same rushed moment. Vague scope is survivable when a human picks up a task and asks a question. An agent doesn’t pause to ask; it runs on whatever you gave it and returns a confident, wrong result. The cost of thin triage moved from “a teammate is briefly confused” to “an agent burned a run and a review cycle on the wrong thing.”
Triaging a mixed backlog, step by step
Here’s the sequence that keeps a human-agent backlog honest. Each step names the failure it prevents.
1. Clear the intake queue before touching the backlog. New requests land in Triage, not straight into the backlog. Work each item with one of four decisions: accept, decline, mark duplicate, or snooze. Triage is an intake queue, not a saved filter and not a form builder, so the decision is explicit and recorded. Failure it prevents: declined and duplicate work quietly becoming real tasks that an agent later picks up.
2. Shape the task before it’s eligible for an agent. An accepted item becomes a Task, but it stays in Backlog while you write acceptance criteria, attach the repository, and note constraints. This is the step people skip under time pressure. Failure it prevents: an agent running on a one-line title and returning output that technically matches the words and misses the intent.
3. Decide the assignee, and treat “which agent” as a real choice. Some tasks want a human. Some want an agent, and among agents the right one depends on the task: a refactor, a test-writing pass, and a docs update aren’t the same job. Route deliberately instead of defaulting to whatever agent is idle. Our routing guide for coding agents covers how to make that call. Failure it prevents: the wrong runtime chewing through a task it’s poorly suited for.
4. Keep it in Backlog until it’s genuinely ready. This is the gate. A task can be fully assigned and still sit in Backlog with no run starting. Use that. Don’t move it out until the scope is set and you actually want work to begin. Failure it prevents: a half-written task launching a run because someone dragged it to the wrong column.
5. Commit it, and let the run start. Move the task to a ready status, or pull it into a Sprint. When a task with a ready Agent leaves Backlog and a Computer and Runtime are available, execution begins. Now the status change and the work are the same event, which is the whole point.
For teams running cycles, Sprint planning for human-agent teams shows how the same commit step scopes a time box instead of a single task.
The backlog status becomes an execution gate
The mental shift is this: on a human board, status is a label describing reality. On a human-agent board, status is a lever that changes reality. Moving a task out of Backlog is the action that starts the agent, so your triage discipline is now your safety mechanism.
That gate is also where the human-agent contract belongs. Agents research, execute, test, and report. People decide what enters the backlog, what gets committed, and what ships. Automation stops where team judgment is required. The Plan view keeps the Backlog, Sprints, and Projects in one place so the commit decision is visible rather than buried in a terminal, and execution, blockers, results, and review all return to the Task instead of scattering across private sessions.
This is why backlog hygiene matters more with agents, not less. A messy human backlog is just clutter. A messy agent backlog is clutter that occasionally runs itself. The board keeps context, ownership, progress, results, and human review visible from intake to release, which is the difference between a queue you manage and a queue that manages you. When review piles up rather than intake, that’s a different bottleneck, covered in why human review is the real constraint.
You can run this with a spreadsheet and manual discipline if your volume is low. If you’re already fielding steady intake and running several agents, Sharkly gives you the Triage queue, the Backlog gate, and one shared board so those decisions stop living in your head. For a wider view of the same workflow, see our guide to AI agent task management and the difference between Triage and your personal Inbox.
A triage checklist you can run today
Run this against your current board. Every “no” is a place agents will surprise you.
- Do new requests land somewhere before the backlog? If intake goes straight to “To Do,” you have no accept/decline/duplicate step and duplicates are inevitable.
- Is every backlog task’s scope good enough to hand a stranger? If it isn’t good enough for a new hire, it isn’t good enough for an agent.
- Does moving a task actually start anything? If your status changes are just labels, the board and the work will drift apart.
- Is assignment a real decision, including which agent? Defaulting to the idle agent is not routing.
- Can you tell, right now, what each agent is working on and what’s waiting for review? If that answer lives in someone’s memory or a terminal scrollback, triage has no shared source of truth.
- Does finished work return to the task, not to a private session? Results, blockers, and diffs belong on the shared record so review has something to act on.
Fix the first two before you scale the number of agents. A clean intake step and honest task scope prevent most of the expensive failures; everything else is refinement on top of a backlog that already means something.
