One of the most memorable lessons from my career regarding designing and building user experiences, came during my time at 86 400, the neobank that later became ubank.
The lesson was simple: Building things takes time, and by the time you've designed, built and launched something for today's market, the market may have already moved on.
This was well before generative AI, when building mobile frontends required considerable teams and development time. Today, AI allows us to build much faster, but the technology itself is advancing just as quickly, opening up possibilities we haven't even begun to explore.
People don't necessarily know what they want until they're presented with something they hadn't imagined. The conversational interface did that for AI.
So the question I keep coming back to is: what does tomorrows user interface look like?
Models are becoming faster, cheaper and increasingly capable of generating visual experiences, animation, 3D and interactions. Smaller models can already run on personal devices, including browsers.
Google's A2UI 1.0, released on 11 November 2026, is another example of the direction things are moving, allowing AI agents to describe interfaces that applications can render.

I've written previously about why I think people will increasingly gravitate towards whichever interface helps them solve the most problems. I suspect that interface will be AI.
The idea
LLMs generate a stream of text. Sometimes that's text for us to read, sometimes it's code for something to execute, and sometimes it's structured output for another system to interpret.
What if the output wasn't intended for us to read at all?
Alternate possible interaction with LLM
The idea is to treat the entire output stream as a language intended for another system, rather than for us to read.
The AI and the receiving system share a common language, allowing instructions to be interpreted and acted upon as they're generated.
The receiving system can maintain its own state, which the AI can inspect and build upon without having to recreate everything from scratch.
In my experiment, that system is a browser, interpreting the stream into visual and interactive experiences. But the underlying approach isn't limited to browsers, or even graphical interfaces.
Revisiting an old experiment
I first experimented with this idea back in April 2025 using GPT-4.5, but the results were interesting, but crap to say the least.

Back then, models were not just fairly poor at coding, but intelligence-wise there was too much going on for it to "get working".
The tooling was also far more limited, and the kind of agent harnesses we have today were nearly non-existent.
I revived the repository a few days ago in November 2026, and Opus 5.5 instantly produced much more favourable results - well beyond what I expected.
The first thing I realised was that it could actually draw things surprisingly well.
So I kept adding more building blocks — shapes, lines, colours, gradients, animations and increasingly sophisticated controls. Each addition seemed to expand what the model was capable of producing.

Then I started wondering: what if the model could actually see what it had drawn, understand the current state and make adjustments to it?
That worked too.
And then I thought, what if I added voice, or a camera? What if I could use an iPad and pen to draw directly onto the interface, and have the model work with that as well?
What started as a one-way stream of instructions was gradually becoming something much more interesting.
The model wasn't just producing an output anymore. It could observe, respond and continue building upon an evolving experience.
And the best part is that I can use an AI subscription I'm already paying for to not just create, but experience these bespoke user experiences.
What can you actually do with this?
One of the things I've struggled with is explaining seemingly simple maths concepts to my daughter.
Things like division when she hasn't yet mastered her times tables, or how to solve division problems using addition.
ChatGPT has been genuinely helpful in suggesting different teaching methodologies, but the experience was still fairly linear. I'd get an explanation, try to demonstrate it myself, and repeat the process with the next question.
What I wanted was something more visual and interactive.
Something where I could take a photo of a homework question, work through it with her using a pen, and have AI guide the process without simply giving away the answer.

Extending this further
One thing I realised as I continued experimenting was that this approach doesn't just create a richer output experience. It also creates a much richer way to provide input to the model.
You can still use text, but now what you draw, write, select or move can carry additional context based on what's already being displayed.
For example, circling part of a maths problem, moving something on a diagram or adjusting a value on a chart can communicate intent without having to explain everything in words.
You could even combine a voice recording with the timing and sequence of pen strokes, so the model has more context about what someone was saying, pointing to or drawing at that particular moment.
And because the interface maintains its own state, the model can interpret these inputs in the context of the existing experience.
There's also nothing fundamentally limiting this to one model or one browser.
You could have smaller, specialised models generating instructions at a lower inference cost.
Or multiple models contributing to the same environment: one interpreting a camera feed, another reasoning about what should happen, and another generating instructions.
With shared state and a common time reference, the possibilities become more interesting. The interaction could become increasingly continuous rather than a sequence of isolated prompts and responses.
The receiving system could also be something entirely different from a visual canvas.
There's also a question about the way we've naturally gravitated towards getting AI to write code, then executing that code to create an experience.
That makes sense given the economics and history of software.
But as inference becomes faster, cheaper and more inteligent, how much of that intermediary programming layer will remain necessary?
Deterministic software will still matter for reliability, precision, timing and safety. But perhaps more of an experience could be generated and adapted as it's needed, instead of every possible interaction being programmed in advance.

What's next?
For now, I've been calling this experiment Conduit.
It's early, and there are still bugs and limitations to work through. I also don't think the underlying principle of machine-interpreted model output is particularly novel.
What's changed for me is how practical and expressive this approach has become with current models and tooling.
My intention is to share the idea, the language and a reference implementation so others can experiment with it, challenge it or take it in directions I haven't considered.
This follows naturally from what I wrote in my previous post about using AI to tackle unfamiliar problems, accumulating experience and building upon what you've learned.