The death of SaaS is a pricing argument

On this page

I think the death of SaaS starts with a loss of pricing power. Useful software will keep being built, hosted and maintained. The uncomfortable question is how much a vendor can charge for a function once its customer has a credible way to reproduce it.

To get beyond the repository screenshots, we ran Reverse Engineer Anything against Excalidraw's shipped production JavaScript. We followed a public export into the bundled engine, inspected the implementation and wrote a small alternative. Within its declared geometry scope, our version matched the original on 528 selected test cases.

We also found an important difference outside that scope. The original caches results against an element's version. Change the element without advancing that version and it can return the old bounds. The engine assumes callers advance the version when they change an element. Our stateless implementation returns the new bounds without that version discipline.

The cache result is why I do not treat a passing function test as application parity. Reproducing a calculation, reproducing an application's behaviour and replacing a business dependency are different achievements. Agents make the first two more approachable. The commercial consequences can arrive well before the third is complete.

What we actually ran

Reverse Engineer Anything, or REA, gives agents structured tools for investigating software. We used its released JavaScript application analyser, version 6.4.0, on the production files in Excalidraw 0.18.1. Excalidraw's MIT licence gave us permission to inspect and reuse the code. We excluded source maps and development builds from the analysis input.

The broad pass parsed all 65 selected JavaScript files without a parser failure. But resource limits prevented complete semantic analysis of the main engine chunk and entry file. A narrower pass identified the function we wanted, while still reporting partial graph coverage. This was useful investigation with visible limits; the tool did not hand us a replacement application.

REA's module relationships connected the public getCommonBounds export to a minified function in the engine. This operation calculates the coordinate box enclosing a set of shapes, including their rotation. We then read the shipped code and reconstructed the mathematics for rectangles, diamonds and ellipses. The comparison ran the actual distributed engine in Chrome, with fresh synthetic elements, alongside our implementation.

The 528 cases covered empty input, rotation, negative coordinates, degenerate shapes and seeded combinations. A deliberately crude control treated every shape as its enclosing rectangle; that differed from the original on 448 cases. The shape-aware version matched within the stated numerical tolerance. The separate cache probe remained a documented difference. These are results for one bounded operation, with the method, code and results retained.

Our reconstruction used inspected, licensed implementation material. It was source-informed work in the same agent environment. We did not conduct a clean-room exercise, clone Excalidraw or measure a development speedup. Excalidraw was already open source; REA was one useful investigation tool in this experiment, rather than the only route to understanding it.

What changed my view was that we could trace a public export to its shipped implementation, reconstruct one operation and check it against the original. A business does not need to commission an entire application to investigate a function it depends on.

The vulnerable unit is the function

A software suite bundles together many different reasons to pay: useful calculations, document handling, collaboration, stored data, integrations, support and a familiar place for people to work. A subscription can capture value from the whole bundle even when a particular customer needs only a fraction of it.

My expectation is that agents will make more of those fractions economically separable. An agent can investigate an operation, produce an implementation, connect it to other tools and compare the output. It can also use an existing open-source engine. The business gains another credible source of the function without commissioning an entire competing suite.

That changes the negotiation. A vendor can own its implementation and still face a cheaper substitute for what the implementation does. The feature may remain useful while becoming a weaker reason to pay the old price.

There is no measured SaaS saving in our geometry experiment. It does, however, make the mechanism concrete: a function embedded in a large application can be reproduced as a small standalone implementation with an explicit scope. The leap from that observation to market-wide margin pressure is my forecast.

I do not assume a permanent token bill for software built with agents. Our geometry reconstruction calculates bounds without a model call. Investigation and future repair can incur model costs; execution can still be ordinary software. Computing and maintenance remain costs either way.

For a small business, that creates a more interesting option than building its own Photoshop. It may become practical to own the limited logic that is specific to the business, then buy the remaining services. I expect ownership and purchasing to become more granular.

Adobe and Microsoft are exposed to functional competition

ArtCraft's application catalogue targets familiar territory: image editing through PhotoCraft, documents through WordCraft, spreadsheets through GridCraft and presentations through DeckCraft. These projects put the competitive question directly in front of Adobe and Microsoft. They do not establish a security breach, and we found no verified development link showing that REA produced them.

The PhotoCraft code deserves more attention than its resemblance to Photoshop. Its Gaussian blur implementation contains real numerical processing. Its engine tests check locked-layer and transparency behaviour. We inspected that code; we did not run a Photoshop comparison.

The same project supplies the strongest reason to resist a victory lap. Its 12 October parity assessment retracts earlier optimism based on feature breadth and separates that breadth from readiness for professional work. Its conclusions about PSD exchange remain substantially less confident than a menu count suggests.

There is a technical reason for that distinction. PhotoCraft's PSD parser can preserve original channel encodings and unknown blocks. That can help an unmodified file round-trip faithfully without the application understanding how to edit everything it preserves. Adobe's own file-format specification separates document structure from interpretation and excludes the PSDC cloud format.

