AGENTX · 2025
Overview
AgentX is a no-code AI agent platform that enables businesses to build, deploy, and orchestrate AI agents without writing code. It helps teams automate repetitive work through customizable AI workflows, making advanced AI accessible to both tech and non-technical users.
Along the way, I developed the Trust Stack—a design framework that helped the team build trustworthy AI experiences across configuration, execution, and multi-agent delegation in future product development.
AgentX’s Product Hunt launch and a post-launch photo with the CEO and team
Launch feedback exposed the next UX problem: builders could create a team of agents, but couldn't follow how the agents divided work or reached an answer.
I turned that gap into the next design focus—making multi-agent behavior easier to understand and supporting a 56.4% retention rate.
The entry point had to work for someone who's never touched an API. I designed a single guided flow — LLM choice, personality, skills, knowledge — that reads like filling out a form, not writing a program. This was never the hard part of the product, but it had to be effortless for everything after it to matter.
Agent Building flow
AgentX's real differentiator wasn't one agent — it was letting non-technical people assemble a team of agents that hand off work to each other, with a manager coordinating the rest. I designed that as a visual, drag-and-drop flow: connect agents, assign one as the manager, done. No YAML, no config files, no orchestration logic to write by hand.
Drag and drop Multi Agent flow
Once a team of agents was live, “easy to build” stopped being the problem. The real question became: can a person watching this actually follow what their agents just did, and why one agent handed a task to another. I designed the reasoning view specifically to answer that — not as a debug log, but as a plain-language window into how the team just did its job.
Multi-agent collaboration unfolding in Chat View
Using a familiar organizational model made delegation and task ownership legible at a glance, without asking users to learn a new mental model for how one AI coordinates others.
Opening the Reasoning panel to follow the team’s work
The first-glance summary preserves agent ownership, tool usage, and key actions; expanding the panel reveals handoffs and implementation details without overwhelming the default view.
Motion used as an information layer across Chat, Reasoning, and system feedback
Chat: status motion makes hierarchy, parallel work, and ownership clear.
Reasoning: key actions stay visible; deeper evidence appears on demand.
Thinking: the AgentX mark signals that the system is working.
Everything above solved a version of this product. The last piece solved a version of me as a designer — turning “read user comments after launch” into a repeatable method for finding the next real problem, one the whole team could pick up without me in the room. More on that below.
Designed Post-Launch Framework
Building an AI agent system from scratch typically takes a team of five, three months, and might not even work at the end. AgentX's builder flow covers that same complexity — model selection, memory, tools, third-party integrations, multi-channel deployment — split across four tabs: General Info, Knowledge, Tools, and Deploy. None of them gate the next one. Only a couple of fields per tab are truly essential; everything else defaults to something reasonable, so a first-time user can fill in the minimum, skip whatever doesn't apply to them — most agents don't need custom tools on day one — and deploy in about two minutes. Anything more advanced, like custom tools, doesn't sit in the main flow at all: it's a deliberately low-emphasis button that opens a focused modal, so the option exists without competing for attention with the handful of fields that actually matter to get started.
Building flow
Multi-agent delegation is a new pattern with no existing precedent — no “shared doc” or “group chat” equivalent yet. I gave agents roles people already understand, like Manager and Reporter, and used an org chart's shorthand — indentation, reporting lines — so hierarchy reads at a glance, not guessed from unlabeled boxes. It wasn't my first direction — more below.
Visualizing delegation through familiar hierarchy
I didn't want the Product Hunt comment thread to be a one-time source of insight — I turned reading it into a repeatable loop: pull user language straight from comments and interviews, sort it into real problems versus noise, design and test a few directions against it, validate with users, ship, and start the loop again on whatever surfaces next. I documented this as a living process in Notion rather than a one-off retro, specifically so it didn't depend on me to run it.
This was the exact problem the launch surfaced: agents splitting up a task meant the interface listed every action each one took, so a single weather check showed up as five identical lines. More detail wasn't building trust — it was burying it. Instead of removing transparency, I redistributed it. Critical information stayed visible, while implementation details moved behind progressive disclosure.
Research
Across builder interviews before launch, the same pattern kept surfacing no matter how experienced someone was with AI tools: people could tell me exactly what they wanted their agent to do, but not what to do next to get there, or what their agent was actually doing once it was running. That repetition is what told me this wasn't a one-off confusion — it was a structural gap in the product, not a copy problem.
Interviews told us people didn't trust the reasoning panel and often stalled before ever finishing setup. Hotjar told us why: session recordings showed users scrolling straight past the reasoning panel without reading a line, and heatmaps showed first-time builders dropping off partway down a long single-page settings flow, well before reaching anything close to “done.” Watching behavior instead of just listening to opinions is what turned a vague “this feels confusing” into two specific, fixable problems.
.png)
Hotjar Heatmap of V1 reasoning
Before redesigning a single label, I ran a closed card sort against a fixed visibility hierarchy with three users — the same technique content strategists use to prioritize content for responsive layouts, applied here to progressive disclosure instead of screen size. Every category of information the panel could show — Goal, Reasoning log, Tool execution, Agent Activity, References — got sorted independently into one of three tiers: Always visible, Progressive, or Hide, then reconciled where their sorts disagreed.
All five had been treated identically before: always visible, all the time. Only Goal actually earned that treatment across all three users. Reasoning log, Tool execution, and References moved to progressive disclosure — there on request, not by default — and Agent Activity, which turned out to matter mainly to people debugging the system rather than builders checking trust, was removed from the default view entirely.
All of our sorted insights
For delegation legibility specifically, “give agents an org-chart structure” wasn't the obvious first answer — it was the one that survived testing. I explored a timeline view (agents plotted against a shared clock), a chat-transcript view (delegation shown as messages between agents), a flowchart view (boxes and arrows redrawn live), and the manager/reporter hierarchy. I put rough versions of all four in front of builders.
A few of the versions along the way
I didn't want the Product Hunt comment thread to be a one-time source of insight — I turned reading it into a repeatable loop: pull user language straight from comments and interviews, group it into real problems versus noise, design and test a few directions against it, validate with users, ship, and start the loop again on whatever surfaces next. I documented this as a living process in Notion rather than a one-off retro, specifically so it didn't depend on me to run it.
The redesign simplified onboarding, reduced decision friction, and made complex multi-agent workflows understandable enough for anyone to use. Those UX improvements translated directly into measurable product growth.
Beyond product usage, the platform achieved a 56.4% retention rate, acquired 4,000+ organic users with zero paid marketing, expanded to 136 countries within two months, and became a key contributor to the company's successful multi-million dollar funding round.
The numbers that moved
.png)
More visibility isn't the same as more trust. The right amount of detail depends on who's looking and what they're deciding — not on how much the system is capable of showing.
A framework, or a process, only proves itself once you're not in the room. The real signal wasn't the launch — it was the team still reaching for both, unprompted, months later.
This is just a snapshot of the entire design process.
Reach out for the full story.
Making revenue, risk, and account health readable from one trusted screen.
