Linear #166: Agents Can Pull Data from Systems of Record, A New Age in Advertising
One vSaaS breakdown. One biz story. One 'how to'. In your inbox once a week.
Today’s newsletter is sponsored by Xplor Pay. If you’re attending TRANSACT 2026 in Atlanta, stop by Booth #717 to learn how you can unlock new revenue streams, scale faster, and streamline the payment experience.
They’re hosting an espresso bar in their booth on Thursday, March 19th, starting at 9 a.m. Stop by if you’re at the show and receive a surprise gift! Learn about PayFac as a Service with Xplor Pay.
Alright, let’s get to it…
Agents vs. Systems of Record:
What Will Happen?
Most companies have a “systems of record are holding our data hostage” problem.
Your ERP / EHR / LMS / ancient desktop app has the data BUT...
-no API
-exports are janky
-the only person who knows how it works is “Steve in accounting”
-every “integration project” turns into a 6-month archaeology dig
Agents can technically solve this.
They can:
1. Open the system (yes, the UI)
2. Navigate like a human would
3. Pull the fields you need
4. Reconcile the mess (“Acct #” vs “AccountID” vs “Customer Code”)
push clean data into the real workflow (CRM, warehouse, dashboard)
This is bigger than “integration pain.” It’s a strategic shift in what it means to be a system of record… and what it means to have a moat.
Part 1:
What this means for systems of record (SoRs)
Historically, systems of record won because they became the “source of truth” and then (intentionally or not) held the data hostage.
Not always maliciously. Often it’s just reality:
The vendor never built the API surface area.
The data model is too messy to safely expose.
The product team optimized for “get the job done,” not “enable the ecosystem.”
The business logic lives in UI flows, stored procedures, and tribal knowledge.
So the SoR becomes the place where work happens and also the place where data gets trapped.
The agentic wedge: “UI as the integration layer”
Agents change the rules because they can do what humans do:
Open the system (yes, the UI)
Navigate like a human
Pull the fields you need
Reconcile the mess (“Acct #” vs “AccountID” vs “Customer Code”)
Push clean data into the real workflow (CRM, warehouse, dashboards)
This is the same conceptual promise RPA has had for years—bridging systems when APIs aren’t available—but agents bring a more flexible “understand + adapt” layer on top of it. Oracle even calls this out directly: RPA “bridges systems that lack APIs” to keep data flowing end-to-end.
And UiPath makes the same point from a different angle: UI-level integration can be a low-risk way to extract and move data when legacy systems don’t expose modern interfaces.
So what happens to the SoR?
A bunch of SoRs are about to learn a hard lesson:
If your primary “defensibility” is data gravity + integration friction, agents are about to sandblast that friction down.
Because the buyer doesn’t actually love your ERP screen from 2009.
If an agent can reliably read + write through the UI, you’ve just lost one of the most underappreciated lock-in mechanisms in enterprise software.
Part 2: What this means for moats (and all the companies built on top of them)
Let’s name the moat that’s quietly powered a lot of enterprise software outcomes:
The “hostage data” moat
“We can’t switch because all our history is in there.”
“We can’t switch because integrations took forever.”
“We can’t switch because the workflows are custom.”
“We can’t switch because no one knows what will break.”
That moat has been real. It’s also been… kind of gross.
Agents don’t eliminate switching costs overnight, but they attack the most expensive part: integration and migration effort.
If a system has no API, historically you had two options:
Pay for a brittle, expensive integration project
Give up and keep doing manual work
Now there’s a third:
Let an agent operate the UI and produce structured outputs + audit logs
This is why the “unlock isn’t the model.”
The unlock is the combo of:
Goal-based execution (agents can actually do the thing)
A thin layer of governance (permissions + approvals)
An audit trail (so you don’t get fired)
And governance is not optional, by the way. Gartner is basically screaming this between the lines.
Gartner predicts at least 15% of day-to-day work decisions will be made autonomously through agentic AI by 2028 (up from 0% in 2024) and 33% of enterprise software applications will include agentic AI by 2028.
Also: Gartner predicts over 40% of agentic AI projects will be canceled by end of 2027 due to escalating costs, unclear value, or inadequate risk controls. Translation: if you can’t prove reliability + controls, you’re toast.
“But moats are dead!”
Moats aren’t dead.
Lazy moats are dying.
If your moat is:
“We’re the only place the data lives”
“Integrations are hard so customers stay”
“No one wants to migrate”
“Our UI is the workflow”
…agents are coming for you.
If your moat is:
Deep workflow ownership
Compliance + certifications + trust
Distribution into a vertical
Embedded payments / financial rails
High-frequency operational loops
Network effects (real ones, not vibes)
…you’re still in a good spot.
The winner moats shift from data custody to decision velocity + workflow control.
Part 3: The new battleground: “System of record” vs “System of action”
If agents can pull data out of any UI, then the real product advantage moves up the stack:
Who owns the action?
Who owns the approval chain?
Who owns the exception handling?
Who owns the audit trail?
Who owns the user’s trust?
In other words:
The agent layer becomes the new orchestration plane
And that’s where a ton of new companies will get built.
Not “ChatGPT but for X.”
More like:
“We turn your legacy finance system into an API by operating the UI safely”
“We reconcile IDs and write back with approvals”
“We provide agent observability, rollback, and compliance evidence”
“We own the decision loop, not just the database”
This is also why the old RPA vs API framing is getting updated.
RPA works at the UI layer; APIs work at the backend. Agents can blend both—and pick dynamically.
What AI agent founders should build (if you want to win)
Here’s the playbook I’d run if I were building an agent company attacking SoR-hostage problems:
1) Pick one “hostage workflow,” not a whole company
Example wedges:
Pull AR aging + reconcile customer IDs + push to CRM
Extract student attendance + completion data from an LMS + sync to reporting
Read orders from an old desktop app + update inventory planning
Keep it narrow. You want predictable UI paths, not infinite autonomy.
2) Build governance like it’s the product
If you don’t have:
permissioning (who can the agent act as?)
approvals (what needs sign-off?)
audit logs (what happened, when, why, and what changed?)
…you don’t have an enterprise product. You have a demo.
Gartner explicitly ties agentic AI success to risk controls and governance—lack of those is a key reason projects die. Source
3) Treat “field reconciliation” as the core hard problem
Everyone wants to talk about models.
Your customer wants:
“Is this the same customer?”
“Which ID wins?”
“What do we do when the UI value and export value disagree?”
“How do we handle exceptions without a ticket storm?”
This is where you earn retention.
4) Make reliability boring
UI automation breaks. Popups happen. UI labels change. Sessions expire.
Your job is to:
detect drift
retry safely
escalate cleanly
never silently corrupt data
What system-of-record founders should do right now (before agents eat your lunch)
If you’re building (or running) a system of record company, this is your “adapt or die slowly” moment.
1) Stop thinking your moat is the database
Assume the customer can (eventually) extract anything.
Compete on:
depth of workflow
time-to-decision
outcome ownership
trust + compliance
2) Become agent-native instead of agent-hostile
If your system fights automation, agents will route around you.
Offer:
stable APIs where possible
export endpoints that don’t suck
event streams / webhooks
permission scopes that map to real roles
built-in audit trails customers can reuse
3) Turn your product into a “safe execution environment”
If agents are going to act, the system of record can still win by being:
the most trustworthy place to execute changes
the best place to enforce policy
the best place to validate actions before write
Basically: “You can do anything… but only safely through us.”
That’s a real moat.
“By 2028…” is way too slow (and also kind of the point)
Gartner’s numbers (33% of enterprise software includes agentic AI; 15% of daily decisions autonomous by 2028) are framed as forecasts. Source
But the more important detail is why Gartner thinks adoption will be slower than the hype cycle:
Because production-grade agents require:
governance
controls
reliability
real integration into messy workflows
That’s not a model problem. That’s an operator problem.
Good news: that’s where founders with battle scars win.
Bringing it home
Most companies don’t have a “data problem.”
They have a hostage situation.
And agents are the negotiation team that can finally get the data out—without waiting for the vendor’s roadmap, without a 9-month integration, and without Steve in accounting doing ritual exports every Monday.
Either be the AI company or get eaten by it…
Last year, we brought hundreds of the top Vertical AI & Vertical Software Founders to Miami for an unforgettable few days...
We heard biz and founding stories, playbooks, etc. from some of the most prolific Vertical Software Founders & CEO’s.
This years line up is INSANE. I actually can’t believe it. We have a bunch of unicorn founders coming to share hard earned lessons.
I can’t wait to share the speaker lineup with you all...
PS - I will give free tickets to a bunch of folks that opt in above :-))
Advertising Is Moving From Attention To Action. And You Can Cash In On It.
For the last 20 years, ads have mostly lived in places where people browse: feeds, search results, content pages.
But we’re walking into a world where people don’t browse as much — they delegate.
They ask an agent to “handle this,” the agent decides what to do next, and then the work gets executed inside the software that runs an industry.
That shift quietly turns “advertising” into something way more powerful: monetized distribution inside workflows.
And vertical SaaS is sitting on the best real estate on the internet.
Alright, let’s get to it.
OpenAI is testing ads inside ChatGPT
(and that’s the starting gun)
As of Feb 2026, OpenAI has begun testing ads in ChatGPT in the U.S. for logged-in adult users on the Free and Go tiers, while keeping Plus/Pro/Business/Enterprise/Edu ad-free. This is not rumor anymore — OpenAI published the test details and the product principles they’re using to keep trust intact.
OpenAI is being extremely direct about the rules of the road: ads are clearly labeled and visually separated, ads don’t influence the answers, and conversations are kept private from advertisers. They’re also shipping real user controls (hide/report, “why am I seeing this,” personalization toggles, delete ad data). That’s important because it tells you how serious “trust” will be as this spreads into work software.
Here’s what the format looks like right now — a sponsored unit underneath the response, with clear separation and labeling:
And yes, the early pricing chatter is aggressive. Reporting on the pilot said OpenAI confirmed a $200,000 minimum commitment, and buyers were quoted around $60 CPM. Whether those numbers hold long-term doesn’t matter as much as the fact the channel exists.
Once ads work in conversation, the next step isn’t “more ads.” It’s ads inside actions.
Chat ads are the obvious first move because they look like search ads: user expresses intent in text, platform shows something relevant.
But agents don’t stop at answering.
They recommend what to do next and often do it for you.
So the next logical ad surfaces aren’t “below the response.” They’re inside:
the recommended next step
the default tool choice
the automated workflow the agent triggers
In other words, ads move from “attention” to “execution.”
That’s why “embedded ads” is a misleading term. What’s coming is closer to sponsored distribution inside the operating system of an industry.
Vertical SaaS has the unfair advantage: it knows intent, timing, and outcome
In horizontal consumer land, you can infer intent (“maybe they’ll buy shoes”) and you can try to attribute outcome (“we think the ad influenced a purchase”).
In vertical SaaS, the product already has the best signals on earth:
The software knows what job the user is trying to do, the exact moment they’re trying to do it, and whether it worked.
A restaurant platform knows when payroll is due. A construction platform knows when a change order is approved. A logistics platform knows when a shipment needs freight. A medical workflow knows when an order is being placed.
That’s a completely different level of “intent” than a keyword.
If you want a parallel mental model, think about what embedded finance did to vertical SaaS: instead of monetizing “traffic,” vSaaS monetized the workflow. This same shape will happen with sponsored actions.
The agent-as-dispatcher model (where this gets really interesting)
Imagine your vertical product has an AI layer on top — not a chatbot bolted onto the side, but an agent that can actually dispatch work.
A user says: “handle this.”
The agent replies: “Got it. Here are the best ways to do that.”
Then it offers two or three options. One might be “sponsored,” clearly labeled. The user picks. The workflow runs. You take a cut.
“Run payroll via X.”
“Finance this invoice via Y.”
“Order parts via Z.”
That’s not “banner ads.”
That’s the equivalent of being the default distribution layer inside a vertical economy.
And if you’re a founder, you should feel your stomach drop a little, because this is one of those shifts that creates $10B companies and also deletes whole categories of incumbents who used to own distribution.
The hard part isn’t building the model. It’s building trust without killing conversion.
If you’re going to put sponsored actions inside workflows, you’re now playing with production systems and money movement. That means your “ads product” needs to look more like enterprise infrastructure than a media platform.
OpenAI is already laying down the pattern: clear labeling, separation, privacy boundaries, and user controls. If you don’t match that bar (or exceed it in a regulated vertical), you’ll get one of two outcomes: either users revolt, or regulators do it for them.
And here’s the non-negotiable: if sponsorship changes what the agent “believes” is best for the user, you’re done. The only sustainable version is sponsorship that changes placement (and maybe incentives), while the agent remains outcome-optimized and transparent.
OpenEvidence is an early case study:
Vertical AI + Ads can scale fast
CNBC reported that OpenEvidence topped $100M in annualized revenue, and that it was one of the first AI startups to rely on advertising for revenue (rather than pure seat-based subscriptions). That ad-led monetization is a huge signal: in vertical contexts, “ads” can be positioned as “distribution to clinicians,” not as random brand spend.
Their own announcement highlights just how vertical this is: verified clinician usage, point-of-care workflows, and agentic research (DeepConsult). Whether you agree with every claim or not, the structure matters: a vertical AI product with heavy daily workflow intent can support monetization models that look “ad-like” while behaving more like outcomes-based distribution.
What founders should do next…
If you’re building vertical AI agents or vertical SaaS, the play isn’t to slap ads into your UI and hope. The play is to identify the handful of workflows where the user is already making a high-stakes tool choice — then let the agent become the dispatcher for that choice.
Start where partners already want distribution: payments, financing, procurement, insurance verification, staffing, parts ordering, logistics booking. The reason these are so attractive is because you can measure the full loop:
suggestion → selection → execution → outcome.
Then be boring about trust. Make sponsorship obvious. Give users control. Keep an audit trail. If you can’t explain why an action was recommended, you’re building a liability, not a platform.
And if you do it right, you don’t just add a revenue stream. You create a new moat: you become the place where decisions turn into executed workflows — and partners will pay endlessly to be in that decision set.
Have a product or service that would be great for our audience of vertical SaaS founders/operators/investors? Reply to this email or shoot us a note at ls@lukesophinos.com