Supply Chain Supplier Status Check Agent

CALL-E is an AI agent that dials suppliers to confirm orders. It logs delays, dates, and cost impacts into a unified dashboard, saving your team 2 hours of manual follow-up calls every single day.

Comment

Inspiration

In modern retail, automotive, and aerospace supply chains, operations depend on razor-thin Just-In-Time (JIT) scheduling. When a supplier ships late, the consequences are catastrophic: manufacturing assembly lines stall ($20,000+ per hour in automotive factory downtime), store shelves sit empty, and late-notice expedited air freight charters cost tens of thousands of dollars.

Yet, behind billion-dollar enterprise resource planning (ERP) systems, the primary tool used to verify whether a supplier will actually meet a delivery deadline remains shocking: manual outbound phone calls.

Procurement specialists and expeditors spend 2 to 3 hours per manager every single day dialing supplier switchboards across multiple timezones, getting bounced between dispatchers, and manually logging notes. Worse, when delays occur, suppliers often fail to proactively alert buyers—leaving procurement teams to discover delivery failures only after the shipment fails to arrive at the receiving dock.

We asked ourselves:"What if an autonomous voice AI agent could proactively call supplier dispatchers 48 hours before delivery milestones, conduct a professional and legally-compliant verification dialogue, diagnose exact root causes for delays, calculate contractual financial penalties, and feed structured intelligence directly into ERP dashboards before assembly lines halt?"

That vision inspired the CALL-E Supply Chain Supplier Status Check Agent.

What It Does

The CALL-E Supply Chain Supplier Status Check Agent is a full-stack, enterprise-grade autonomous voice operations platform that transforms manual vendor check-ins into an automated risk control tower:

  1. Autonomous Outbound Telephony: Proactively dials vendor dispatchers prior to committed delivery dates using the CALL-E platform.

  2. Deterministic 5-Step Conversational Protocol:    - Step 1: Greeting & Verification: Introduces the agent as Enterprise Procurement on a recorded line (TCPA compliance) and authenticates the dispatcher.[6:20 PM]- Step 2: Fulfillment Status Check: Conducts a binary milestone schedule verification against committed purchase order delivery dates and quantities.    - Step 3: Root Cause Diagnosis: If a shipment is delayed, triages the failure into a standardized logistics taxonomy:      $$\mathcal{T} = {\text{RAW_MATERIAL_SHORTAGE}, \text{LOGISTICS_PORT_CONGESTION}, \text{QUALITY_CONTROL_HOLD}, \text{PRODUCTION_HALT}, \text{WEATHER_FORCE_MAJEURE}, \text{OTHER}}$$    - Step 4: Recovery Timeline & Mitigation Negotiation: Negotiates a guaranteed revised delivery date, explores partial split shipments ($Q_{\text{dispatched}} / Q_{\text{total}}$), and captures expedited freight options.    - Step 5: Cost Impact & Escalation: Records expedited freight surcharges, logs escalation supervisor details (name and direct phone), and closes the call with an audit confirmation.

  3. Mathematical Financial Risk Quantification:    For any purchase order $i \in {1, \dots, N}$ with committed delivery timestamp $t_i^{\text{committed}}$, revised delivery timestamp $t_i^{\text{revised}}$, contractual daily SLA penalty rate $R_{\text{penalty}}$, and expedited freight surcharge $C_{\text{freight}, i}$:

   The delay in days $D_i$ is computed as:    $$D_i = \max\left(0, \left\lceil \frac{t_i^{\text{revised}} - t_i^{\text{committed}}}{86400} \right\rceil\right)$$

   The contractual financial penalty risk $\text{Penalty}i$ is:    $$\text{Penalty}_i = D_i \times R{\text{penalty}}$$

   The total financial exposure across the entire procurement portfolio is mathematically quantified as:    $$E_{\text{total}} = \sum_{i=1}^{N} \left( D_i \times R_{\text{penalty}} + C_{\text{freight}, i} \right)$$

   For partial shipments where volume $Q_{\text{split}} < Q_{\text{total}}$ is expedited, the effective operational disruption score is modeled as:    $$\Omega_i = \left( 1 - \frac{Q_{\text{split}}}{Q_{\text{total}}} \right) \times D_i \times \omega_{\text{criticality}}$$

  1. Universal Multi-Vector Search & Normalization: Instant search across purchase order IDs, vendor names, line items, and normalized raw telephone digits (e.g., matching +1-563-281-3105 whether the user types 563-281-3105, 5632813105, or a call ID).
  2. Interactive Executive Operations Dashboard: Features real-time KPI summary cards, taxonomy distribution visualizers, dual view modalities (Data Table and Card Grid), full conversational dialogue transcript viewer, and on-demand outbound call triggers.
  3. ERP-Ready Data Pipeline & SQLite Persistence: Relational SQLite database with Write-Ahead Logging (WAL) and automated streaming exports to CSV (procurement_status_report.csv) and JSON audit ledgers (procurement_status_report.json) compatible with SAP S/4HANA, Oracle NetSuite, and Walmart Retail Link.
  4. 5 Supported Integration Modalities: Operates via Python SDK (calle-ai), REST API (FastAPI), JSON-RPC 2.0 stdio MCP Server (src/mcp_server.py), interactive CLI (main.py), and portable Agent Skill manifest (skills/supply-chain-agent/SKILL.md).

