Simplicity isn’t the absence of complexity. It’s the result of carefully managing it.
There’s a moment when a product goes from impressive to useful - and it almost always comes down to friction. Or more specifically, the lack of it.
You don’t need tooltips for everything. You don’t need to explain every system.
But you do need to make sure things feel predictable, responsive, and legible.
That’s what we mean by invisible UX:
Removing just enough of the surface to make the core feel obvious.
And when you’re working with modular AI agents, that’s not easy.
The Complexity Beneath
An Anjin agent isn’t a static script or a one-off GPT wrapper.
A single run might involve:
- Tool lookups (e.g. live search, external APIs)
- Chained context from previous agents
- Role and plan-based gating
- Custom logic to format inputs or outputs
- Streaming responses, retries, fallbacks
- Logging and audit trails
That’s all happening behind the scenes.
But to the user? It just looks like: “Agent is running…”
That’s the point.
We Don’t Hide Complexity. We Handle It.
We’re not trying to “dumb things down”.
We’re trying to shield users from unnecessary choices while still giving them power when they need it.
So we:
- Show progress only when it’s meaningful
- Delay user decisions until we can offer context
- Auto-handle retries, error sanitisation, and tool fallbacks
- Render structured outputs that can be edited, reused, or redirected
You’ll see complexity when it helps.
Otherwise, we keep the noise out of the way.
Where This Shows Up in the Product
A few examples of invisible UX in Anjin:
- Agent chaining happens server-side, with no config required
- Custom tools are injected only when needed - users don’t need to choose them
- Errors are caught before the user sees a failure, and re-attempted if safe
- Context memory is passed where relevant, but never assumed globally
- UI updates reflect underlying logic: if an agent needs confirmation, you’ll be asked. If not, it just moves
Everything is intentional.
And if we’ve done it right - you don’t notice most of it.
Why This Matters
Users don’t want to learn how your system works.
They want to feel like it works with them.
And when something goes wrong, they don’t want an error code.
They want a next step.
Invisible UX means we’re not asking people to become AI operators just to get something done.
It means they can trust the system to carry some of the complexity for them.
That’s when products become sticky - not just functional.
Final Thought: The Best Tools Feel Obvious
When someone says, “I don’t know what’s different, but it just feels cleaner” - that’s the sign we’ve done something right.
Invisible UX doesn’t mean there’s no system underneath.
It means that the system respects the user’s time, energy, and attention.
That’s how we build Anjin.
Not by showing off everything it can do.
But by making it feel like less work - without ever being less powerful.
Curious how we make complex agents feel simple to use?
Join the community or read more about how we’re building quietly ambitious systems:
- Inside Anjin #13: The Myth of the Universal Agent
- Inside Anjin #12: Augmentation Over Automation
- Inside Anjin #06: The Modularity Mindset
