From Prompts to Persistent AI Coding Agents
Long-running AI agents are autonomous software systems that can execute coding tasks for hours or days, preserve their working state, verify their own output, and decide when to stop without constant human prompts or supervision. The important shift is not that AI can write code; it is that AI coding agents now sit inside continuous workflows, waking up, doing work, and shutting down on their own. Anthropic’s Claude Code agents no longer behave like one-off assistants; they operate as teams of cooperating instances that prompt each other, review pull requests, scan for security issues, and leave developers to wake up to completed work instead of empty terminals. For developers, that means the center of gravity has moved from crafting prompts in an IDE to designing autonomous developer workflows that run while they sleep.
Anthropic’s Claude Code Loops: Thousands of Agents, One Human in the Loop
Anthropic engineers are treating Claude Code agents as an operational fleet, not a single chatbot. Boris Cherny says he has not written a line of code by hand in roughly eight months, and that Claude Code is now fully written by Claude Code. On busy days he manages thousands or even tens of thousands of Claude Code agents, while on quieter days the count still runs into the hundreds. The key innovation is loops: recurring agent runs with a trigger, a task, a verification step, and a clear reason to stop. These loops can run tests, inspect real environments, compare screenshots, or prove that a pull request satisfies a defined goal; when they can do that, you no longer have a prompt, you have a workflow. Anthropic reports an eightfold increase in code output by one internal measure, but stresses that raw code volume is an imperfect proxy for value.
This approach attacks the real bottleneck: human review. Modern coding agents already generate code quickly, especially after releases like Claude Opus 4.5; the slower part is checking that the implementation matches specifications. By designing loops where teams of agents review other agents’ code and look for bugs from different perspectives, Anthropic turns verification into AI agent automation instead of a late-stage human chore. That reshapes the developer role. You stop being the person who types every function and become the person who defines the finish line, inspects the evidence, and decides when a machine-written change deserves to ship.
Perplexity’s SPACE Runtime: Infrastructure for Long-Running AI Agents
The missing piece for long-running AI agents was reliable infrastructure: a place where agents could run for hours, days, or months without losing state or leaking secrets. Perplexity’s SPACE runtime, the Sandboxed Platform for Agentic Code Execution, is built exactly for that. It supports long-running AI agents that execute code, edit files, and complete multi-step tasks over extended periods. Each task runs inside a disposable Firecracker microVM with its own guest kernel, keeping untrusted workloads isolated from the host and from other tenants. When the work ends, the microVM is destroyed, but rolling snapshots preserve memory and files so sessions can pause, resume, or branch across sandboxes without losing context.
SPACE is opinionated about persistence: it offers pausing, resuming, suspension, restoration, rollback, forking, and crash recovery as first-class features. Disk snapshots track filesystem changes, full snapshots capture the paused virtual machine, and suspended sessions are uploaded to object storage so another node can restore agents with their previous state intact. Under the hood, the storage layer uses btrfs with copy-on-write cloning and atomic snapshots, keeping startup times low while containing resource usage. The platform also keeps credentials outside the sandbox, injecting them at the network layer or via a browser agent, and allows enterprises to use their own encryption keys. This is what long-running AI agents needed: a runtime that treats them more like persistent applications than fragile chats.
Jira’s AI Coding Agents: Centralizing Autonomous Developer Workflows
While Anthropic and Perplexity focus on engines and runtimes, Atlassian is betting that the future of autonomous developer workflows lives inside the project management stack. It acknowledges that developers dislike interacting with Jira and wants them to spend more of their day there instead. To make that plausible, Atlassian has launched AI-centric features that embed AI coding agents directly into the software development lifecycle. Teams can assign Jira work items to Claude Code, Cursor, or GitHub Copilot, with OpenAI’s Codex coming in a later phase. A built-in Jira Coding Agent, included in every paid plan, can turn work items into pull requests without any developer setting up a local environment. Jira for Slack lets people create work items by talking to @Jira inside chat threads, and automation rules can route bug fixes, vulnerability remediation, and test generation to agents in the background.
This is an attempt to centralize AI agent automation around the ticket, not the IDE. The new Jira Planner mines Jira and Confluence history plus team context to generate technical specs in Confluence, linking planning, coding, and review in one loop. Atlassian says that among its 6,000 internal engineers, the new capabilities produced a 44% boost in agent task completion efficiency, a 48% drop in token consumption, a 36% reduction in pull request cycle time, and 51% of routine code vulnerabilities resolved autonomously and queued for review. Codebase context support is also planned, with coverage across multiple source control systems. There is no long-term roadmap; Atlassian plans work in quarters, with six months as an upper bound before plans become guesses. Whether developers will agree to “live” in Jira is unclear, but the company is reshaping the tool into a control room for AI coding agents.
Why Developer Work Will Feel More Like Orchestration Than Coding
Taken together, long-running AI agents, SPACE-like runtimes, and ticket-centric AI coding agents are changing what “being a developer” looks like. The shift is from manual prompts to autonomous agent systems where Claude instances prompt other Claude instances, verify each other’s work, and keep multi-hour or multi-day tasks moving without human intervention. On the infrastructure side, persistent sandboxes maintain agent memory and files while isolating risky code, so these workflows can extend over days or even months. On the tooling side, Jira pushes work from chats and backlogs straight into AI agents, which in turn create pull requests, specs, tests, and vulnerability fixes in the background.
This is not magic; it is a deliberate response to the new bottleneck. After the release of powerful coding agents, the slowest part of development has become human review, not code generation. Best practice is already shifting toward long-running agents that have the permissions they need, verify their own work, and review the code they or their peers write. In the ideal setup, you only perform human code review for the most critical parts of your application. The practical impact for ordinary teams is that hands-on coding time drops, while the importance of defining goals, constraints, and stop conditions rises. The new skill is not writing the perfect prompt; it is designing loops and environments where long-running AI agents can do useful work without getting in your way.
