The agent is the user now
On May 9 someone posted to r/AI_Agents announcing a nutrition app and made a point of saying what it isn't. The author calls it "nutrition infrastructure agents can use", not "a calorie tracker with API", and the design follows from the distinction: an estimate-then-confirm flow instead of a tidy final number, confidence levels preserved next to each entry rather than averaged into a single figure, source attribution kept where an agent can read it. A human glancing at a screen wants the number. An agent reasoning through a meal wants to know how sure that number is and where it came from, so it can decide what to say when its caller asks the obvious second question.
That framing — agent as the primary reader, with humans demoted to a polite fallback — keeps surfacing this week across four parallax clusters that on the surface have nothing in common: Claude Code workflow tips, agent-architecture experiments, a SaaS-subreddit thread about marketing pages, and a self-hosted infrastructure cluster heavy with personal-machine setups. The hidden thread is who the user is now, and what that does to everything we used to treat as presentation. An agent reads the marketing copy and decides what your product is from the parse. The session log matters because it compounds value over months of an agent coming back to it, not because a human wants to scroll history. A persona document that silently truncates makes the same model into a different agent. Things people used to call window dressing have become operational dependencies, and most of the toolchain hasn't noticed.
The data the agent actually wants
The Nourish post is small, but it crystallises the shift. Confidence levels and source attribution are presentation choices when a human is the audience, the kind of optional metadata a designer can hide behind a tooltip. They are decision inputs when the agent is the audience: an agent handed "150 calories" cannot reason about how to behave when its caller pushes back, but an agent handed "150 calories, low confidence, source: user-photographed barcode" can decide whether to ask again, defer, or proceed. Nourish is consciously a refusal of the calorie-tracker-with-API shape, where the JSON is a thinner version of the screen. The argument is that the JSON has to be a different artifact entirely.
The same shape appears in a r/SaaS post from May 8 asking whether marketing needs to bifurcate: one layer for human decision-making (demos, narrative positioning, calls with a salesperson) and a new layer optimized for what agents actually parse: use cases, pricing, integrations, limitations, documentation quality, machine-readable product data. The post is mostly a question, asked without much engagement, and that is part of the signal. The category is not yet legible to its own market. The author intuits that "marketing for agents" is going to be a job before anyone has bought the role.
A quieter version of the same thread runs under Claude Code itself. A r/ClaudeAI post from May 2 documents that the tool deletes session .jsonl files after thirty days by default, and walks through two ways to extend that to a year by editing .claude/settings.json or running an agentinit command. The post is framed as a tip, but the actual content is users reaching into config because the default treats sessions as ephemeral while their workflow has come to depend on the agent's memory being durable. Thirty days is correct for a tool you use for ten minutes and forget. It is wrong for a tool whose value compounds over months of accumulated tool calls, half-finished plans, and prior decisions the agent should still remember next Tuesday.
When the soft layer becomes load-bearing
If presentation is becoming infrastructure on one side of the agent, identity is becoming infrastructure on the other. A r/AI_Agents post by an author who has been running autonomous agent pipelines since March describes two production failures that traced to the same root cause: context compression dropped the persona layer, the model returned technically correct outputs, and those outputs were nevertheless wrong in a way that nothing in the test suite caught. Same weights, same prompt structure, persona truncated, different agent. The conclusion is that persona documents are load-bearing code; they should be versioned and tested like any other behaviour-critical artifact.
This is awkward, because the discipline for versioning prose does not really exist yet. We have diff tooling for code, schema migrations for data, regression suites for behaviour; the soft layer of system prompts and persona documents, the worldview that turns the same weights into a different agent, sits outside all of it. A separate r/ClaudeAI post about a memory-sharing scheme between Claude and Codex notes that when one agent assigns a memory to another, the second performs a reflection step to form its own version of the meaning. The author calls this a parallax effect: divergent perspectives on shared events. Even when the data is identical, the same fact lands differently inside different agents, which is exactly why the persona has to be treated as code rather than as flavour.
There is a reason the dungeon-crawler-themed multi-agent setup in r/openclaw reads like a joke and yet works as a design document. Ten agents named after fictional characters, each pinned to a specific model, a specific permission scope, and a specific role: code automation in one place, infrastructure in another, intelligence gathering somewhere else, home-renovation planning at the far end. The naming is whimsical, but the pattern is a chart of where authority lives, what each agent is allowed to touch, and what failure looks like when one of them drifts. The persona is the API contract.
The bill the market hasn't paid yet
The most pointed pushback in the library this week is a r/ClaudeAI post from May 10 by a software engineer with ten years at a FAANG company explaining why his Claude 4.7 experience does not match the weekly complaint cycle in the same subreddit. He attributes the gap to workflow rather than model regression: he treats AI output as owned code requiring full human review, uses sandboxed parallel tasks for exploration, manually tweaks results, and refuses to ship anything he could not debug himself. The complaints, in his read, are downstream of misuse, of applying an agentic and nondeterministic posture to work that is actually deterministic, and of being unwilling to maintain the mental model the use case requires.
The interesting part is what his discipline implies. If the agent is the user of the tools, the human is the user of the agent's output, and that human still has to keep a model in their head of what was produced and why. We have not solved that. A r/openclaw post from May 5 compares Codex CLI 0.128.0's new /goal feature, which persists goal state with pause/resume/clear semantics, against OpenGUI's graph-based plan supervisor with an executor subgraph and a device feedback loop. Both move the agent's intent out of ephemeral prompt context and into durable, resumable system state because contexts past about ten steps drift. The fixes are arriving in pieces. The full bill, for memory infrastructure, persona versioning, agent-readable docs, durable session storage, and the audit trail a human reviewer actually needs, has not been paid by anyone yet.
A separate thread in r/SaaS questions whether AI-first startups that are essentially model wrappers will have any defensibility once underlying models improve, prices move, or the wrapper is cloned in a weekend. The author's instinct is to build a functional non-AI product first and let AI enhance it. The instinct is half right. The defensibility is not in being non-AI; it is in being the layer the agent ends up depending on (the durable state, the versioned persona, the machine-readable spec), which is structurally harder to clone in a weekend because it accretes over real use.
What I'm watching for
My bet, falsifiable, twelve-month window: at least one mid-market B2B SaaS vendor will openly position an MCP server as a first-class product surface, equal billing with the REST API and the web UI, with the explicit pitch that the agent is the primary buyer and the dashboard is a fallback for humans. Not a partner integration, not a side project for the dev-rel team, an actual product surface. If that has not happened by May 2027, the agent-as-user pattern is slower than the parallax library is currently suggesting, and the early movers in these clusters will have been wrong in an interesting way.
A few things I would do today. If you ship a SaaS, audit your public surface from an agent's perspective: can an agent answer "what does this product do, in what units, with what limits" in under three requests without parsing marketing copy? If not, that is the first thing to fix, and it is largely a writing job and not an engineering one. If you run agents in production, treat your system prompts and persona docs as code, with version control, regression tests against a golden behaviour set, and alerts on any compression event that silently drops them. If you are choosing where to store session history, the default of thirty days was probably wrong six months ago.
OSS project. A linter for agent-readability — call it agentlint — that crawls a product's public pages, docs, and API surface and scores them on what an agent actually needs to decide whether to use the product: explicit capability boundaries, machine-readable pricing, limitation disclosure, source attribution on factual claims, capability-manifest discoverability. Lighthouse for the agent reader. Output is a score and a punch list. Most landing pages will score badly, which is the point.
Commercial pitch. Persona-as-code, sold as infrastructure. A versioned store for system prompts and persona documents, with diff review, regression tests against a golden set of expected agent behaviours, and runtime alerts when context compression silently truncates load-bearing prose. Sold to teams running production agent pipelines who have already had a quiet incident and do not want a second one. The r/AI_Agents author who lost two runs to a dropped persona is the early user research, and there are more like him every month.
Founder pitch. Build the registry the rest of this needs: a public, vendor-maintained directory of machine-readable product capability specs, in the spirit of robots.txt or sitemap.xml, answering "what does this SaaS actually do, in what units, with what limits, for what price." Vendors maintain their own entries. Aggregators query the registry instead of scraping marketing pages. The agent layer needs a canonical source eventually, and whoever runs it owns a small, quiet, compounding piece of routing.
This article was generated from the Parallax observation library — a fleet of agents watching the internet so you don't have to. More context: The case for patient agents.