Last week we introduced gedonus. This week's announcement is quieter, and it's for the people who found us before there was a website: the gedonus codebase is now private. The add-in you use doesn't change. The way we build it does.
Why we built in the open
What became gedonus started as two open codebases: a version-control layer for PowerPoint and a slide-generation engine. Keeping them public and permissively licensed was a deliberate choice, for two reasons.
The first was trust. The version-control side of gedonus is local-first: your decks are snapshotted, versioned and diffed on your own machine, and none of that history is ever uploaded. That is an easy claim to make and a hard one to believe: software that sits inside your most confidential documents doesn't get the benefit of the doubt. Publishing the code was the honest way to back the claim: anyone could read exactly what happened to their files.
The second was feedback. The earliest versions were shaped by the people who used them. What a version should capture, what a diff should show, which changes are worth flagging: that came out of conversations with early users, not out of a roadmap.
What changed
The center of gravity of the product moved. The early work was mostly plumbing: reading a deck, storing versions, computing diffs. Plumbing like that is worth keeping open: it builds trust, and it was never a secret.
The work now is different, and so is where the progress comes from. Over the last months, almost every real gain has come out of one area: LLM orchestration. A slide in gedonus is not a single model call. It is a pipeline of coordinated steps: a plan for the deck, a draft for each slide, a grounding pass that ties every figure back to the exact place in the source material it came from, and review passes that check the result, including visually, before a person ever sees it. Which steps, in which order, with which models and which checks: that is research in the plain sense of the word: we build variants, measure them against each other, keep what wins and throw the rest away.
The deeper that work went, the clearer one thing became: this orchestration layer is where gedonus wins, not the plumbing around it. What took months to learn is how to make those steps work together well enough that the output holds up in a finance workflow, and that learning compounds with every iteration.
It is also narrowing, on purpose. We are not building a general slide tool. We are building for finance workflows specifically: pitchbooks, IC memos, the documents where a wrong number costs more than a late deck. The templates, components and checks are increasingly specific to exactly those documents. Closed development lets us rebuild parts of that engine in days without treating every internal step as a public interface someone might depend on.
The honest part
Companies usually explain a move like this with "focus" and "velocity". Both are real here. The third reason is simpler: the orchestration layer is our competitive advantage. It took months of research to get right, it is the first thing a competitor would copy, and publishing it while we refine it would give it away. That serves us, plainly. We believe it also serves our users, because it is what lets the product go deep on finance instead of staying shallow on everything.
What doesn't change
We still keep nothing. Going closed source changes who can read our code, not what happens to your files. The deck file is never uploaded, versioning and diffs still run locally, and what a generation request sends to the model is discarded once the answer comes back: never retained, never trained on. The security page documents the boundaries.
Feedback still runs the roadmap. The loop that shaped the early product doesn't close with the source. If you work in decks all day, we still want to watch you use gedonus and hear where it fails you.
Most of the research goes public. When we measure something, like how decks are actually built, where AI-written numbers go wrong or what breaks when files pass through tools, we will publish the data, the method and the code in public repos anyone can rerun. Not all of it: the findings that feed directly into the engine stay internal. But the studies themselves are only worth something if they can be checked.
If you want to see what the engine produces today, book a demo and we'll show it live, inside PowerPoint.
