OutSystems Mentor: AI for Enterprise Apps

Drive the 101 freeway through San Francisco this year and the billboards along the way seem to repeat the same five words, just with a different logo stitched underneath. Woodson Martin, chief executive of OutSystems, an enterprise software platform founded in 2001, uses that image to describe a problem the whole AI industry is wrestling with right now.

"the industry is struggling to crystallize differentiated messaging in this world... it's the sea of same" (Woodson Martin, [60:29])

Everyone is selling the same basket: an agent, a builder, a pile of integrations. The harder test, Martin argues, is not what the demo can do in a conference hall. It is what happens when that same system meets a bank's compliance department, a refinery's safety rules, or twenty years of accumulated legacy code.

Martin took over OutSystems in 2025 from founder Paulo Rosado, who ran the company for 24 years (03:05). Rosado's original complaint was blunt: custom enterprise software projects were always late, over budget, and brittle once finished (04:42). His fix became the company's mission, and Martin still states it plainly.

"Build faster, reliably every time, and evolve software at the pace of the business without breaking anything." (Woodson Martin, [04:42])

That promise has not changed, Martin says. What has changed is who, or what, is doing the building.

Most AI coding tools let a model write and edit raw code directly. OutSystems does something different. An abstraction layer, meaning a simplified model that represents what an application is supposed to do rather than the literal code that does it, sits between the AI agent and the finished software (08:32). An engineer using Claude Code, OutSystems' own assistant called Mentor, or any other coding agent is not editing files line by line. The agent edits this intent model, and the platform then deterministically generates the underlying code. The payoff, Martin says, is that every asset the system produces automatically inherits the platform's existing security rules, role based access controls, and regulatory requirements such as GDPR or HIPAA, the European and American rules governing data privacy and health information, without an engineer rebuilding those protections from scratch each time (09:13).

Reliability, in Martin's telling, is not purely a technical property. It is also reputational. Trust in a system, he argues, comes from the entire history of delivering similar systems inside similarly regulated environments, not just a benchmark score (11:38). That kind of track record is hard for any startup to replicate, however capable its underlying model is.

That matters because the definition of "enterprise ready" has shifted. It used to mean uptime and reliability above all else. Nathan Labenz points out that OpenAI and Anthropic, the two labs setting the pace in AI, do not have especially strong uptime records by old enterprise standards, and almost nobody holds it against them (12:15). What large regulated companies actually need now, Martin says, is proof that an AI model's training data was legally acquired, a question that increasingly decides whether an agent is allowed to touch real work at all (14:22). Martin describes clients who have built and tested a working agentic system, only to watch it sit in a compliance backlog waiting on approval of the specific model running underneath, even when the job is something as mundane as reading data out of a PDF.

The Price of Thinking

Every call to a language model costs money, measured in tokens, the small chunks of text a model reads and writes. By Martin's account, OutSystems' own internal token spend peaked in June and July of this year, after the company pushed its engineering organization to run everything through AI (27:30). The experiment paid off in velocity: major feature releases went from four in the fourth quarter of last year to nineteen in the first quarter of this year and twenty six in the second (28:23). But the same surge produced what Martin calls a shared "oh shit moment" across the industry, as CFOs opened February and March token bills and found costs rising faster than anyone had modeled (31:09).

OutSystems did not respond by using AI less. It built an engineering specific harness loaded with internal context, plus a routing layer that sends each job to the cheapest model capable of handling it rather than defaulting to the newest frontier release (28:43). The result, Martin says, is that the company is now burning fewer tokens than it had projected for the current quarter, even with output still climbing (29:09).

"Most enterprise workloads can use models that are three years old for most of the stuff." (Woodson Martin, [29:41])

The unglamorous truth, in his telling, is that most enterprise AI work, meaning the ordinary business of running a company rather than inventing new software, does not need the frontier at all. Older models, or deterministic code with no model involved, handle it at a fraction of the cost.

Nowhere is acceleration more visible than in the oldest corners of corporate IT. Many of OutSystems' customers still run systems sixty years old, written in COBOL or running on AS400 hardware, alongside tools like Lotus Notes (25:58). These systems were historically too risky and too expensive to touch. Martin says AI is changing that calculation by automating the slowest part of modernization: understanding what decades old code actually does and translating that logic into new requirements (44:19). One insurance client had planned a case management overhaul as a six year project. With AI handling requirement translation, testing, and rollout, the same work is now scoped at six months.

"Instead of planning it as a six-year thing, we're now gonna do it in six months." (Woodson Martin, [44:19])

Martin is less certain about where the interface itself is headed. He expects to still carry more than a hundred apps on his phone a year from now, and he resists the idea that conversation will absorb every interaction (55:44). At OutSystems' user conference in June, the company demonstrated a banking customer's agent noticing, mid conversation about a kitchen remodel, that the customer was pre-approved for a 30,000 dollar loan, then carrying that same conversation into the bank's own mobile application without the customer repeating anything (57:50). The software did not disappear. It moved.

What Does Not Get Easier

As every platform rushes to offer the same basket of agent, builder, and integrations, Martin thinks the next round of competition will not be won on breadth. It will be won on depth, in regulated industries such as banking, insurance, and energy, where OutSystems has spent two decades building domain specific guardrails (61:39). And he is betting part of that future on hiring junior employees who have never known software built any other way, people he calls "AI-pilled," meaning native to these tools rather than adapted to them (63:47). The caveat he adds is that most organizations have not yet built the onboarding to match: these hires still need to learn the regulatory and industry specific judgment that turns raw speed into something a bank's compliance department will actually sign off on (64:25).

Underneath all the acceleration, Martin keeps returning to one older, less exciting question. Models get cheaper, faster, and more capable almost every quarter. What a company should actually build to solve a real problem does not get any easier to answer just because the tools improved (54:18). That gap, between what AI can draft in an afternoon and what an enterprise can trust into production, is where OutSystems intends to keep making its money.