SpendPilot

Inspiration

Companies use a lot of software, but choosing and buying it can take time. Someone has to compare products, check pricing and security requirements, stay within budget, and get approval. We thought AI could help with that work, but we didn’t want an agent to have free rein to spend company money.

That’s where SpendPilot came from. We wanted to make procurement easier while keeping people involved in the decisions that matter.

What it does

SpendPilot helps turn a natural-language business request into structured information that can be reviewed. A user can describe what their team needs, how much they can spend, and any requirements the purchase needs to meet.

SpendPilot brings recommendations, budget information, governance, approvals, and task outcomes into one place. Its Jira experience lets users review structured requests and create tasks alongside their team’s existing work. The enterprise control room provides a place to follow activity and inspect the decision trail.

SpendPilot also explores how teams could identify unused software licenses and make better use of the tools they already pay for.

How we built it

We built the enterprise control room with Next.js and React, and used FastAPI and Pydantic for the backend. We integrated OpenAI to help turn natural-language requests into structured task information.

For the Atlassian experience, we built a Forge app for Jira that lets users review a request and create a task. We also built governance and payment components around budgets, approvals, duplicate-request protection, and x402 settlement checks.

Challenges we ran into

The hardest part was figuring out how an agent could help with purchasing without treating every request as permission to spend. A budget gives the system a limit, but it does not automatically mean a purchase is authorized. We needed to account for policy checks, human review, and the details of the specific request.

We also had to be careful about how we displayed payment states. A prepared payment should not look like a settled payment. Likewise, paying for a service does not necessarily mean the task was completed successfully.

Connecting the Forge app, Jira, the frontend, and the backend took work too. Each part needed to pass the right information along while keeping the experience easy to understand.

Another challenge was working with incomplete provider information. Pricing and security details are not always easy to compare, so we wanted SpendPilot to show uncertainty instead of filling in missing facts.

Accomplishments that we're proud of

We brought together several parts of an agent-assisted purchasing workflow, from natural-language intake and recommendations to governance, review, and verification.

We’re proud that we built around the controls a company would need to trust an agent with spending. The Jira app also gives users a way to review a request alongside their team’s work.

What we learned

We learned that an AI agent needs more than the ability to make a recommendation. It also needs clear boundaries, reliable information, and a way to hand decisions off to people.

We also learned that verification is not all-or-nothing. Checking that a brief contains the right sections and links is useful, but it does not prove that every claim is accurate or every source is current.

What's next for SpendPilot

We want to connect real license data, improve how SpendPilot checks sources, and make the Jira app available to teams. We also plan to test the full Coinbase/x402 payment flow.