“AI-Native” is an Architectural Claim
It feels like every company lately is calling itself “AI-native,” while still looking and acting like the last generation of software. The term has become marketing fluff, a crutch companies lean on when they’re unable to articulate a real value prop.
Adding AI to an existing product doesn’t make it AI-native. If the underlying data model, workflows, and interface haven’t fundamentally changed, the label hasn’t been earned.
At Quanta, we think a lot about what actually being AI-native means: how LLMs let us build products in completely different ways than were possible before.
We believe that in true AI-native software, every customer will experience a radically different UI, even though the underlying product is the same.
We also think it might mean no UI at all.
The Interface Has Always Been the Constraint
Throughout our careers, we’ve been frustrated by the UI limitations of the software tools we’ve built and used. We’ve built “rules engines” that never fully allowed for all the rules we needed them to. We’ve battled workflow builders that aren’t expressive enough. We’ve given up on BI tools that just couldn’t show the graph we wanted. We’ve ignored the charts on the homepages of our SaaS tools because they weren’t relevant to us, wishing instead we could choose what we saw. We’ve clicked 100 times to finish a seemingly simple task.
As a software engineer, I’ve seen these situations escalate to needing the “rules engine” to be a DSL, or letting our customers write their own code instead of using a rules UI, in order to handle their case. When I want to visualize data myself, I’d rather just export it and build the views I want, instead of settling for whatever the BI tool can show. And instead of clicking through a UI 100 times, I want API access so I can automate those clicks.
I’m especially biased here given my career in fintech. Finance teams have consistently rejected SaaS UIs in favor of spreadsheets, because no traditional UI could capture the edge cases and customizability their work demands. Accounting teams spend much of their time in “close workbooks,” massive Excel files with 100 tabs, manually updated every single month, because the software doesn’t capture the edge cases of their business.
In Finance, Exceptions are the Rule
Again and again, SaaS UIs have fallen short because there was one edge case that didn’t fit. In finance, exceptions are the rule, even if you think your business looks simple: the one strange contract where the customer reimburses you for their compute on your machines. The new revenue-sharing model you’re piloting with a partner who sends you deals. The experimental product line that starts with prepaid credits and then flips to retroactive overage pricing. Building something that can handle all these edge cases is extremely difficult.
Generative AI, and generative UI, is an unlock. Generative UI can render the visual representation of a dataset that a moment calls for. LLMs can take a nuanced edge case and map it to how it should be handled in a system, without anyone needing to define “if-this-then-that” logic that would be too rigid anyway. Those interpretations still need to be reviewable, and the underlying numbers traceable.
You Have to Rethink the Foundations
We believe there are three components to productizing this:
Building a small set of strong, powerful, robust visual primitives. This lets AI compose and assemble them to fit the use case, building the screen on the fly.
Owning well-modeled, extremely granular data, fully accessible through flexible entry points that can pull any relevant cut of it.
Every single action that can be taken in the system must have an entry point that’s legible to agents and invokable by them. This also means each entry point must enforce permissions, validate preconditions, and be safe to call even when an agent gets the ordering or context wrong.
A product that fully meets these requirements demands an entirely new way of building, and of thinking about building. It requires extreme consistency and thoroughness in how the product stores data, exposes access to it, and performs operations on it. This is NOT something that can be bolted onto an existing product. The product has to be built this way from the ground up. That’s what “native” should mean.
This is how we’ve built at Quanta from the ground up, because we believe “AI-native” means the customer can see their data however they want, backed by a system built to support that flexibility.
The Future of Software Needs to Be Infinitely Expressive
Finance is the perfect place to start building this future of software. This is because finance professionals ask new questions about their business every day and when these predefined dashboards can’t answer them, they export the data and build the views they need by hand in spreadsheets. The future of finance software has to be infinitely expressive: any cut of data, any representation, any action. If the interface still decides what they can ask or do, the product hasn’t earned the right to call itself AI-native.
At Quanta, we’re our customers’ financial system of record so we already hold the underlying financial data in a format we understand. Now we’re building the product layer on top, the one that finally makes “AI-native” mean something: showing them exactly the view they want, the moment they need it. We’re building a product where your imagination sets the limits on how you explore and visualize your data.
If this is something that excites you too, learn more about us here.




