Inspiration
Kigumi didn't begin as a product.
It began as a system I needed for government contracting, where every decision, every source, and every deliverable carries consequences. Early AI tools were powerful, but they struggled with repeatability, traceability, and governance. I found myself spending more time proving how an answer was produced than actually using it.
About two years ago I started experimenting with workflows built from simple automation tools and early AI models. The goal wasn't to build software—it was to build a process I could trust. As AI capabilities accelerated, that process evolved into Kigumi.
Today, Kigumi is a governed execution workspace designed to help organizations transform AI conversations into structured, reviewable, replayable work.
What it does
Instead of treating AI as a one-shot chat interface, Kigumi creates governed work sessions.
A user can attach source material, authorize grounded work, prepare drafts, route work for review, promote approved work into a governed Session, and preserve trust, lineage, and replay throughout the lifecycle.
Every important step is designed to be observable, repeatable, and reviewable.
How we built it
One of the most interesting parts of this project is how it was built.
Long before Codex became a standalone application, I was already organizing development around specialized engineering workflows and governance concepts. During OpenAI Build Week, Codex became an integral part of that process.
We used Codex throughout development to:
inspect and navigate the live browser, diagnose backend and frontend integration issues, verify replay and deterministic workflow behavior, help implement production code, review architecture, and even help prepare the demonstration you are watching.
Rather than treating AI as a code generator, we used it as a collaborative engineering partner inside a disciplined development workflow.
What we learned
The biggest lesson wasn't about AI models—it was about governance.
Powerful models are becoming increasingly accessible. The challenge is no longer simply generating an answer. The challenge is helping organizations understand:
what happened, why it happened, what evidence supports it, whether it can be replayed, and when human review is still required.
That realization shaped every major architectural decision in Kigumi.
Challenges
The hardest part of Build Week wasn't implementing AI.
It was proving that the system behaved correctly under real execution.
We built permanent certification harnesses, exercised the governed lifecycle against a real Mongo-backed runtime, verified deterministic replay, validated lineage and trust, hardened customer-safe projections, and systematically removed every verified blocker before reaching a complete backend certification.
The result isn't just a demo.
It's a governed execution substrate that we can continue building on.
What's next
Build Week established the foundation.
From here we plan to continue developing:
governed semantic conversations, multi-model orchestration, the Model Council, vertical workflow packs, adaptive drafting, and continuous self-improving orchestration built on the same governed execution principles.
We believe the future of AI isn't just better models.
It's helping organizations use those models in ways they can understand, trust, govern, and continuously improve.
Log in or sign up for Devpost to join the conversation.