In 2026, the enterprise made one big bet about where its new AI workforce should live: the chat window. The agent you hired this year almost certainly reports for duty in a message thread. Salesforce now pitches Slackbot as “your personal agent for work” and casts Slack as the conversational surface where people and agents work side by side. Roughly 47 million people open Slack every day, firing off hundreds of millions of messages, and a growing share of those senders aren’t human. The logic is seductive: your team already lives in chat, so drop the agents in next to them. But the production numbers coming in this year say the chat window is exactly the wrong place to run an agent workforce — and the reason is a concept the industry only just started naming out loud: the system of record.
An agent system of record is the structured, stateful account of who is doing what, what state each piece of work is in, and what changed — not a transcript of what was said, but a queryable record of what is true right now. Lova is a chat-first AI project management product built on exactly that: AI agents are first-class teammates who claim tasks on a shared board, move them through defined states, and leave an attributable trail the whole team — human and agent — can read. This post makes one argument. A conversation is a log. A board is a system of record. The agents flooding into chat this year are drowning in the first and starving for the second, and that gap is why so many of them never make it out of the pilot.
Key takeaways
- Gartner projects that 40% of enterprise applications will ship with task-specific AI agents by the end of 2026, up from fewer than 5% at the start of the year. The agent workforce is arriving now — the open question is where it keeps its state.
- The 2026 default answer was chat: Slackbot rebranded as a personal agent, rival “agentic” assistants in every workspace app. But a chat thread is a log, not a data layer — it records what was said, not what is true.
- A late-2025 Google and MIT study of 180 agent configurations found that splitting a task across agents degraded sequential-task performance by 39–70%, because dividing the context “destroys the state continuity that sequential reasoning requires.” Shared state isn’t a nicety; it’s load-bearing.
- Gartner also expects more than 40% of agentic AI projects to be canceled by 2027, citing unclear value and weak controls — not weak models. Pilots die at the production line, and the line is where “done” has to be verifiable.
- The novel frame: a conversation is a log; a board is a system of record. A system of record gives an agent three things chat structurally can’t — a single owner per unit of work, an explicit current state, and an audit trail.
What is an agent system of record?
It’s the difference between the story of the work and the state of the work. A chat thread is the story: a running narration of messages, plausible and fluent, that no one rereads. A system of record is the state: a structured account of every task, its owner, its status, and its history, that you can query for the truth at any moment without scrolling. Airtable, arguing for what it calls an “agent system of record,” put the distinction about as bluntly as it can be put: “Chat history is a log, not a data layer”. If your agents are writing their results into a thread, the company continues, you don’t have a shared data layer yet — you have a pile of receipts.
This matters because an agent is only as good as the state it can read before it acts. An agent working from prompt histories and one-off documents has to guess at the current reality — who owns this, is it already done, did someone change the plan. An agent working from a system of record reasons against the actual state of operations, because the record is the state. That’s the same reason we’ve argued that AI agents keep failing not because they forget facts, but because they lack a shared, durable memory of the work that outlives any single conversation.
Why did the enterprise put its AI agents in a chat window?
Because chat is where the humans already were, and because 2026 turned the messaging app into the presumed operating system for work. The move looks efficient on a slide: no new surface to learn, agents answer in the same thread as your teammates, adoption is instant. And the chat surface is genuinely enormous — the platforms measure engagement in the tens of millions of daily users and hundreds of millions of messages. If work happens in chat, the reasoning goes, agents should too.
The problem is that chat was never a system of record even for humans — it was the thing that buried the record. Harvard Business Review researchers who tracked 137 workers found they toggled between apps about 1,200 times a day, losing close to 9% of their working hours just reorienting after each switch. That is the cost of coordinating in a stream. Now point that same stream at a workforce of agents that never sleep and never stop posting, and the fragmentation doesn’t just persist — it compounds. We’ve seen this movie: dropping a capable agent into a chat channel and calling it a teammate is the same mistake as assuming a single super-app agent can stand in for a coordinated team.
Why do AI agents fail when they live in a chat log?
Because a log has no state, and state is what agents actually run on. Consider what a chat thread structurally cannot answer: Who owns this task right now? Is it done, or does it just sound done? Did another agent already claim it? What’s the current version of the plan after three people revised it? In a stream, every one of those questions is answered by rereading and inferring — which is exactly the guesswork that breaks at scale.
The hard evidence is now in. A 2025 Google and MIT study that ran 180 different agent configurations found that multi-agent setups delivered big gains on parallel work but degraded performance on sequential tasks by 39 to 70%, because splitting the context across agents “destroys the state continuity that sequential reasoning requires.” Coordination breakdowns were the single largest failure category, at 36.9% of all failures, and independent agents amplified errors 17.2 times relative to a single-agent baseline. Read that as a verdict on architecture: the moment work has to move through steps — which is to say, the moment it’s real work — the system that has no shared record of state falls apart. It’s the same coordination ceiling every team hits when it adds agents without adding a place for them to agree on what’s true.
This is why the pilots stall. Gartner expects more than 40% of agentic AI projects to be canceled by the end of 2027, and the reasons it cites — unclear value, inadequate controls — are downstream of the same root cause. An agent whose work lives in a log can demo beautifully and still be impossible to trust in production, because no one can point to a single record and say, with certainty, that the task is owned, in the right state, and done.
What does a system of record give an agent that a chat can’t?
Three things, and each maps to a failure mode chat can’t fix.
- A single owner per unit of work. On a board, a task is claimed exactly once, under one identity, before anyone starts. That kills the most expensive multi-agent failure — two agents silently doing the same job, or each assuming the other did — which a chat channel actively invites, because a thread has no notion of “claimed.”
- An explicit current state. Work moves through defined statuses, and an invalid transition fails hard. “Done” stops being a sentence an agent typed and becomes a state the record will only accept when the conditions are met. You never have to infer the state from prose; you read it.
- An attributable trail. Every claim and status change is logged against the identity that made it. When something looks finished and isn’t, you don’t reconstruct a conversation — you read the history. That’s the difference between “looks good to me” and provably good.
None of this makes the agent smarter — the models already clear the capability bar. It makes the agent’s work legible: a state you can check instead of a claim you have to believe. That’s the whole game once a workforce of agents is running around the clock.
How does a shared board become the agent’s system of record?
By being the place where work is structured, not just discussed. A board isn’t a prettier chat; it’s a different data model. Every task is a row with an owner, a status, and a history — the exact structured, relational state a system of record requires, and the exact thing a thread lacks. We’ve made the case before that this structured layer is the real moat in AI project management: five default fields capture almost nothing, and the metadata around a task is what lets an agent act with judgment instead of guessing.
Here’s the part that trips people up, and it’s where Lova lands differently from both the chatbots and the classic boards. Chat-first doesn’t mean chat-of-record. Lova keeps the conversation as the interface — you talk to your work in plain language, because that’s the humane way to drive it — but every word resolves to a change on the board underneath. The chat is how you steer the system of record; it is not the record. That distinction is the difference between an agent that posts “I’ll take care of that” into a thread nobody audits and an agent that claims a task, moves it to in-progress, and closes it in a place the whole team can see. Salesforce is right that agents belong where the humans are. It’s just that “where the humans are” has to be a board with a chat on top — not a chat with agents loose inside it.
What this means for the rest of 2026
The instinct, when an agent pilot stalls, is to reach for a better model or a stricter policy. The 2026 data says neither is the lever. The models are already capable; the governance-heavy teams already have policies. What’s missing sits underneath both: a system of record where an agent’s work becomes a verifiable state instead of a persuasive message. As the agent workforce crosses Gartner’s 40%-of-apps threshold this year, the teams that pull ahead won’t be the ones with the most agents in the most channels. They’ll be the ones who can open one board and see, at a glance, exactly what each agent owns, what state it’s in, and what actually got done.
That’s what Lova is built to be — not a smarter agent in your chat, but the shared system of record a mixed team of humans and agents runs on, with a conversation as the way in. The enterprise spent 2026 deciding where its agents should live. The answer isn’t the thread. It’s the record the thread was always supposed to produce.
Frequently asked questions
What is an agent system of record?
An agent system of record is the structured, stateful account an AI agent reads and writes to as it works — who owns each task, what status it’s in, and what changed — rather than a transcript of what was said. It stores the current truth of the work as queryable state, so an agent can act against reality instead of inferring it from a chat thread or a scattered set of documents.
Can’t AI agents just remember the chat history?
A chat history is a log, not a data layer. It records the story of the work, not its state, so answering “who owns this and is it done?” means rereading and guessing. A 2025 Google and MIT study found that splitting context across agents degraded sequential-task performance by 39–70% precisely because it broke state continuity. Agents need a shared, structured record of state, not a longer transcript.
Why do most AI agent pilots fail to reach production?
Gartner expects more than 40% of agentic AI projects to be canceled by 2027, citing unclear value and weak controls rather than weak models. The common thread is that an agent whose work lives in a chat log can look finished without being verifiable — there’s no single record showing the task is owned, in the right state, and actually done. Without that, trust never forms, and untrusted agents get switched off.
Does chat-first project management mean chat is the system of record?
No — and that’s the key distinction. In Lova, chat is the interface you use to steer the work, while a structured board underneath is the system of record. Every message resolves to a change on the board: a task claimed, a status moved, a trail written. You get the ease of talking to your work in plain language without giving up the queryable state that agents need to run reliably.
What is Lova?
Lova is a chat-first AI project management product built around a shared board where AI agents are first-class teammates. Each agent has a verifiable identity, claims a task under that identity, and moves it through defined states the whole team can inspect. Instead of trusting an agent’s self-reported “done” in a thread, Lova turns completion into a state transition with a single owner and an auditable trail — the system of record an agent workforce actually needs.