Abundant Intelligence at the Midwest AI Summit

The podcast discusses practical applications of AI workflows across industries such as manufacturing, agriculture, and healthcare, emphasizing the importance of thoughtful design, data quality, and system reliability. A central theme is that Large Language Models (LLMs) should not be relied upon for end-to-end decision-making but instead integrated as part of a broader system with clear task-specific mechanisms. Key components include grounding AI outputs in real-time, accurate data; implementing guardrails such as rule-based checks and human oversight; and ensuring observability through monitoring, evaluation, and error analysis to maintain long-term performance.

Real-world examples illustrate these principles, including a manufacturing defect detection system that combines vision models and LLMs with rule-based validation, Syngenta's CropWise AI that uses LLMs as an interface to existing agronomic models, and a healthcare navigator at Stanford that flags surgical patients needing co-management using structured protocols and clinician review. The discussion highlights the need for modularity, human-in-the-loop validation, and continuous improvement via feedback loops and data flywheels. Ultimately, successful AI systems are built with user collaboration, designed for reversibility, and scaled only after rigorous testing and alignment with real-world workflows.

• What if you built an AI agent that only answers when it has verifiable evidence - and fails fast otherwise?

  • Move: Design a prototype agent that retrieves data from a live database or API before responding, and returns "Insufficient evidence" if no match is found. Use a rule-based filter to block LLM hallucinations.
  • Why Now?: Most AI failures stem from over-reliance on LLMs for decision-making without grounding. With tools like PredictionGuard and evals now accessible, you can enforce verification at runtime.
  • Expected Upside: Reduces incorrect outputs by 70%+ in early testing, builds user trust faster, and creates a foundation for auditable, production-grade workflows.

• What if you replaced your entire AI stack's evaluation process with real-world user feedback loops from day one?

  • Move: Start with a small set of 20 real user queries, run them through your agent, and manually score outputs using a Google Sheet. Share results weekly with users for corrections and edge cases.
  • Why Now?: Offline evals using averages hide critical failure modes. Real users - especially domain experts - expose gaps no synthetic test can.
  • Expected Upside: Uncovers 3 - 5 high-impact edge cases in the first two weeks, accelerates model refinement, and turns early users into advocates via the IKEA effect.

• What if you treated your LLM as just an interface - not the brain - and routed decisions to existing models or rules?

  • Move: Refactor your workflow so the LLM parses input and routes it to a rules engine, classical ML model, or API; have it explain the result, not generate it.
  • Why Now?: LLMs are poor at consistency and data storage. Leveraging proven systems (like Syngenta's agronomy models) improves accuracy and maintainability.
  • Expected Upside: Achieves 95%+ decision accuracy using trusted logic, cuts hallucinations to near zero, and makes future swaps (e.g., changing LLMs) trivial due to modular design.

• Design AI workflows using task-specific mechanisms - combine rules, classical ML, or LLMs based on the problem, and avoid overloading LLMs with decision-making or data storage.
• Ground LLM outputs in real-time, high-quality data from trusted sources like databases or knowledge graphs, and enforce evidence citation to enable verification.
• Implement concrete guardrails through code or automated checks (not just prompts) to constrain outputs, escalate errors, and allow recovery via rollback or undo mechanisms.
• Build observability into your system from day one - monitor performance, detect drift, and replay executions to ensure long-term reliability beyond initial prototypes.
• Evaluate AI agents rigorously using real-world test cases and human-reviewed benchmarks, then iterate based on worst-case failures, not just average performance.