A new era for Curiosity Studio: the foundation and the factory

Rafael

• 2026-10-28

The way we make software changed more in the last twelve months than in the five years before. In October 2026, a coding agent wrote 243 of the 275 commits to Curiosity Studio's main branch, and one of us reviewed and merged each of them. Our public changelog listed about two new features a week in the second half of 2025. Between 7 September and 20 October 2026 it listed seventeen a week.

This post is about what we think that means for the companies we build for and what we built because of it. It is also about why we are excited about what comes next.

Software got cheap to write

Barry McCardel, who runs Hex, wrote this week in A new era for Hex, and data:

I think it is true that a lot of software categories will effectively die over the next couple of years. But I also believe many will combine and be reborn into new shapes.

His post is about BI. We see the same thing in the internal tools of industrial companies: the quality tracker, the supplier review, the deviation form, the report a team pays for per seat and uses for one workflow. A coding agent can now write the screens of any of them in an afternoon. So the question at a license renewal is changing from "can we build this?" to "why are we still paying for it?".

Writing was never most of the cost, though. Chris Gregori said it plainly in January in Code is cheap now. Software isn't: "code has become cheap, but software remains incredibly expensive." A licensed tool comes with a data model, connectors to your other systems, access control, hosting, upgrades and someone to call. Only the screens got cheap.

What enterprises keep asking for

In February Namanyay Goel argued in AI is killing B2B SaaS that customers now feel they can build a replacement for the software they rent. His advice to vendors was to remind them what that simple tool would also need: "auth, permissions, backups, uptime, and compliance." In a recent discussion around a funding round in August, a reply put the adoption question the same way: "Adoption of AI application building technologies in most enterprises is much more about governance and security than it is about any particular coding feature."

That matches what we hear from quality leads, IT and security in aerospace, rail and manufacturing. The people we talk to do not doubt that an agent can write the app. They ask where the data lives, who sees which record, who approved the change and who runs it next year. Our whitepaper The app is the easy part collects the incidents that happen when those questions go unanswered.

A strong foundation speeds AI up

The usual picture is that governance slows AI down. We think the opposite holds when the governance is built once, underneath every app, rather than rebuilt inside each one.

That is what Curiosity Studio is. Connectors bring records from more than 70 systems into one typed graph: tickets, part records, maintenance logs, supplier notices. Who may see a record is synced from the source system and checked per record at query time. A tool generated on Studio cannot show anyone a record the source would not. Search and AI run on the same graph, with the model you choose, on your own infrastructure.

On a foundation like that, the first tool pays for the connectors, the schema and the access groups, and every tool after it reuses them. Security reviews the platform once, and each new tool is a diff they can read. We believe Studio is a strong foundation for enterprise AI adoption. The best evidence we have is what it lets an agent do in an evening. One built a non-conformance application with access per program and division, between ordering dinner and paying for it. Another built an aviation market intelligence app that reads 248 news feeds and writes a daily brief.

AI factories

NVIDIA uses "AI factory" for a data center whose "primary product is intelligence, measured by token throughput." We use the word for something a company runs on top of that: a line that turns a team's request into internal software in production, week after week, and replaces legacy and expensive tools one at a time.

We expect most large companies to run one within a few years. What separates a factory from a lab is repetition: the tenth tool is built the way the first one was, with the same checks, and all ten keep running. So a factory is judged by what reaches production and stays in use, not by what it can prototype.

The foundation, the factory, and how the work comes through

We built the pieces of that line ourselves:

• Curiosity Studio is the foundation: the context graph, the permissions, the models and the audit trail every tool inherits.
• Curiosity Orchestrator is the factory's foundation. It gives each team, project or customer its own Studio. You deploy it once, iterate quickly, and graduate each tool to production when it is ready.
• Sudo and curio are how the work comes in. An administrator asks Sudo for a change, and a developer and their coding agent ask through curio from a terminal. Both build it in the same sandbox and stage it as a diff, and nothing applies until a person approves it.

If you run models on your own GPUs, Spark serves them behind OpenAI and Anthropic compatible APIs, so Studio uses them like any hosted provider.

From months per feature to features per day

For most of Studio's history a large feature was a project measured in months. Here is what our public changelog counted, one file per weekly release and one entry per change:

Seventeen features a week is about 2.4 a day, weekends included. Three days from October, by the time each pull request was merged, Munich time:

• 18 October: built in web search providers at 17:10, image generation and editing providers at 20:49, and a settings page for the PowerPoint themes assistants build decks with at 22:00.
• 22 to 23 October: cluster mode, where the primary role moves between servers by handover, election or forced promotion without reloading the graph, in three pull requests over twelve hours.
• 26 October: voice control, with on server speech to text, dictation and the "Hi Sudo" wake word, in four pull requests between 18:30 and 23:36.

The October release overview has the rest. What made this possible is the same process we sell: an agent writes the change, a build checks it, a person reviews it and merges it. As writing gets faster, review sets the pace, and that is where a factory should be slow. A strong foundation is what lets it be fast everywhere else.

What comes next

We are excited about the years ahead. Software that a company could only rent is becoming software it can own. It is shaped to how its teams work, on data the company already has, inside permissions it already runs. We built Studio for that.

To try it, install the free developer version and give it one tool your team pays too much for. Or book a demo, and we build it with you on data shaped like yours.

Further reading

• A new era for Hex, and data, Barry McCardel, Hex. Why software categories will die and be reborn, from the BI side.
• Code is cheap now. Software isn't, Chris Gregori. Where the cost of software went once code got cheap.
• AI is killing B2B SaaS, Namanyay Goel. The vendor side of the same shift, and what a tool a customer builds still has to handle.
• Software is changing (again), Andrej Karpathy at Y Combinator. Natural language as a programming interface, and the week between his demo and a real app.
• Building AI factories that deliver, Curiosity. A 30-page paper for CIOs and heads of IT: the six stations a request passes through, what every tool inherits from its foundation, and how to pick the first tool to rebuild.