Agentic AI is turning project tools from systems of record into systems of action

For thirty years the project tool has had one job, and it has done it with the enthusiasm of a filing cabinet: remember things. The plan goes in. The risks go in. The status goes in, eventually, after a reminder. And at the end of the month somebody pulls it all out again and turns it into a deck, which is the moment the filing cabinet's work is finally appreciated, by which point everything in it is three weeks old.

Every tool I have used in that time, from the spreadsheet to the enterprise PPM platform with the licence that cost more than the programme, has been a system of record. The people did the work. The tool remembered it. Mostly.

The first wave of AI did not change that. It made the remembering more pleasant. You could ask a chat window what was overdue instead of building the filter yourself, and a copilot could turn twelve bullet points into a paragraph that sounded like a person had written it on purpose. Useful. But the shape of the job stayed the same: the project manager still gathered the inputs, still clicked through the screens, still owned the assembly of every deliverable. The copilot was a very fast intern who could not leave the room.

The second wave changes the shape.

Systems of record versus systems of action

A system of record waits. A user enters data and later extracts a report. It is the world's most expensive notebook.

A system of action does things. It carries out multi-step work on the user's behalf, drawing on the record rather than merely holding it. An agent, in this sense, is not a chatbot with a longer memory. It is software that can take an objective, break it into steps, call the tools it needs, check the result, and keep going until the objective is met or it has to ask. Applied to a transformation programme, that is the difference between a tool that stores your governance log and a tool that keeps it honest.

Three shifts follow, and each one lands on the project manager's desk, usually on a Monday.

From navigating a UI to declaring an intent

Today, preparing a steering pack means opening the plan, checking what slipped, opening the governance log, filtering for anything escalated, opening last week's status, reading the value tracker, and assembling the result by hand, ideally before the pizza arrives. The interface is the work.

In an agentic tool the user declares the intent: prepare the steering pack for the customer portal programme. The agent fetches the plan movement since the last meeting, reads the open decisions and the risks that changed, pulls the value trajectory, and drafts the pack. The person reads a draft rather than building one.

This is not the end of the interface. It is the end of the interface as the only route to a result. The dashboard remains for when you want to look. It stops being the tax you pay to get anything done.

From reactive to proactive

A system of record is silent until someone asks it a question. That is why so many programmes surprise their steering group: the signal was in the data for weeks, and nobody ran the query, because nobody knew which query to run, because nothing had happened yet. Obviously.

A system of action watches. It notices that three tasks on the critical path slipped in the same fortnight, that a risk has been open without an owner for a month, that a benefit trajectory went amber while the delivery RAG stayed a confident green. It does not wait to be asked. It raises the anomaly with a proposed resolution attached, so the person's job is to decide rather than to discover.

I wrote in an earlier post that RAG status is a lagging indicator by construction. Proactive agents are how a leading indicator becomes operational: the conditions that predict trouble are already in the record, and now something is pointed at them that never gets bored.

Agents that talk to other agents

The third shift is the least visible and, over a few years, probably the largest. Systems have integrated through APIs for two decades: one platform pushes a record, another accepts it, a developer maintains the mapping, the developer leaves, the mapping becomes folklore. In an agentic landscape the integration surface is the agent itself. A governance agent that needs to verify a budget variance asks the finance system's agent, in plain language, and gets an answer with the evidence attached. Nobody exports a ledger. Nobody opens a ticket called "ledger export, again".

That changes what a platform has to offer. It is no longer enough to have an API. The platform has to expose its capabilities in a form an external agent can discover, understand, and use safely, with the same permissions the person would have had. The Model Context Protocol is the first widely adopted way of doing that, and it is why a serious project tool now needs an MCP surface as much as it once needed a REST one.

What does not change: who is accountable

It would be easy to read all this as "the agents run the programme". They do not, and they should not. A steering group signs off a status. A sponsor owns a benefit. A project lead decides whether a risk is real or whether someone had a bad week. Accountability does not transfer to software, and a tool that quietly rewrote a RAG status because a model thought it should would be a tool no serious governance function could use, or explain to an auditor.

So the useful frame is narrower and more demanding than "autonomous". Agents gather, analyse, propose, and draft. People confirm. The quality bar for the agent is that its proposal is grounded in the actual record, that it shows the evidence, and that nothing in it was invented to make the narrative tidier. The quality bar for the tool is that no write happens without a person saying yes.

Where to start

If you run programmes today, the practical question is not whether this is coming but what to do while it arrives.

• Get the record into one place. An agent can only act on what it can

read. A plan in one tool, risks in a spreadsheet, and status in email is a record no agent can govern, and no human can either, which is how you got here.

• Insist on grounding. Ask any AI feature where each claim came from. If

the answer is "the model", it is not ready for a steering pack.

• Ask where the model runs. Agents need deep access to the record, and the

record is the most sensitive description of your business that exists. Who hosts the inference and whether they train on it are product questions now, not procurement footnotes.

• Keep the confirmation step. The tools worth adopting make the human

decision faster. They do not remove it.

TransformRadar was built as the one place for the record, with AI that drafts from it and never invents. The next post sets out exactly what that means in the product today, and the one after where it goes from here.

• AI
• agentic AI
• project management
• governance