Toolmaking

Agentic workflows in production

By Vignesh Prasad, Principal Product Designer at Ebury

I design and build. Doing both myself was sometimes slow, and the context switching had a cost of its own.

The bigger drag was real data. Testing an idea properly meant standing up backends, plugging in APIs, wiring up the plumbing. A lot of time went into engineering rituals that were not the point when what I wanted to know was whether the product idea held up.

Agentic tools have mostly closed that gap.

Ebury Hedge

Ebury Hedge is the platform businesses use to manage currency risk. Exposures, trades, hedging policies, performance and credit conditions in one place, with trade instructions to review and approve.

Forwards, options, non-deliverable forwards and spot, across 60 or so currencies.

I lead design for it. We started in January 2025 and built it from scratch, and it is already generating meaningful revenue and growth.

The hard part was never the interface. It was that most of our clients do not have a treasury team.

A large corporate has people whose whole job is currency risk. An SME importing from three countries has a finance director who already has a full week.

The tools had to make sense to people who are not currency specialists:

  • Show a business its actual exposure, not an abstract risk
  • Let it model strategies side by side and see the outcomes before committing

None of that can be validated in Figma.

A static mock of an exposure chart tells you nothing about what happens when a client has eleven currencies, a policy that skipped a month, or a hedge ratio above 100%.

From sandbox to studio

So I built a prototype sandbox. A lite version of the Hedge platform I could run locally and plug real data into.

Every visualisation and simulator went through it before anyone built it properly, tested against real numbers and the edge cases that break charts.

I built it for myself. Other people started asking to use it.

I moved it into the internal ops platform and improved it until stakeholders could use it directly. That became Prototype Studio.

The ops platform runs on a micro-frontend architecture. We made a decision early to share one library with the client-facing Hedge platform: same design system, same visualisations, same simulators.

Internal and client surfaces use the same components, so they do not drift apart.

The people using it are not designers. They are relationship managers, ops, risk and commercial, the people who talk to clients daily and come back with a sharp idea and no way to show it.

Prototypes run on real data from internal services and inherit the design guidelines automatically. What comes out is close enough to production code that shipping it is a decision rather than a rewrite.

It also connects to Figma through a local MCP server, so a design can become a working prototype without anyone hand-coding the UI.

Discussions about whether something would work got shorter, because building it was usually faster than debating it.

What carries across

I run personal projects in my labs to test agentic workflows, tools like Air.dev, and multi-agent sessions that run overnight in sequence. I keep honing them as new ideas and features emerge.

Four habits have held up:

  • Write the spec first and treat it as the thing that is true.
  • Build your own local brain with tools like Graphify.com and OpenSpec.dev
  • Put the design system where the speed happens, so moving fast cannot produce something off-brand.
  • Get real data in front of people early. A working prototype ends an argument a deck would have extended by two weeks.
  • Keep the quality gate strict enough that shipping stops being a decision.

Most of what I do now is building the tools that make the actual work faster.