Our cache finding is a smaller version of the same problem. A successful numerical result does not capture every assumption surrounding it. Document fidelity, state and awkward behaviours accumulate across an established application. They are expensive evidence and integration problems even when generating the next function becomes easier.

I still see exposure. A challenger does not need professional Photoshop parity to compete for some image operations. More significantly, PhotoCraft's command engine serves desktop, CLI and machine-facing paths through a common registry. That creates the possibility of competing directly for an operation inside an agent's workflow. The agent may never need a familiar menu or a new human habit.

IP survives cheaper implementation

The claim that agents make software IP worthless confuses the difficulty of reproducing something with the rights to reproduce it.

Copyright protects software expression; functional ideas and methods are a different question. IP Australia's guidance makes that distinction and also explains why computer-related inventions can raise patent questions. An implementation can become easier to produce while copying code remains restricted and separate patent rights still matter.

Australian law is more specific than either "reverse engineering is legal" or "the EULA always wins". Section 47B permits certain incidental copies made when a lawful owner or licensee runs a program to study its functioning. Section 47D permits narrowly conditioned copying for interoperability. Section 47G can remove those exceptions when copies or derived information are used for a different unauthorised purpose. Section 47H makes contractual restrictions ineffective for specified exceptions. Access-control circumvention has separate rules under section 116AN. None of that creates a general permission to clone a commercial product. These distinctions come from the current Copyright Act.

The US result in Google v Oracle is similarly narrower than the slogan often attached to it. The Supreme Court assumed copyrightability for argument and held the particular API copying fair use in context. It did not make every API or implementation free to copy, and it supplies no general Australian fair-use defence.

Our experiment sat on much firmer permission: an MIT-licensed target. That made the technical investigation straightforward to authorise. It says nothing about permission to feed proprietary code, confidential material or separately licensed assets into the same process.

I expect provenance to become a larger part of software production as generation gets cheaper. A working output does not tell us which inputs entered it, what rights accompanied them or whether the resulting distribution meets those obligations. Those questions survive a passing test.

A second agent does not establish a clean room

REA's own installation guidance addresses a weakness in agent-based clean-room claims. Selecting a different project or agent profile changes tool discovery; it does not necessarily prevent shell, filesystem or network access to the analysis. The documentation calls for enforced isolation when the implementation environment must be unable to access the target and investigation material.

That is a substantive engineering requirement for the claimed process. Giving two agents different names or telling one to forget does not establish what information was available to it. Nor does isolation, by itself, settle every legal right.

PhotoCraft declares a clean-room policy based on public specifications and observed behaviour, with prohibitions on proprietary code and assets. That declaration is evidence of the policy. We have not independently audited every contributor's inputs or the barriers between analysis and implementation. I see no basis here for either an infringement accusation or a clean-room certification.

The project's own licensing also undermines the idea that IP has stopped mattering. Its code is offered under permissive licences, while its brand terms reserve the ArtCraft identity. Reusable implementation and protected identity can be parts of the same commercial strategy.

The incumbent can lose the interface and keep the bill

Microsoft provides a concrete reason to doubt a simple extinction story. Its pay-as-you-go Retrieval API preview meters supported tenant-data access and retains tenant, Azure, administrative and licensing prerequisites. A different agent interface does not remove the permissioned route to that data.

Its agent-consumption guidance also describes credits consumed during supported building, preview, testing and evaluation activity. A supplier can earn from agents before those agents even reach production. Neither document establishes Microsoft's eventual net revenue, but both show mechanisms for collecting a different bill.

Adobe has a similar opportunity in its Photoshop API, which exposes parts of an established editing engine through programmable workflows. Microsoft offers Excel workbook operations through Graph. An agent can reduce the human interface work while continuing to use incumbent machinery.

My view is that vendors will be pressured to explain what they control that remains worth buying. For some operations that will be little more than reproducible code. For others it will be a difficult engine, permissioned data, hosted coordination or a contractual commitment to deliver. Those positions have different prospects, even inside one company.

What I expect the agentic economy to change

I expect more businesses to combine owned software, open engines, incumbent APIs and specialist services around a piece of work. That gives the agent a different purchasing problem from choosing another application seat: which contribution is missing, who can supply it and what result will count as delivery?

This is the commercial direction behind agents buying services. I expect an agent's purchase to be judged by the contribution delivered. A supplier can keep earning if it accepts responsibility for difficult work that the business cannot economically reproduce. That is the premise of AI-native service businesses.

Maintenance remains part of that bargain. Our bounded implementation avoids much of Excalidraw's scope; someone extending it would have to decide which shapes, state and compatibility assumptions to support. Agents may reduce that work, but this experiment does not price it. A more granular market creates more choices about who owns those responsibilities.

I think the subscription will survive wherever the continuing service earns it. What will weaken is the assumption that packaging a useful function inside a large application entitles its owner to collect the same rent indefinitely. I expect businesses to own more of their execution logic and keep paying for the dependencies they cannot replace economically.

Joel Chan is the founder of Agentic Economy. Prepared from a firsthand, source-informed experiment and primary-source research on 14 October 2026.