Agentic coding ships the 80%. Your tracker holds the other 20%.

Agentic coding is a way of building software where an autonomous AI agent takes a high-level instruction and plans, writes, tests, and revises the code with little step-by-step human input. Unlike an inline assistant that waits for you to type and then completes the line, an agent runs a loop: it decides what to do next, does it, checks the result, and corrects itself, until the task is done or it gets stuck. Claude Code, Codex, Cursor's agent mode, and Gemini's coding agent are all versions of the same idea.

That loop is genuinely fast, and it is why the term went from niche to everywhere in a year. It is also why a specific gap keeps showing up in the discussion: the agent reliably produces roughly the functional 80% of a working change, and the remaining 20%, the part that has to be right for the work to actually be done and remembered, does not live in the code the agent just wrote. This post is about where that 20% should go.

#The 80% problem, stated plainly

If you search "agentic coding," one of the first questions Google surfaces is "what is the 80% problem in agentic coding?" The short version people have converged on: agents ship the working majority of a change quickly, and the hard, compounding remainder, the error handling, the security edges, the "why did we do it this way," the coordination between the change and everything else in flight, is where the debt accumulates when nobody captures it.

Notice that most of that remainder is not more code. It is context and decisions. Which approach was chosen and why. What was ruled out. What the agent noticed on its way through that nobody asked it to fix. Which of three parallel agents already touched this module. That information is real work product, and by default it lives in exactly one place: the context window of the session that produced it. When the window fills and compacts, or the session ends, it is gone. The code survives; the reasoning behind it does not.

So the 80% problem is not really "agents write sloppy code." It is that the fast part and the durable part have different homes, and agentic workflows are very good at producing the fast part and very bad at persisting the durable part.

#Where the durable 20% should live

The cheapest durable unit for the 20% is an issue. Not a document, not a chat log, an issue: it has an owner, a status, a priority, and a comment thread, and it sits outside the model entirely, so it survives every context reset by construction. When an agent opens an issue for the work, comments on it as it makes decisions, and closes it with a note when the change lands, the reasoning stops being a casualty of the next auto-compact. The next session, or the next agent, reads the current state instead of reconstructing it from a summary that got squeezed out.

This is also the piece that lets more than one agent work at once without stepping on each other. A developer in a recent r/github thread described building the missing layer by hand: a single local API for the full issue lifecycle so that, in their words, "the agent never polls GitHub, it just checks local state and the sync layer handles the rest." That instinct is exactly right. The agents need one fast place to read and write the state of the work, separate from any one session's memory. The only question is whether you hand-roll it or point at one that already exists.

Radial is that record, built so agents can drive it directly. It is a fast issue tracker with a real CLI, a plain REST API, and an MCP server, all against the same issue lifecycle, so however your agent reaches it, it reads and writes the same state. Here is the loop an agentic coding session runs against it, using the CLI (every command takes --json, so the output pipes straight into the next step):

# The agent reads what's assigned to it, in progress, as structured JSON
radial list --assignee me --status "in progress" --json

# It makes the change, then closes the issue with a note the next session can read
radial close RAD-482 -m "Chose optimistic locking over a mutex; ruled out the queue approach, added in #611."

# It spotted a second problem on the way through, so it files that too
radial create "Token refresh retries on 401 instead of re-auth" -t ENG -p high -l bug -a me --json

Nothing in that loop is specific to one agent. The same three verbs run from a REST call in CI, from the MCP server a different agent is connected to, and from your own terminal, all against one shared record. The 80% (the code) ships however it ships; the 20% (the decisions, the follow-ups, the state) is now written down where it outlives the session.

#Why this is a tracker, not an AI feature

There is a line here worth being precise about. Radial does not read your code, summarize your diffs, or try to be a smarter memory layer for your agent. It is a fast issue tracker that agents happen to be able to drive over CLI, REST, and MCP, and the durable record is a side effect of agents filing and updating issues the normal way, not an AI feature bolted on top. The intelligence stays in your agent, your model, your keys. Radial holds the record.

That is deliberate, and it is binding. There is no copilot in the product, no auto-summary, no AI triage, and no AI credit meter, because your agent already does the thinking and you already pay for it once. The Plain Software Pledge is the enforceable version: the day Radial ships a copilot, meters your usage, or charges you for AI you didn't ask for, your subscription is free.

And because every agent credential is an API client, not a billed seat, running a fleet of coding agents against Radial costs nothing extra. The price is $50 per user, per year, flat, billed annually, for the humans on the workspace, locked at the rate you join. Ten agents writing to the same tracker is still just the humans. Agents ride free; that is the structure, not a promotion.

#FAQ

#What is agentic coding?

Agentic coding is a software development approach where an autonomous AI agent plans, writes, tests, and modifies code from a high-level instruction, with minimal human intervention. Instead of completing a line you are typing, the agent runs its own loop: it decides the next step, executes it, checks the outcome, and self-corrects until the task is done. Claude Code, Codex, and Cursor's agent mode are common examples.

#What is the 80% problem in agentic coding?

It is the gap between the functional majority of a change that agents produce quickly (roughly 80%) and the durable remainder (the error handling, the security edges, the decisions, and the coordination) that compounds into debt when it is never captured. Much of that remainder is context and reasoning, not code, and it disappears when a session's context window compacts or ends unless it was written down somewhere outside the model.

#How is agentic coding different from vibe coding?

Vibe coding is prompt-driven and exploratory: you describe what you want and iterate on the output by feel. Agentic coding is outcome-oriented and self-directed: the agent runs a plan-act-check loop toward a defined result and corrects itself along the way. In practice the two blur, but the agentic version produces more work product (decisions, follow-ups, state changes) that needs a durable home.

#Where should an AI coding agent record its work?

In an issue tracker it can drive directly, so the record survives context resets and hands off cleanly to the next session or agent. An issue is a cheap durable unit: owner, status, priority, and a comment thread, all outside the model. Point your agent at Radial's CLI, REST API, or MCP server and it can read its queue, file issues, comment as it decides, and close them when done. See give Claude Code access to your issue tracker in 5 minutes for the MCP setup.

#Does running multiple coding agents against Radial cost more?

No. Agent credentials are API clients, not billed seats. You pay $50 per user, per year, for the humans on the workspace, locked at the rate you join, and a fleet of agents writing to the same tracker adds nothing to that.

#The short version

Agentic coding ships the functional 80% fast, and the durable 20%, the decisions, the follow-ups, and the coordination, is context, not code. By default that context dies with the session's memory. Give your agents one durable record they drive over CLI, REST, and MCP, and the reasoning behind the work outlives the window that produced it.

See the full tool list and the CLI verbs on the developers page, or read your Claude Code sub-agents keep losing the thread for the multi-agent version of the same argument.