Overview
Five projects, since 2023
Dialexis2023
Video translation
Archived
noted2023
Video summarization
Archived
Solon2024
Conversational commerce
Archived
Kivo2025
Data analysis
Active
Orama2026
Web automation
Active
Timeline
Projects and models by date
2023202420252026
Dialexis
noted
Solon
Kivo
Orama
next
self-hosted open source
first hosted LLM
tool calling
multi-agent + sandbox
self-improving agents
context and memory
Projects
Each one in detail
01 — 2023
Dialexis
Dub any video into another language in the speaker's own cloned voice, with matching lip movement.
A full media pipeline: pull a video, transcribe and translate the speech, regenerate it in a clone of the original voice, then re-render the face so the lips match. Built with open-source models, before any of this was an API you could call.
Archived
Mar — Dec 2023
Findings
Real footage was the hard part. Multiple speakers meant adding pyannote diarization and word-level alignment before anything could be translated, and Wav2Lip's output had to have GFPGAN run over it to be presentable at all. Every stage that made a clip work added processing time and another way to fail.
The lesson was focus. I was solving voice cloning, translation and lip sync at once when only one was actually hard — buying the voice from ElevenLabs and putting everything into lip sync would have got further.
01Models
Techniques
- Voice cloning from ~30s of audio
- Speaker separation and word-level alignment
- Speech-to-speech translation
- Lip sync, and face repair on its output
- Model testing — 3 TTS, 3 lip-sync engines
Stack
02 — 2023
noted
Turns a long video into a structured summary where every point links back to its timestamp.
Paste a URL, get thematic sections with key points — each carrying a [[hh:mm:ss]] citation you can click to jump to the source. Started as a Flask script, then rebuilt as a SaaS with auth, billing and usage limits. Built during Buildspace.
Findings
First time I put an LLM in a product, after a year of self-hosting models. The output had to be checkable, so every point the model produced carried a timestamp back to its place in the source.
Also the first thing I shipped end to end — login, payments, usage limits, a real deployment. Built on Wasp, which I have used on every full-stack project since.
02Models
Techniques
- Long-context summarization with structured output
- Timestamp citation on every point
- Keeping the model to a fixed output format
- Usage limits per user
Stack
03 — 2024
Solon
An AI sales agent that sells your catalogue over Instagram and WhatsApp DMs, cart to checkout.
Wired into Meta's messaging APIs. It searches a live catalogue, tracks inventory, builds a cart and closes with a Stripe payment link — then hands off to a human when it should. Ten tools, running on two parallel agent implementations.
Findings
Cost decided the model. GPT-4 existed, but only GPT-3.5 was affordable, so the work went into making a weaker model hold up: tool use, per-customer context from order history, and a human check before the agent replied. On Claude there was no tool API at all, so I wired the XML by hand.
Around it sat the platform — a merchant dashboard, automatic Stripe provisioning, and Instagram and WhatsApp integrations pushed past what those APIs were built for.
03Models
Techniques
- Tool use, written by hand before Anthropic had an API for it
- The same tools running on two model providers
- Customer order history and details in every reply
- Human-in-the-loop approval before the agent answers
- Handing the conversation to a person
- Automatic Stripe setup per merchant
- Cart state held across DM conversations
Stack
04 — 2025
Kivo
Upload messy data, get a finished analyst report — five specialist agents do the work.
Rather than one model doing everything, five specialists divide the job: one researches, one writes Python in a sandbox, one builds charts, one handles tables, one edits the document. The output is a shareable report, not a chat log.
Findings
Context was the constraint, so the work split into sub-agents — which also let them run in parallel. The whole thing sits on a custom text editor, so how you hand a document to an agent and let it edit in place took real iteration.
Messy spreadsheets were the hardest part: what do you show an agent from a dirty Excel file so it can clean it cheaply? Passing whole files through a cheap model to clean them without code didn't work. Generated code in a sandbox did, and was safer and faster, with streaming to cover the latency.
04Models
Techniques
- Sub-agents for context management
- Running agents in parallel
- Sandboxed execution — agents write and run real Python
- Spreadsheet cleaning and editing
- Agent editing inside a custom text editor
- Search over uploaded files
- Streamed output to keep the interface responsive
Stack
05 — 2026
Orama
An agent that lives inside your web app, sees the page, and clicks through it for the user.
A browser-automation agent shipped as an embeddable widget. It reads the live DOM and drives the app toward a goal stated in plain language — in any browser, without the developer-protocol access most automation tools rely on. After each run a reviewer inspects what happened and writes reusable skills, which later runs retrieve.
Findings
Cost was the whole problem. The goal is to run free for every user on a client's platform — many runs, a cheap model — and passing a page's DOM as context is expensive. Most of the work went into which parts of the DOM actually matter, how to identify what is interactive, and how to manage context. Sub-agents didn't win; cached tokens and summarization did.
Other tools control the browser and drive it through CDP. This had to work in any browser, so none of that was available. The reviewer covers the rest — once the agent works out how to do something in an app, it should know it the next time.
05Models
Techniques
- Cutting a live DOM down to what the agent needs
- Identifying interactive elements without browser-level access
- Context held with cached tokens and summarization
- Getting a complex task to work on a cheap model
- A reviewer that turns finished runs into reusable skills
- Finding the right skill before a run starts
- Token and cost tracking per run
Stack