Analytics Is Still Single-Player

The tools that won the last era of work all won the same way: they went multiplayer. The document stopped being a file that one person edited and everyone else received. It became a place — shared, live, one copy — where the team could watch each other work, argue in the margin, and pick up exactly where someone else left off. Design files did it. Code did it. Planning boards did it. Work stopped travelling as attachments and started happening in one room, even when the team was not in one.

Analytics never made that jump. Worse, the AI wave has so far pushed it the other way. Ask a question of your data today and the state of the art is one person, alone, in a private prompt box — and a screenshot for everyone else.

The screenshot is the deliverable

Follow one question through a normal week. An analyst types it into an AI chat and gets a plausible answer, generated by SQL nobody else saw, against a snapshot nobody else can inspect. The result travels the way results travel now: a screenshot in a group chat, a chart pasted into a deck, a CSV export attached to an email with "final_v2" doing heavy lifting in the filename.

Then someone in the meeting asks the obvious follow-up — is that net of returns? does that include the new depot? — and the room discovers the answer's weak point. Nobody knows. The reasoning happened in a private session. The analyst goes away, asks again, privately, and returns with a second screenshot. By Thursday there are three copies of the number in circulation, each slightly different, and the meeting is no longer about the question. It is about which copy to trust.

None of this is the analyst's fault, and it is not really the model's fault either. The artefact is private. A session that one person owns cannot be redirected mid-flight, checked while it is live, or handed over with its working intact. It can only be forwarded — flattened into a picture of an answer, with the question that produced it left behind.

Multiplayer means the session is the artefact

TridaPad was built the other way round. The sources connect once — 50+ SQL, NoSQL, Big Data and cloud sources — and the team works in one shared workspace: the same live queries, the same dashboards, with real-time collaboration and role-based access deciding who can edit and who can view, instead of whoever happened to receive the file.

AgentSQL works inside that shared session rather than in a private chat of its own. The question is asked where the team can see it. The SQL it writes is on the screen, not buried in a transcript. The chart it builds lands on the shared dashboard, and because AgentSQL verifies its results before presenting them, what the room is looking at has already been checked. If the question is wrong, someone says so while it is still a question — and the fix happens in the same session, on the same live data, in front of everyone it affects.

The same holds for the programmatic route. TridaPad's built-in MCP server carries per-user API-key auth, so when an AI client queries data or builds a dashboard through it, it does so as a named user inside the governed workspace — not as an anonymous export pulled out the side door. And for the people who only need the answer, dashboards carry public share links: one live link, not another copy.

What changes in practice is small and total. The question has a history. The query can be inspected while it is live. A handoff is "here is the session", not "here is my export, good luck".

One Monday review, four people in one session

Take a mid-size consumer-goods company — packaged staples, sold through distributors, shipped from a chain of regional depots — and its Monday dispatch review. A month ago this meeting ran on a deck built from three exports, and the East region's missed plan was argued over for most of an hour because two copies of the dispatch sheet disagreed about what had actually left the depots.

This Monday, the review runs in one shared session. The operations head asks, in plain words, in front of the room:

"Why did the East region miss its dispatch plan last week?"

AgentSQL checks the schema of the connected dispatch view and writes the query. The core of it, on the screen for everyone:

-- Dispatch plan vs actual: East region, last week, by depot and product line
SELECT depot,
       product_line,
       SUM(planned_cases) AS planned_cases,
       SUM(dispatched_cases) AS dispatched_cases,
       ROUND(100.0 * SUM(dispatched_cases)
             / NULLIF(SUM(planned_cases), 0), 1) AS attainment_pct
FROM dispatch_plan_actual
WHERE region = 'East'
  AND week_start = DATE '2026-11-02'
GROUP BY depot, product_line
ORDER BY attainment_pct;

The numbers in this worked example are sample numbers; the shape of the answer is the point. Overall attainment comes back at 93 percent — but the split does the talking. Most depots sit in the high nineties. One depot, on the company's largest detergent line, sits at 71 percent. The miss is not a region. It is an address.

The supply planner, who can see the query because it is in front of him, redirects it in the same session: split it by day as well. The room watches the same live query change shape, and the shortfall concentrates where he suspected — the last three days of the week, not the first four. The finance partner does not ask for an export. He forks the same query into a margin view — same data, same definitions, his angle — while the original stays untouched on the screen. The result is pinned to the shared dashboard the review always uses, and when a regional manager asks about it on Wednesday, she opens the same link. It shows Wednesday's data. Next Monday starts from the saved query, not from a blank prompt and a memory of what was asked.

What multiplayer does not fix

Three honest limits. A shared session spreads a wrong definition faster, not slower: if "dispatched" quietly means invoiced rather than loaded, the whole room now agrees on the wrong number in real time. The definitions still have to be argued once, deliberately, before they are shared. Second, shared is not the same as open to everyone — the finance partner's fork works because finance is allowed to see margin, and role-based access is what keeps a shared workspace from becoming a bigger leak. Third, a session does not make the decision. Somebody still has to own the call: reroute the trucks, accept the shortfall, change the plan. The shared session removes the argument about which copy is right. The argument about what to do remains — and it should, because that one is the actual job.

Bring the meeting into the session

If your team's analysis lives in one person's prompt history and everyone else's screenshots, the fix is not a better prompt. It is a shared room: one workspace on live data, the agent working where everyone can see, redirect and build. Try TridaPad with your own team and your own Monday question — or write to us at data@tridalabs.com.