Something important has shifted in SaaS over the past several weeks.
Attio, Linear, and PostHog have not shipped the exact same interface. But they have moved in the same direction.
The center of gravity is moving away from the default dashboard and toward an agentic entry point.
That is the part worth paying attention to.
The old assumption was that a software product needed one carefully designed homepage that everyone would land on first. The new assumption is starting to look different: users arrive with different goals, different roles, different contexts, and increasingly they want to state intent directly rather than navigate toward it.
That does not mean UI is dead.
It means one static UI is losing its job.
I also turned this argument into an interactive companion: SaaS → Chat → Generative UI.
The pattern is real, even if the surfaces differ
It is worth being precise here, because the lazy version of this argument is too broad.
No, every SaaS homepage has not literally turned into a blank chat box.
But the recent product moves are too aligned to dismiss:
- Attio launched Ask Attio in February 2026 as "a new way to work with your entire CRM", then pushed the interface further with a dedicated Ask Attio product surface that lets users search, update, and create with AI across the CRM.
- Linear launched Linear Agent on March 24, 2026, positioned as something "accessible everywhere" across the workspace, comments, Slack, Teams, desktop, and mobile.
- On April 2, 2026, Linear also shipped web forms for Asks, making the request layer itself into a broader intake interface rather than a fixed internal dashboard flow.
- PostHog's current homepage now foregrounds PostHog AI and "Install with AI", while its March 24, 2026 essay "What we wish we knew about building AI agents" is even more revealing: PostHog says agents are now a primary persona, and that 34% of dashboards created by AI came through its MCP server.
That is not one company copying another company's landing page.
It is several good product teams converging on the same operating model.
Why the old homepage is weakening
The core problem is simple.
A modern SaaS product usually serves too many jobs to be well represented by one default screen.
Take a CRM.
The founder wants pipeline risk. The AE wants meeting prep. The RevOps lead wants data quality. The CSM wants account history. The manager wants forecast movement.
Those are not minor variations on one need. They are different intents.
The same thing is true in product software.
The PM wants patterns across requests. The eng manager wants delivery risk. The designer wants context around a feature. The support lead wants triage. The executive wants a compressed summary of what matters now.
Traditional dashboards handle this by becoming a compromise.
They show a little bit of everything, which usually means they are not the best first screen for anyone in particular.
That compromise worked well enough when software was narrower and users had more patience for navigation. It works less well now that products are broader, data is denser, and people increasingly expect software to meet them at the task rather than make them traverse a menu tree first.
This is less the SaaS industry admitting UI failed, and more the SaaS industry admitting that one handcrafted default UI cannot anticipate every user's intent.
Why chat wins the transition period
Chat is not the final interface.
But it is the obvious transitional one.
Why? Because chat is a universal router for intent.
If the product cannot predict whether I want a dashboard, a list, a summary, a workflow, a draft response, a report, a bug triage, or an account brief, the simplest thing it can do is let me say what I want in natural language.
That is why these recent launches matter.
Attio is not just showing records. It is giving users a way to ask across records, calls, emails, web search, and connected data. Linear is not just showing issue views. It is letting users pull context, draft specs, generate issues, and route request intake through an agent layer. PostHog is not just adding one assistant pane. It is treating both the built-in agent and the MCP server as real product surfaces.
In each case, the system is shifting from navigation-first to intent-first.
That is the deeper change.
The playbook behind the shift
Once you strip away the branding, the product pattern looks surprisingly consistent:
- expose the real system through APIs, tools, and data access layers
- add an agentic layer that is grounded in product context
- let the user start from intent rather than from navigation
- return the right interface for the task instead of forcing one default interface on everyone
PostHog says this almost explicitly. In its March 24 essay, the team says that if they were restarting, they would make MCP the canonical interface, and that their work should converge because agents are now a primary persona. PostHog's MCP server is not a side experiment. It is part of the product architecture.
Attio is making a similar move from the CRM side. Ask Attio is paired with a developer platform that explicitly foregrounds the Attio MCP, API, and SDK. The implication is clear: the CRM is no longer just a set of screens. It is a context layer that both humans and agents can work through.
Linear's product framing is slightly different, but the direction is similar. Linear Agent is built "directly into Linear" and "accessible everywhere", while Linear Asks extends the interface from issue management into generalized request capture and routing.
This is what an agent-native product stack starts to look like.
Dashboards are becoming outputs
The old mental model was:
homepage -> navigation -> feature -> task
The new one increasingly looks like:
intent -> agent -> generated view -> action
That shift matters because it changes what a dashboard is for.
A dashboard used to be the starting point. Increasingly it becomes the output of a request.
You ask for the accounts at risk. The system composes the right filtered view.
You ask for repeated customer themes from recent requests. The system gives you a grouped summary and the linked issues behind it.
You ask for a product drop-off analysis. The system builds or updates the chart, query, or dashboard that fits the question.
PostHog's numbers are especially revealing on this point. If 34% of dashboards created by AI are coming through the MCP server, then the dashboard is no longer just something a human manually constructs from a static UI. It is something an agent can produce as part of answering an intent.
That is a very different product posture.
Why chat is still not enough
It would be a mistake to stop the argument at "SaaS became chat."
Chat is too lossy to be the long-term answer.
Users do not actually want paragraphs of prose when the task is better represented as:
- a structured table
- a filtered list
- a form
- a comparison view
- a timeline
- a dashboard
- a draft workflow they can inspect and edit
And the leading products are already moving in that direction.
Attio's own engineering write-up on Ask Attio makes the direction unusually explicit: text alone is not the right interface, so the system renders structured, interactive UI directly inside the agent flow. Linear's Asks product is not merely conversation; it is intake, routing, and workflow capture. PostHog is using agent and MCP flows to generate dashboards and product artifacts, not just textual replies.
So the likely sequence is not:
dashboard -> chat forever
It is:
dashboard -> chat as router -> structured response -> generative UI
That last step is the one I think people are underestimating.
The agent will not only answer the question. It will increasingly compose the interface that best fits the question.
Not one universal homepage. Not one universal chat transcript.
A generated working surface.
Generative UI is the logical next step
Once software accepts that users arrive with variable intent, the next question is obvious:
If the system already knows the task, why force the same interface every time?
Why not generate:
- the right table for this request
- the right filters for this account review
- the right issue view for this planning question
- the right brief for this meeting
- the right combination of chart, list, and action controls for this specific user, right now
That is what I think this recent product wave is pointing toward.
Chat is useful because it captures intent cheaply.
Generative UI will matter because it turns that intent into structure.
The long-term winner is probably not the product with the prettiest fixed dashboard, or even the slickest agent chat. It is the product that can reliably turn user intent into the right working surface, backed by real system access and grounded context.
What this means if you build software
If you are building SaaS, I think the implication is straightforward.
You should stop treating the homepage as the permanent center of the product.
The more durable advantage is increasingly somewhere else:
- first-party context
- clean APIs and action surfaces
- agent-readable tools and schemas
- strong permissioning and grounding
- the ability to compose the right interface after intent is known
In other words, the moat is shifting down the stack.
The homepage still matters. Design still matters. Navigation still matters.
But more and more, the thing users are actually buying is not the screen they first see.
It is the system's ability to understand what they are trying to do, reach the relevant context, and produce the right interface for that job.
That is why I think this recent cluster from Attio, Linear, and PostHog matters so much.
It is not because they all copied chat.
It is because they are all, in different ways, redesigning software around intent.
And once that happens, the dashboard stops being the homepage.
The agent becomes the homepage.
Then the agent starts generating the interface itself.
Related on this site
- SaaS → Chat → Generative UI is the interactive companion if you want the argument as a faster visual product surface rather than a full essay.
- How Agents Actually Talk to Each Other is the companion piece on what happens once software exposes enough capability for multiple agents and runtimes to coordinate.
- The Intelligence Stack maps the broader shift from chatbot-style interfaces to tool use, orchestration, and AI as an operating layer across software.
- Evolution of LLMs is the broader timeline behind the model and product changes that made this product shift possible.
