MENU
AKARII
VISIT WEBSITE
YEAR
2025 - 2026
ROLES
Founder
Product Designer
Engineer
PROJECT SCOPE
Product Strategy
Product Design
Full-Stack Development
AI / Agent Architecture
DESIGN TOOLS
Figma
TECH STACK
Next.js
React
Convex
TypeScript
Tailwind
Claude
Fly Machines
OVERVIEW
An AI teammate that does the work.
Akarii lives in your team’s chat. You talk to people and to the agent in the same place, and the agent goes and does the work: it spins up a cloud machine with your repo, writes the code, runs the tests, and opens a pull request, then reports back in the thread. I built all of it solo, from the product and interface down to the agent architecture underneath.
THE PROBLEM
A demo is easy. An agent that actually works is not.
Anyone can make an agent look impressive once. The hard part is the part nobody films: reading the right files, writing code that fits the codebase, telling apart the people in a thread, and knowing when to stay quiet. That is where the work went, and it is the difference between a teammate and a party trick.
DELEGATE THE WORK
From conversation to a pull request.
You delegate in plain language. Akarii answers first, then gets to work: it spins up a cloud machine with your repo, reads the codebase to see how the piece fits, and makes the change through typed tools, running commands, reviewing its own diff, and opening a pull request. It has to review the diff before it can open the PR, and it works on an isolated branch. Every step streams into the same thread, so you follow the work instead of waiting on a black box.
KNOWING WHO’S IN THE ROOM
A teammate has to know who is talking.
In a real thread the agent is one voice among several. It has to track who said what, answer the right person, and not blur three people into one. I built the conversation model so the agent always knows the participants, addresses them by name, and sends each reply or question back to whoever it was actually for, whether that is a teammate or another agent.
AMBIENT INTELLIGENCE
Knowing when to speak.
An agent that comments on everything is noise. Most of the design here is restraint, and most of that restraint is not the model’s call. Deterministic rules decide the bulk of it: no more than three interventions in a session, at least fifteen messages between them, a cooldown after it gets waved off. Only past those gates does a fast, cheap model judge whether the moment is worth it, and even then the agent can choose to say nothing. That split, what the harness decides versus what the model decides, is the part of agent building I care about most.
MEMORY THAT LASTS
Memory the agent can grep.
I built Akarii’s memory as a searchable file tree the agent reads with its own shell tools, with semantic recall alongside it. Language models are fluent with files and grep, so a real tree the agent can search makes its memory legible and durable across long-running work. The bet is that the agent should retrieve context closer to the way it reasons, and fall back on semantic search rather than lead with it.
BUILT IN THE CLOUD
Not trapped on a laptop.
The agent runs server-side, in a cloud machine that spins up on demand with your repo cloned in. The work does not live on your laptop, so you can kick off a task, watch it run, and merge from anywhere, even your phone.
CONNECTED TO YOUR TOOLS
Plugged into the team’s stack.
Akarii connects to the tools the team already runs on, acting through GitHub, listening on Slack and Discord, and reaching Linear, Notion, Sentry and the rest. It reasons over real product context instead of a sandbox, and you decide what it is allowed to touch.
THE FRONTIER
An app that improves itself.
The direction I am most drawn to: an agent that uses the product the way a person would, through a browser, notices what is broken or awkward, and opens a pull request to fix it. The pieces exist, browsing the app, critiquing it against what the product is meant to be, generating a patch, but the loop is not closed yet. It is the sharpest version of the question under all of this: how much can you hand to an agent, and how much do you keep.
WHAT I LEARNED
The dial between the harness and the model.
Building Akarii solo, across product, design, and engineering, the lesson that stuck was not about any single feature. An agent is a constant negotiation between a deterministic harness and a non-deterministic model: how much to constrain, how much to let it run, what it reads, when it acts. Tune that balance well and it feels like a teammate. Tune it badly and it feels like a liability. That balance is the work I want to keep doing.