Atlassian’s stock is down 70% in 12 months. Revenue grew 23%. They crossed $1B in cloud revenue for the first time. By every traditional metric, they’re executing.

The market doesn’t care.

The Signal in the Stock Price

Investors aren’t punishing Atlassian for bad results. They’re pricing in a future where the humans who need Jira seats are replaced by agents that don’t. The per-seat SaaS model depends on humans sitting in chairs clicking buttons. When the chairs empty, the revenue disappears.

CEO Mike Cannon-Brookes addressed it directly in his February shareholder letter:

You’ve heard me say AI is the best thing to happen to Atlassian. At the same time you’ve probably heard a lot of people say SaaS is over, and software is dead.
— Mike Cannon-Brookes, Atlassian CEO (Feb 2026)

That’s not confidence. That’s damage control. When the CEO of a $40B company is explicitly rebutting “software is dead” in a shareholder letter, the narrative has already won.

Late January, the S&P 500 software and services index dropped 3.1% in a single day. Roughly a trillion dollars in market value evaporated. The thesis: AI agents reduce headcount, fewer heads need fewer seats, fewer seats mean less revenue. Atlassian isn’t unique here. They’re just the canary.

Ceremonies for a Different Era

Think about what Jira and Agile ceremonies actually solve:

  • Standups exist because humans forget context overnight. Agents don’t. They pick up exactly where they left off.
  • Sprint planning exists because humans can’t estimate. Agents work until done.
  • Retros exist because humans repeat mistakes. Agents can be patched, given guardrails, or constrained by spec.
  • Confluence exists because humans can’t hold enough context. Agents read the entire codebase.
  • Jira tickets exist because humans need work broken into digestible chunks. Agents handle multi-hour tasks across planning, building, testing, and deployment.

Every ceremony is a compensation mechanism for human cognitive limits. They’re not wrong - they solved real problems. But they solved human problems.

The real question
If you removed every human coordination bottleneck from your workflow, which ceremonies would survive? The answer reveals how much of your process exists to manage people, not produce software.

The Forced Migration Moment

Atlassian is ending new Data Center license sales on March 30, 2026 - six weeks from now. Full end-of-life is 2029. They’ve also raised Data Center prices ~15% effective this week.

Thousands of organizations with a decade of customizations, plugins, and workflows face a choice: migrate to Cloud (at ~50% higher cost for Premium), or leave. The community backlash is real. Years of server-side apps, custom integrations, compliance configurations - all potentially abandoned.

This is the largest forced re-evaluation of PM tooling in a decade. And it’s landing at exactly the moment when the alternative isn’t “which other human PM tool?” but “do we need a tool designed for human coordination at all?”

The Tools That Get It (and the Ones Playing Catch-Up)

We hit this wall months ago. Linear was the best PM tool for developers, but it still assumed a human would read every ticket, update every status, triage every issue. So we built Flux: a Kanban board designed for AI agents. CLI-first, git-native, MCP-integrated. flux ready shows unblocked tasks sorted by priority. Pipe it to your agent. No browser required.

Linear is now catching up. Four days ago they expanded their MCP server with support for initiatives, project milestones, and updates - explicitly designed for use from Cursor and Claude Code. Their tagline: “Designed for workflows shared by humans and agents.” Credit where it’s due: they see the direction. But the fact that a side project by 2-3 developers shipped agent-native PM before a $6B company tells you how fast this space is moving.

The PM tool of the agent era isn’t a dashboard humans stare at. It’s an API agents consume.

Human Touchpoints, Not Human Blockers

The goal isn’t removing humans from the loop. It’s removing humans as the serialization layer.

In a traditional Jira workflow, information flows like this: PM writes ticket → developer reads ticket → developer writes code → developer updates ticket → PM reads update → PM writes next ticket. Every arrow is a human reading, interpreting, and re-encoding information. Each handoff adds latency, loses context, introduces errors.

In an agent-native workflow: human sets direction → agent reads spec, plans work, implements, tests, updates status → human reviews output, makes judgment calls.

Humans still make every important decision. They just stop being the bottleneck between systems. The insight from the product engineering shift applies here too: the interface layer is being removed, and what remains is pure decision-making.

The best process is one where humans only touch the parts that require human judgment. Everything else is overhead.

What This Doesn’t Solve

  • Agents still screw up. They hallucinate, miss edge cases, introduce security vulnerabilities, and confidently tell you it’s fixed when it isn’t. Removing human coordination overhead doesn’t mean removing human oversight. You need deterministic guardrails that catch what agents get wrong, and visual verification that forces them to prove their work. The less ceremony you have, the more enforcement matters.
  • Alignment is still hard. Agents execute on bad specs just as fast as good ones. Someone still needs to decide what to build and why. Spec-driven workflows help, but the judgment call of what’s worth building stays human.
  • Autonomy needs structure. Letting agents run autonomously for hours only works if you’ve defined clear acceptance criteria and review checkpoints. Without them, you get fast garbage instead of slow garbage. The core loop still matters: plan, review, implement.
  • Not every team is ready. Organizations still figuring out basic CI/CD aren’t going to leapfrog to agent-native PM. The gap between “we use Jira” and “agents manage our backlog” is wider than the tooling suggests.
  • The agile values aren’t the problem. Iterating quickly, responding to change, working software over documentation: these principles are fine. It’s the ceremony industrial complex built on top of them that’s dying. Certified Scrum Masters charging day rates to facilitate standups is the part that doesn’t survive.

The Pattern

Every wave of developer tooling follows the same arc: manual process → tool that manages the process → tool that automates the process → process disappears.

Version control: manual backups → CVS → Git → agents that commit, branch, and merge autonomously.

Testing: manual QA → test frameworks → CI/CD → agents that write, run, and fix tests.

Project management is entering the “automates the process” phase. The tools that win won’t be better Jira. They’ll be the ones that make the coordination overhead invisible - where humans set direction and review output, and everything in between just happens.

Atlassian’s stock price isn’t a market overreaction. It’s a market that’s figured out the trajectory before the product has.

Related Posts