A no-code platform for AI agents, designed before AI could design.
Composabl (now Amesa) helps subject-matter experts build, train and optimize autonomous AI agents without writing code. 2023–2026
- Role
- Primary product designer for 2.5 years, at Semiflat. Discovery, UX, UI and the design system, directly with the founders.
- Goals
- Ship a no-code MVP in year one and give Composabl a product to raise on.
"The Semiflat designers took the time to learn the machine teaching methodology that drives our product. This is truly special."
Kence Anderson
Co-Founder & CEO, Composabl · about the Semiflat team
Agent Builder puts an agent’s whole architecture on one canvas, built by hand.
Perceptors read the sensors, selectors decide, skills act. We put those layers on one canvas, so the thing you look at is the agent, and every block opens where it sits. Composabl raised its seed on this screen.
perceptors → selectors → skills, on one canvas
The canvas is the agent: perception layer, selectors, skills, top down. Every block opens in the side panel, so configuring never leaves the overview.
Selectors matter most, they decide which skill runs. Their goals read as sentences, reach a speed, minimise battery use, because the people writing them are engineers, not data scientists.
One panel, three states: not configured, a sequence of skills, and the Scenarios tab showing where the selector is used. Every state designed before it was built.
Skills. One thing the agent learns, described the way an engineer talks.
Reach 55 km/h, keep battery use low, never cross the altitude limit: that is a skill, written as a sentence. There was nothing to copy, so the panel came from zero, implementation first, then the goal, then the lines it may not cross. It shipped like this.
The skill panel: implementation on top, then the goal as a sentence, then constraints. Variables from the simulator sit on the right, so the engineer never has to remember a name.
Connecting a simulator means naming its sensors. A flat list with a name and a description per variable was the simplest form an engineer could fill without documentation.
Scenarios lay out the situations an agent trains for as a fixed path.
A drone delivering food in wind, a machine sorting waste: the same steps repeat and the same steps fail. My first version was a timeline. It read well and added one more loose builder to a product that already had one, so I fixed it into three columns. My decision, and I am proud of it.
free timeline → fixed Kanban: Starting, Middle, Ending
The scenario flow in three fixed columns. Items connect across stages, the stages never move. That was the whole decision: a structure, not another builder.
Dragging a step into the Middle column. The same drag and drop as the Agent Builder, so one gesture works everywhere in the product.
Training takes hours. We show it on the agent, not on a dashboard.
The hard part was never the start button, it was knowing where a run is and what happened on the way. We proposed an event timeline per skill, and I put the whole panel on the agent, because what trains is what you look at. Shipped in the first launch.
Training details over the canvas: cycles used, skills trained, active simulators, and an event log that explains why a skill finished early. Charts per skill show the run as it happens.
Starting a run: pick the cluster, set the cycles, see how they split across skills. The platform proposes a cycle count from the agent’s structure; the engineer can override it.
Statistics decide which of your agents goes to the real machine.
You train several agents for one job and one of them gets the equipment. Cost sits next to performance, project to skill in one hierarchy; a manager reads the top, an engineer digs in. The founders questioned our proposal line by line, and that is how it got good.
Overview: ROI and training cost on top, goal performance per scenario for every agent below. The first screen a manager opens.
The performance table per agent and scenario, and the ranking that puts ROI next to battery use. Where the choice of which agent to deploy gets made.
Training sessions: each run with its cycles drawn as a graph, which skills moved the goal and which sensors mattered. The engineer’s view of the same numbers.
Takeaway
Composabl shipped as a no-code MVP in its first year, launched with its seed round, and lives on today as Amesa, in use and growing. The rule I took from it: not understanding a hard domain must never paralyze design, but you need enough of it, holistically, to know what you are building. I design things that have to work, not things that look like they do.
More screens from Composabl2023–2026