How We Built It

We engineered the application from the ground up with modular enterprise architecture, test-driven development, and strict security and privacy standards:

  • Telephony Client & High-Fidelity Simulation Engine (src/calle_client.py):   - Built an abstraction layer over the CALL-E Calls API (POST https://api.heycall-e.com/v1/calls).   - Integrated high-fidelity offline simulation allowing developers and judges to run full-scale batch tests with zero API credit consumption, while seamlessly switching to live PSTN calling when API keys are supplied.[6:20 PM]- Implemented CalleSupplierAgentClient.from_calle_api_task() to hydrate verified live CALL-E call telemetry into typed application models.

  • Deterministic Conversational State Machine (prompts/supplier_agent_prompt.py):   - Implemented deterministic conversational guardrails ensuring the agent stays strictly on task: mandatory TCPA recorded line disclosure, dispatcher identity confirmation, binary delivery confirmation, and supervisory escalation capture.   - Enforced fail-closed ambiguity contracts: any conflicting order or destination information immediately halts execution for human review.   - Integrated deterministic idempotency keys:     $$\text{IdempotencyKey} = \text{hash}(\text{PO_ID} \,|\, \text{Supplier_ID} \,|\, \text{CommittedDate} \,|\, \text{Version})$$     preventing duplicate outbound dials to vendors.

  • Data Modeling & Validation (src/models.py):   - Designed strict Pydantic v2 schemas: Supplier, PurchaseOrder, CallResult, FulfillmentStatus, DelayReasonCategory, and BatchProcurementReport.   - Enforced automated runtime computation of financial penalty exposure and freight surcharges.

  • High-Performance SQLite Persistence Engine (src/database.py):   - Built a zero-dependency relational database using Python 3.12 standard library sqlite3, adhering strictly to disk quotas.   - Configured with PRAGMA journal_mode=WAL; and PRAGMA synchronous=NORMAL; for high-throughput concurrency and crash resilience.   - Implemented dual-layer persistence: relational indexed columns for sub-millisecond filtering and universal phone digit search, combined with lossless JSON payloads for forward compatibility.

  • FastAPI REST API & Backend Server (src/server.py):   - Built production REST endpoints: GET /api/summary, GET /api/calls, GET /api/calls/{call_id}, POST /api/calls/trigger, POST /api/workflow/trigger-batch, GET /api/db/stats, and streaming CSV/JSON export.   - Added verified call hydration and real-time report re-indexing upon every call execution.

  • Interactive Operations HTML Dashboard (src/html_dashboard.py):   - Designed a responsive, executive-ready single-page application with zero external JavaScript or CSS framework dependencies.   - Features real-time KPI metrics, multi-pill status filters (ALL, ON_TIME, DELAYED, PARTIAL_DISPATCH, UNREACHABLE, ESCALATIONS), category dropdowns, dynamic search, and structured conversational speech bubble viewers.

  • Model Context Protocol (MCP) Server (src/mcp_server.py):   - Implemented an RFC-compliant JSON-RPC 2.0 stdio MCP server exposing calle_check_supplier_status and calle_run_batch_procurement, allowing external AI agents (like Claude Desktop, Antigravity, or custom autonomous orchestrators) to dispatch phone calls on demand.

  • Curated Operational Benchmark Dataset (data/suppliers_enterprise_50.json):   - Curated a balanced 14-record operational dataset featuring exactly 2 orders per root cause taxonomy category, including verified real call telemetry (PO-88219 / call_BX2osyVHhnrQgDngurhn8w).

  • Production VPS Cloud Deployment (deploy/):   - Deployed live on a Hostinger Ubuntu VPS under https://calle.fyro.cloud with Nginx reverse proxy, Let's Encrypt SSL/TLS, and automated systemd daemon supervision.

  • Comprehensive Automated Testing (tests/):   - Built an exhaustive 54-test automated suite covering models, transcript parsing, SQLite persistence, REST endpoints, HTML dashboard rendering, and MCP protocols with 100% pass rate in < 0.5 seconds.

Challenges We Ran Into

  1. Conversational Ambiguity in Real-World Logistics Calls: [6:20 PM]- In real life, supplier dispatchers do not speak in structured JSON schemas. They say things like "we had a minor delay with our coating supplier in Ohio, so we're looking at Tuesday or Wednesday next week, but we can ship 400 units by courier tomorrow."    - Solution: We built a multi-pass regex and NLP pattern extractor with fuzzy date normalization, currency parsing, and partial volume extractors (src/transcript_parser.py) combined with structured conversational prompts that guide dispatchers to confirm exact dates.

  2. Strict Telephony Safety & Community PR Review Requirements:    - During review of our official pull request (PR #440) on CALLE-AI/awesome-phone-call-agents, upstream maintainers raised critical governance requirements: enforcing run-level authorization preflights, destination verification, telephone number masking, and documenting carrier cancellation limits.    - Solution: We updated our architecture to require explicit operator authorization, implemented telephone masking (+1-555-***-9923) across all transcripts and exports to protect vendor PII, added deterministic idempotency keys, and explicitly documented carrier-level non-recallable dispatch boundaries in references/safety.md. Upstream PR #440 passed all validation checks with zero violations.

  3. Developing Complex Voice Logic Without Burning Telephony Credits:    - Outbound phone calls consume API credits and carrier fees. Iterating on dozens of edge cases and automated CI/CD runs would have exhausted development credits within hours.    - Solution: We built a high-fidelity offline simulation engine into src/calle_client.py that emulates realistic dispatcher dialogue, simulated latency, and error states. This enabled rapid local TDD, automated testing, and zero-cost judge evaluations.

  4. Sub-Millisecond Search Over Raw Telephone Numbers in SQLite:    - Users and procurement officers search for vendors using various phone formats (+1-563-281-3105, (563) 281-3105, or raw digits 5632813105), while records might be stored in E.164 or formatted strings.    - Solution: We engineered normalized digit wildcard queries (%5%6%3%2%8%1%3%1%0%5%) in SQLite and client-side regex stripping (\D) in the frontend, enabling instant, error-free matching regardless of punctuation.

  5. Resource and Disk Space Constraints:    - Working in constrained environments with strict disk limits required zero bloat. Heavy databases or massive node modules would fail disk quotas.    - Solution: We built our entire database on Python's built-in sqlite3 with WAL mode and built the interactive web frontend with pure vanilla HTML5/CSS/ES6, delivering a lightning-fast enterprise application in under 25MB of code.

What We Learned

  • Enterprise Voice Operations Require Deterministic State Machines: While open-ended conversational chatbots are great for casual chat, business-critical voice operations demand deterministic conversational branches. Ensuring identity verification, recorded line disclosures, and supervisor escalation points requires strict conversational gating.
  • Model Context Protocol (MCP) Bridges AI and the Physical World: Integrating CALL-E through the Model Context Protocol proved how transformative tool calling is. With MCP, any LLM agent can be granted telephony powers, allowing it to pick up the phone, speak to a human dispatcher, and return structured ground-truth facts to its reasoning loop.[6:20 PM]- Financial Quantification Drives Executive Action: Telephony logs and call recordings are overwhelming for busy executives. By translating unstructured conversations into quantifiable SLA financial exposure ($), procurement managers can instantly prioritize which delayed shipments require urgent intervention.
  • Safety and Privacy Must Be First-Class Citizens: Handling supplier contact information requires strict PII protection. Masking phone numbers, validating destination authorization, and preventing duplicate dials via idempotency hashing are essential for responsible enterprise telephony deployment.

Accomplishments That We're Proud Of

  • Live Production Deployment: Deployed the complete application to a live public HTTPS endpoint at https://calle.fyro.cloud with Nginx, Let's Encrypt SSL, and systemd automation.
  • Official Open-Source Contribution: Submitted and verified Pull Request PR #440 to the official CALLE-AI/awesome-phone-call-agents repository, passing all upstream validation checks.
  • 54/54 Automated Unit & Integration Tests: 100% test pass rate across data models, SQLite persistence, REST endpoints, transcript parsing, dashboard rendering, and MCP protocols.
  • 5 Supported Integration Modalities: Shipped complete support for Python SDK, REST API, JSON-RPC 2.0 MCP Server, CLI, and Agent Skill manifest in a single cohesive repository.
  • Verified Real CALL-E Telephony Telemetry: Captured and integrated real live call telemetry (call_BX2osyVHhnrQgDngurhn8w) verified through the official CALL-E platform.
  • Zero-Credit Developer Experience: Developers and judges can clone the repository and experience the full end-to-end interactive dashboard and CLI immediately without entering an API key.

What's Next for CALL-E Supply Chain Agent

  • Direct Two-Way ERP Connectors (SAP S/4HANA & Oracle NetSuite): Deploy pre-built SAP BAPI and NetSuite SuiteTalk connectors to automatically schedule outbound verification calls 48 hours prior to purchase order milestones without human input.
  • Dedicated Inbound Callback DID Lines: Provide suppliers with a dedicated toll-free phone number and PIN so dispatchers can call back with revised tracking numbers, automatically updating the procurement ledger via CALL-E inbound webhooks.
  • Multilingual Global Procurement Calling: Expand conversational prompts to support multilingual suppliers in Mandarin, Spanish, Vietnamese, German, and Japanese for cross-border global logistics.
  • Autonomous Multi-Vendor Sourcing Re-Routing: If a primary vendor confirms a critical delay exceeding a defined threshold ($D_i > \tau$), automatically trigger secondary vendor availability calls to reserve backup inventory and prevent assembly line stoppages.

Built With

  • agentic-workflows
  • automation
  • autonomous-agents
  • calle
  • cli
  • conversational-ai
  • csv-export
  • erp-integration
  • json
  • json-rpc
  • logistics
  • mcp
  • model-context-protocol
  • natural-language-processing
  • outbound-calling
  • procurement
  • pydantic
  • python
  • rest-api
  • supply-chain
  • tcpa-compliance
  • telephony
  • voice-ai
  • webhooks
Share this project:

Updates

Submission history