Optimizing UX and AX: Eight Lessons From Building for AI Agents
Written by Keaun Amani | Published 2026-9-30
Written by Keaun Amani | Published 2026-9-30
For years, software teams have invested in UX: the experience people have when they use a product. As AI agents begin using those same products through tools and APIs, there’s another experience to think about. At Neurosnap, we call it AX: Agent Experience.
I’m the founder and CEO of Neurosnap, a platform that makes advances in drug discovery, molecular biology, and chemistry accessible to researchers. Over the past several months, we’ve been rolling out our MCP server to clients around the world, including leading pharmaceutical companies and Fortune 500 organizations working across life sciences, agriculture, and materials science.
One lesson has come up repeatedly: giving an agent access to a tool doesn’t mean it knows how to use it well.
Neurosnap can be a demanding environment for an agent. There are hundreds of tools, thousands of settings, saved jobs, input files, generated results, and relationships between them. A good human interface helps researchers navigate that complexity. Agents need help too, though they get it through tool descriptions, schemas, examples, responses, and errors.
Here are eight things we’ve learned so far.
Before an agent can use individual tools, it needs to understand a few basic things about the platform. What is a job? How do you retrieve its results? Which actions can consume credits?
A short orientation can answer those questions without sending every tool description and setting into the agent’s context at once. Too much information up front makes the useful details harder to find and increases token costs. We’ve had better results starting with the essentials and giving agents a way to find more detail when they need it.
A researcher can browse a menu, scan categories, and open a form. An agent also benefits from taking things one step at a time: find the relevant capability, inspect how it works, then use it.
That matters on a platform with many related tools. If someone asks an agent to review past results, the agent needs to find the tools for listing jobs, reading their details, and retrieving their files. It shouldn’t have to work that out from a flat catalog dominated by tools for submitting new jobs.
The aim is to help the agent find the next useful action while keeping the rest of the platform discoverable.
“Submit a job” tells an agent what a tool does, but not enough to use it reliably.
It also needs to know which inputs are required, which are optional, what defaults apply, what limits are enforced, and how to supply files. Examples help when an input is easy to misunderstand. We’ve seen agents understand a scientific request but stumble when attaching a file or configuring a more advanced workflow.
That information needs to be close to the tool itself, much like the guidance a researcher would expect from a well-designed form and its documentation.
An agent can try a search or list files at little cost. Submitting a job is different: it can start real work and consume credits.
A validation step gives the agent a chance to check the complete request before submitting it. It can catch missing inputs and incompatible settings without creating a partial or diagnostic job. The agent also needs to know what a successful submission returns, including the job ID it should report to the user.
That makes the experience better for the person who asked for the work too: fewer surprise charges and a clearer account of what happened.
It’s easy to focus an early tool set on creating things and give less attention to inspecting them. But an agent that can submit a job also needs to be able to retrieve the results.
The gap becomes obvious when someone asks it to compare two completed runs. Filenames alone aren’t enough to support a structural comparison.
Listing, reading, and downloading results deserve the same attention as submission. Agents need reliable access to the underlying data and guidance on when to inspect it before making a claim.
An error that says only “something failed” gives an agent little to work with. Exposing internal implementation details doesn’t help the user either.
A useful error explains, safely and specifically, which input was rejected, what constraint it violated, and whether any action took place. If a submission failed and no job ID was returned, the agent needs to know that. It can then tell the user what happened and decide whether a retry makes sense.
An agent’s working environment is temporary, but a user’s files and results need to remain accessible. That distinction matters when an agent writes a report and includes an internal file path in its response. The path may work for the agent but lead nowhere for the person reading the answer.
We’ve learned to treat published files as product artifacts, with links and viewers the user can access. We’ve also learned not to load every saved file into every new agent session. A focused set of relevant files, along with a searchable catalog, gives the agent what it needs without filling its workspace with unrelated material.
A successful tool call doesn’t necessarily mean the user got what they needed.
Did the agent retrieve the right files? Did it submit the requested configuration rather than a partial one? Did it report the correct job ID? Did it distinguish a completed computation from a scientifically convincing result?
These are the questions we ask when reviewing agent behavior. The answers can point us toward a missing retrieval tool, an unclear constraint, a weak example, or an error that didn’t give the agent enough information to recover.
AX is the path an agent takes through a product on a user’s behalf. When that path is clear, the human experience improves too: actions are more reliable, costs are more predictable, and results are easier to verify.
As agents become a more common way to use scientific software, I expect teams to give tool catalogs, schemas, examples, and error messages the same care they give pages and forms. The interface is different, but the design question is familiar: can the person—or agent—understand what to do next and trust what happened?
By Danial Gharaie Amirabadi
By Keaun Amani
By Keaun Amani
By Keaun Amani
By Keaun Amani
By Keaun Amani
Register for free — upgrade anytime.
Interested in getting a license? Contact Sales.
Try Free