SourcePilot — Evidence-Backed AI Sourcing Agent

From messy buyer requests to evidence-backed sourcing decisions, with humans in control.

Comment

Inspiration

International sourcing often starts with a message that looks simple:

“I need fashionable women’s shoes for Ghana. I want 8–12 designs, a small test order, a limited budget, and a reliable supplier.”

But turning that message into a real procurement decision is not simple.

A sourcing professional has to clarify requirements, search for suppliers, compare inconsistent prices and MOQs, evaluate commercial risk, calculate quantity exposure, prepare RFQs, and decide when a human should step in.

I built SourcePilot to turn that messy process into an agentic workflow.

Instead of behaving like a chatbot that waits for the next question, SourcePilot moves from buyer intent toward a structured, evidence-backed procurement decision and interrupts the human only when a meaningful commercial decision is required.

What it does

SourcePilot turns an unstructured buyer request into a procurement workflow:

Buyer Request → Requirements → Supplier Discovery → Quote Normalization → Risk Analysis → Commercial Analysis → Recommendation → Human Approval → Procurement Proposal

The system can:

  • extract sourcing requirements from a buyer message
  • create a structured procurement specification
  • evaluate multiple supplier candidates
  • compare price, MOQ, quality, lead time, reliability and quotation completeness
  • calculate commercial trade-offs deterministically
  • identify situations where the cheapest supplier is not necessarily the best supplier
  • trigger a HUMAN DECISION REQUIRED state when a real business trade-off exists
  • generate a buyer-facing procurement proposal after approval
  • generate RFQ drafts for supplier outreach

SourcePilot follows a simple principle:

The model judges. Deterministic code measures. The human makes the commercial commitment.

Evidence-backed supplier discovery

One of the biggest problems in sourcing tools is provenance.

If an AI recommends a supplier, the buyer should be able to ask:

  • Where did this supplier come from?
  • What is the source of the price?
  • Is this a real quotation or just a marketplace listing?
  • Where can I contact the supplier?
  • When was the information checked?

SourcePilot therefore includes a Public Source Evidence workflow using supplier and product records collected from public B2B marketplace pages such as Alibaba.com and Made-in-China.com.

Each record preserves information such as:

  • supplier name
  • source platform
  • supplier profile URL
  • product listing URL
  • public region or address when available
  • publicly listed price range
  • MOQ
  • verification information shown by the marketplace
  • contact path
  • date the source was checked

Importantly, SourcePilot does not treat a public marketplace price as a formal supplier quotation.

A public listed price is labeled as indicative. A real commercial quotation still requires an RFQ and supplier confirmation.

The current hackathon version uses reproducible public-source snapshots rather than claiming continuous real-time marketplace scraping.

Human-in-the-loop procurement

The goal is not to remove the human from procurement.

The goal is to remove unnecessary manual work while preserving human judgment where it matters.

For example, one supplier may offer a lower unit price but require a much higher MOQ.

SourcePilot calculates:

  • unit-price difference
  • additional units required
  • additional EXW inventory exposure
  • quantity exposure relative to the intended test order

Instead of silently choosing one option, SourcePilot stops and shows:

HUMAN DECISION REQUIRED

The buyer can then approve the recommended supplier, choose the lower-price alternative, or review the shortlist.

No purchase commitment is made automatically.

How I built it

SourcePilot is built in Python with a modular multi-agent architecture using the Strands Agents SDK.

The architecture separates responsibilities into specialist agents for:

  • Requirements
  • Supplier Discovery
  • Quote Normalization
  • Risk & Verification
  • Commercial Analysis
  • Recommendation

A supervisor coordinates these specialist capabilities.

Procurement-specific calculations such as MOQ exposure, cost comparison, risk thresholds and supplier scoring are implemented as deterministic Python tools rather than delegated to the language model.

This makes the commercial reasoning auditable and reproducible.

The user interface is built with Streamlit and deployed publicly on Render.

The repository also includes an Amazon Bedrock-compatible Strands execution path and an Amazon Bedrock AgentCore runtime entry point. My AWS account encountered Bedrock account-access allowlisting during the hackathon, so the public demo preserves a deterministic execution mode rather than falsely claiming a successful cloud runtime deployment.

Architecture

SourcePilot uses a supervisor / specialist-agent architecture:

Buyer Request
      |
      v
Strands Supervisor
      |
      +--> Requirements Agent
      |
      +--> Supplier Discovery Agent
      |
      +--> Quote Normalization Agent
      |
      +--> Risk & Verification Agent
      |
      +--> Commercial Analysis Agent
      |
      +--> Recommendation Agent
      |
      v
Deterministic Procurement Tools
      |
      v
HUMAN DECISION REQUIRED
      |
      v
Procurement-Ready Proposal

Challenges
1. Separating AI reasoning from financial arithmetic

A sourcing system should not rely on an LLM to calculate commercial exposure.

I therefore separated qualitative reasoning from deterministic calculations.

For example:

200 additional pairs × $7.40 = $1,480 additional EXW exposure

That calculation comes from Python, not generated text.

2. Supplier provenance

An early version used synthetic supplier profiles for a completely reproducible demonstration.

However, supplier names and prices without provenance felt incomplete.

I added a public-source evidence layer that preserves marketplace URLs, indicative prices, MOQ, locations and contact paths while clearly distinguishing marketplace listings from formal quotations.

3. Designing meaningful human intervention

A common “human-in-the-loop” implementation simply adds an approval button at the end.

I wanted SourcePilot to interrupt the user only when there is an actual decision.

The approval gate is therefore triggered by measurable procurement trade-offs such as MOQ exposure and price-versus-risk differences.

4. Deployment reliability

The project had to remain reliable as a public hackathon demo.

I implemented a stable deterministic mode so that supplier scoring, risk rules and commercial calculations remain reproducible even when external model or cloud access is unavailable.

What I learned

The biggest lesson was that building a useful AI agent is not mainly about adding more autonomous steps.

It is about deciding:

What should the model reason about?

What should deterministic software calculate?

What evidence should the user be able to inspect?

What decisions should remain human?

For professional agents, trust comes from provenance, measurable reasoning and controlled autonomy.

What’s next

The next version of SourcePilot would add:

authorized marketplace APIs
automated supplier-source refresh
quotation PDF and Excel parsing
email and messaging RFQ integrations
supplier reply ingestion
freight quotation APIs
landed-cost calculation
supplier due-diligence integrations
purchase-order workflows
collaborative procurement workspaces
supplier performance history

The long-term goal is for SourcePilot to become an evidence-backed procurement operating layer between overseas buyers and global suppliers.

Built With

  • agents
  • agentsamazon
  • ai
  • bedrockstreamlit
  • human-in-the-loop
  • multi-agent
  • strands
Share this project:

Updates

Submission history