Tokyo Tech Talks #2: What Representation Makes Possible
A look back at Tokyo Tech Talks #2 in Ebisu — Mitchell Carroll on lossy compression, and Daniel Leuk on how KD and KS open up better ways to represent the world in software.
On March 31, we held Tokyo Tech Talks #2 at Build+ in Ebisu. The theme was Encoding the World: how reality becomes data, what gets preserved, and what gets lost along the way.
It turned out to be a good theme for the room. The talks came from different directions, but they all pushed on the same question: representation is never neutral. The way we describe the world shapes what software can understand, what systems can check, and what builders can move quickly on.
The Talks
Mitchell Carroll — Data Is a Lossy Compression of Reality
Mitchell Carroll, Senior Product Manager at Mercari, made the idea concrete fast. His talk centered on a simple point: software never works with reality directly. It works with a reduced representation of reality, and every reduction throws something away.
One of the best moments of the evening was an exercise he ran with the room. People split into small teams. One person described a familiar object without naming it, while the others tried to draw what they thought it was. Even with something common, details fell out quickly. The exercise made the point better than any abstract definition could: once information is compressed into language or data, reconstructing the original is harder than we think.
Mitchell’s framing was useful because it applies far beyond machine learning. Product metrics, database rows, event logs, embeddings, UI state: all of them are choices about what counts as signal and what gets treated as noise.
You can download Mitchell’s slides here: Data Is a Lossy Compression of Reality.
Daniel Leuk — Languages for Structured Reality
Daniel Leuk, CEO of Ikayzo, talked about the Ki family of languages and the design goals behind Ki Declarative (KD) and Ki Script (KS).
KD is a concise, typed declarative language meant for structured data such as configuration and serialization. KS builds on the same shared types and structures, but moves into scripting, with features like parameter constraints and units of measure. Together, they reflect a broader idea that fit the event perfectly: better defaults at the language level can make real-world data easier to express and easier to reason about.
Instead of forcing everything through generic strings and JSON-shaped conventions, Daniel showed what becomes possible when the representation itself carries more meaning. For people who want to dig deeper, the Ki documentation is worth a look.
Keenan Thompson — Implementing KD in Go
As part of that discussion, Daniel also brought in Arcnem AI CEO Keenan Thompson to talk through some of the implementation work around Ki.KD-Go, the Go implementation of KD.
Keenan described starting with the core he understood well, then taking advantage of better models as they became useful for the job. A key inflection point was bringing tests over from the Kotlin implementation. Once the project had that growing body of test coverage, the work sped up: AI could help port behavior, and the tests made it much easier to see what was correct and what still needed iteration.
A Shared Thread
What connected the evening was not just “data” in the abstract. It was the idea that how we encode the world determines what we can do next.
Mitchell focused on what gets lost. Daniel focused on what better structures can preserve, and the implementation discussion around Ki.KD-Go showed what it looks like to turn those ideas into working software. Different talks, same underlying lesson: if the representation is weak, everything downstream gets harder.
Looking Ahead
Tokyo Tech Talks is still early, but the shape of the community is becoming clear. Small room, practical ideas, thoughtful people, and enough time after the talks for real conversation.
If you missed this one, keep an eye on upcoming events.