PPV Memory for Invoice Processing | Track 2

An AP agent that flags a price variance once, learns how it was resolved, and never asks about the same case again.

Comment 1

Track 2 - Autonomous Office of the CFO

Inspiration

At the hackathon, an engineer from Maximor gave me a piece of advice that stuck: don't build broad, go deep on one real problem, and make sure the agent actually learns from how a human resolves an exception, not just flags it. That's exactly what PPV Memory does: it takes one specific, genuine AP pain point, purchase price variance, and solves it properly instead of half-solving ten things.

What it does

PPV Memory reads an invoice, checks it against the purchase order, and decides: auto-approve, or flag for a buyer to review. If it's flagged, the buyer resolves it once with a real reason. The next time that exact vendor, item, and price shows up, the agent auto-approves it on its own, citing the earlier decision. It also has a tolerance band for small variances, and guardrails so it never over-applies a resolution to a different item or a bigger price jump than what was actually approved.

How I built it

The core pipeline is a LangGraph graph: extract, then look up the PO and resolution history, then decide. It started as a Streamlit prototype to prove the mechanism worked, then became a FastAPI backend with a Next.js dashboard and a separate "vendor simulator" page, so invoices arrive the way they realistically would, not triggered from the AP team's own screen. Extraction runs on Claude and Tensormux's GLM-4.7-Flash, and it works on both plain text and real PDF invoices. The entire thing was built through Agent Orchestrator: every piece was a scoped task, reviewed and merged.

Challenges I ran into

Getting the human-in-the-loop pattern right was the trickiest part. LangGraph's interrupt/resume pattern works cleanly in one process, but pausing and resuming a graph across a frontend and backend introduced real complexity, so I redesigned it to run each invoice to completion and resolve flagged ones as a separate, explicit step instead. Learning Agent Orchestrator itself was its own challenge too. I started with a simple test project first just to get a feel for how it actually worked before diving into the real build.

Accomplishments that I'm proud of

The memory mechanism actually works, and I can prove it: my eval shows the system going from getting several cases wrong without memory to getting every case right with it. The guardrails hold too: a different item, or a bigger variance than what was approved, still correctly gets flagged instead of being waved through.

What I learned

I already had experience building with AI agents before this hackathon, but actual financial workflows were completely new territory, and that turned out to be the most interesting part. Learning how AP teams actually think, POs, tolerance bands, exceptions, who resolves what and why, and then figuring out how to automate that with an agent instead of just a rules engine, was genuinely fun in a way I didn't expect. Agents and financial workflow automation are now two areas I'm genuinely interested in continuing to explore after this hackathon.

What's next for PPV Memory

Extending the same memory mechanism to other AP exception types, like duplicate invoices and missing POs, and connecting it to a real email inbox or vendor portal instead of a simulator, so invoices genuinely arrive on their own.

Built With

  • agent-orchestrator
  • ai-agents
  • claude
  • fastapi
  • finance-automation
  • human-in-the-loop
  • invoice-processing
  • langgraph
  • nextjs
  • ocr
  • python
  • sqlite
  • tensormux
Share this project:

Updates

Submission history