Automatic

Eric Lamanna

Podcast for Automatic.co and LLM.co, the AI automation specialists.

  1. -7 h

    Own Your Vector Database: The Enterprise Case for Taking Control

    Vector databases sit at the heart of every useful enterprise LLM deployment, yet most organizations treat them as rented utilities rather than strategic assets. This episode of Automatic makes the full business case for bringing that infrastructure in-house — drawing on this deep-dive on owning your enterprise vector database — and walks through exactly what ownership means for cost, compliance, agility, and competitive positioning at scale. Here's what the episode covers: Why vector data is now strategic: Semantic search has replaced keyword lookup as the primary interface for enterprise knowledge work, and the vector database is the infrastructure that makes it possible — turning fragmented silos into a unified, queryable knowledge layer.The real cost math: Managed vector services bill with opaque multipliers on top of commodity hardware prices. Self-hosted infrastructure follows a nonlinear cost curve — storage costs grow far more slowly than data volume — turning an upfront capital investment into a long-term financial advantage.Hidden savings most CFOs miss: Co-locating a privately owned vector store with GPU inference servers eliminates cross-zone network egress fees, and fine-tuning index parameters (like HNSW search settings) can deliver sub-second recall without additional compute spend.Compliance and data sovereignty: When the infrastructure is yours, so is the jurisdiction. Demonstrating data locality, encryption controls, and retention schedules to a GDPR or HIPAA auditor becomes a routine exercise rather than a crisis response.Eliminating vendor leverage: Managed service vendors can — and historically do — raise prices once switching costs feel prohibitive. Owning an open-source or licensed engine means the system runs regardless of renewal decisions, fundamentally shifting the negotiating dynamic.Speed, debugging, and engineering culture: Owned infrastructure compresses the feedback loop from idea to prototype, enables deep diagnostic access when retrieval goes wrong, and cultivates a craftsmanship mindset that attracts and retains strong technical talent.The episode also covers practical migration strategy — including dual-write windows, dark-launch traffic testing, and observability requirements (tail latency, cache hit ratios, and shard health) — so teams can cut over without user-facing disruption. For more on how AI is reshaping physical industries, check out the earlier episode AI Agents Are Coming for the Built World — And Not a Moment Too Soon. LLM

  2. -1 j

    AI Agents Are Coming for the Built World — And Not a Moment Too Soon

    The built world — construction, real estate, and infrastructure — is one of the largest industries on earth and, by most measures, one of the least productive. This episode of Automatic digs into why that's true, what it actually costs, and how agentic AI systems are emerging as something genuinely different from the waves of construction tech that came before. The full research is laid out in the source article behind this episode, and the conversation here builds a strategic framework around it. Here's what the episode covers: The scale of the problem: Large construction projects routinely run 20% over schedule and up to 80% over budget — and bad data alone cost the global industry nearly $2 trillion in 2020, according to Autodesk and FMI research.Where the data actually lives: More than 80% of survey respondents said at least a quarter of their project data was effectively unusable — not because it doesn't exist, but because it's trapped in PDFs, email threads, BIM models, ERPs, and the memory of whoever was last on site.Why SaaS wasn't enough: Digital tools moved work off paper and created audit trails, but still required humans to log in, interpret, and decide. They captured the work — they didn't coordinate it.What agentic AI does differently: Instead of surfacing information for a human to act on, agent-based systems can monitor progress, reschedule crews, trigger procurement workflows, flag compliance issues, and escalate only when the stakes require human judgment — closing decision loops at machine speed.Early proof points and market momentum: Companies like Buildots, OpenSpace, ALICE Technologies, and JLL are already documenting measurable gains. The AI-in-construction market is projected to grow from roughly $3 billion in 2023 to nearly $17 billion by 2030.Where the competitive moat is moving: For software vendors and operating companies alike, the advantage is shifting toward data ownership and workflow orchestration — not feature sets. The firms that control proprietary workflow data will be hardest to displace.The episode also spotlights an underappreciated opportunity in design and preconstruction, where AI-assisted conflict detection and specification review can prevent costly change orders months before a shovel hits the ground. Three converging conditions — mature multimodal models, interoperable enterprise systems, and unprecedented business pressure — make this moment structurally different from prior construction tech cycles. For more on AI systems operating at the edge of enterprise boundaries, check out the earlier episode AI Red Teams: Testing the Limits of Your Private LLM. Automatic

  3. -2 j

    AI Red Teams: Testing the Limits of Your Private LLM

    Deploying a private large language model inside your organization sounds like a competitive edge — until the model does something no one anticipated and the fallout is very public. This episode of Automatic explores AI red teaming: the structured, adversarial practice of stress-testing your LLM before it ever reaches production. Drawing on this deep-dive guide to testing private LLMs, the episode makes the case that finding your model's failure modes quietly, on your own terms, is the only responsible path to deployment. Here's what the episode covers: What AI red teaming actually is — borrowed from military and cybersecurity culture, it means assembling a team with a single mandate: break the model before anyone else does.Why standard QA falls short — traditional software testing confirms a system does what it should; red teaming uncovers what it does when manipulated, pressured, or prompted in ways no one planned for.Who belongs on a red team — the most effective teams are deliberately eclectic, mixing penetration testers, linguists, creative writers, and AI probing tools to attack guardrails at scale and from unexpected angles.How a campaign is structured — from baseline sanity checks to adversarial creativity (hiding disallowed requests inside limericks or foreign alphabets) to long-haul stress tests that simulate real production load over hours.Turning findings into boardroom language — metrics like policy-violation frequency, recovery time, and remediation cost convert an opaque black box into a trackable sprint backlog that earns executive trust and budget.Making red teaming a recurring practice — the episode argues that wiring adversarial tests into CI/CD pipelines, triggered automatically by model or prompt updates, is what separates a fragile experiment from a deployment you can stake your reputation on.Trust in AI isn't granted — it's built through rigorous, repeated pressure-testing. More from the show: if the intersection of machine learning and production reality interests you, check out Reinforcement Learning in Production: Yikes for a look at what happens when another class of models meets the messy real world. LLM

  4. -3 j

    Reinforcement Learning in Production: Yikes

    Reinforcement learning has produced genuinely remarkable results in research settings — mastering games, controlling robots, solving problems that once seemed intractable. But the leap from lab to live production environment introduces a class of risks that don't show up in benchmarks. This episode of Automatic breaks down what engineering and product teams actually need to understand before deploying RL in systems that touch real customers, real budgets, and real operations, drawing on the in-depth article behind this episode. The episode walks through the most common failure modes and the practical safeguards that separate responsible deployments from expensive lessons: Reward function misalignment: When the metric you define doesn't fully capture what you care about, RL will optimize the metric — relentlessly — while quietly ignoring the nuance. Narrow reward signals produce narrow, and sometimes alarming, behavior.Environment instability: Unlike simulations, production environments shift constantly. Customer behavior, traffic patterns, and upstream dependencies can all change without notice, turning a well-trained policy into a reckless one without a single line of code changing.The cost of exploration: RL improves by trying new things — a feature that's great in sandboxes and genuinely problematic when real users absorb the downside of experiments. Without guardrails, a model can treat production like a testing ground.Choosing the right tool first: RL works best where decisions repeat frequently, feedback is usable, and actions influence future outcomes. For many problems, a simpler supervised model or rules-based approach will outperform RL with far less operational risk.Offline evaluation before live deployment: Simulation, replay testing, and counterfactual evaluation should surface behavioral problems long before a policy encounters real users. Production is not a beta environment.Observability and human oversight: Standard ML metrics aren't enough. Teams need visibility into how the policy is evolving, what actions it's taking, and whether the reward signal is behaving as expected — and humans need to stay in the loop on retraining, rollback decisions, and scope expansion.The episode closes with a case for deliberate, narrow rollouts — starting where mistakes are reversible and rewards are legible, then expanding only after the system has demonstrated trustworthy behavior under real conditions. For more on related themes, check out the episode Why Federated Training Is the Future of Global AI for another angle on responsible AI deployment at scale. Automatic

  5. -4 j

    Why Federated Training Is the Future of Global AI

    Building a unified AI model across a multinational company sounds like a technical challenge — but for most global enterprises, the real obstacles are legal, regulatory, and geopolitical. This episode of Automatic unpacks why federated training has emerged as the architecture of choice for organizations navigating data sovereignty laws like GDPR, LGPD, and PIPEDA, drawing on this deep-dive analysis of federated training for global enterprises. Rather than centralizing data for model training — a process that can trigger months of compliance reviews and legal exposure — federated training flips the paradigm: the model travels to the data, not the other way around. The episode walks through the mechanics, the business case, and the implementation discipline required to make this work at scale. Key topics covered include: How federated training actually works: Regional servers train on local data and send only cryptographically protected gradient updates — compressed mathematical summaries, never raw records — to a central orchestrator that blends them into a globally improved model.Compliance by design: Because sensitive data never crosses jurisdictional boundaries, federated architectures sidestep the regulatory friction that makes traditional centralized pipelines untenable in multi-jurisdiction environments.Latency and performance gains: Keeping inference close to end users — rather than routing every request through a single data center — can cut average response times by more than half in distant markets like Asia-Pacific, Latin America, and the Middle East.Resilience and scalability: Distributed compute means no single point of failure; regional nodes can be scaled up or gracefully skipped without catastrophic disruption to training rounds.The economics of not moving data: Eliminating cross-border data replication reduces storage, egress, and bandwidth costs in ways that compound meaningfully on cloud infrastructure bills over time.Smart rollout and governance: Successful deployments start with two-jurisdiction pilots, instrument everything, version governance playbooks like code, and run federated evaluation so regional model drift is caught early — before it becomes a global problem.The episode also explores how thin regional adapter layers can sit atop a shared global model backbone, delivering cultural and contextual personalization without fragmenting the core. The overall argument: privacy, performance, and profitability are not trade-offs in a well-designed federated system — they reinforce each other. For more on the infrastructure decisions that underpin large-scale AI deployments, check out the earlier episode GPU Scheduling: Herding Cores in the Cloud. LLM

  6. -5 j

    GPU Scheduling: Herding Cores in the Cloud

    GPU scheduling sits at the intersection of cost, performance, and team trust — yet it rarely gets the attention it deserves until something goes wrong. This episode of Automatic unpacks the deep dive on GPU scheduling in cloud environments, walking through why the problem is so much harder than it looks and what separates a policy that quietly hums along from one that turns a powerful cluster into an expensive traffic jam. The episode covers the core decisions every GPU scheduler has to make, the hidden traps that catch even experienced infrastructure teams off guard, and the design principles that make the difference between infrastructure that earns its cost and infrastructure that just burns it. Key topics include: Why simplicity is deceptive: GPUs look binary — busy or free — but real workloads vary wildly in memory, compute, and hardware requirements, turning simple job matching into a multi-dimensional negotiation.The fairness-vs-efficiency tension: Chasing utilization too aggressively starves smaller jobs; enforcing strict fairness leaves expensive cores idle. There is no configuration where every metric wins simultaneously.Placement, timing, and sharing rules: The three core dimensions every scheduler balances — where a job runs, when it runs, and what guardrails prevent any one team or workflow from consuming everything in sight.Fragmentation as a hidden culprit: A cluster can appear healthy at a glance while being quietly full of unusable gaps — leading teams to conclude they need more hardware when the real problem is scheduling policy.Heterogeneity and the miniature puzzle problem: Mixed GPU fleets keep costs flexible, but jobs that perform wildly differently across hardware types make every scheduling decision harder to get consistently right.Observability as the foundation for improvement: Without visibility into queue times, placement outcomes, idle gaps, and preemption rates, scheduling decisions default to gut feel and whoever complained loudest that week.The episode makes a compelling case that GPU scheduling isn't a background technical detail — it directly shapes platform performance, cloud spend, and whether teams trust the infrastructure enough to stop hoarding resources as a hedge. For more on how AI and automation are reshaping operational challenges at scale, check out the earlier episode How Retailers Are Using LLMs to Tame Supply Chain Chaos. Automatic

  7. -6 j

    How Retailers Are Using LLMs to Tame Supply Chain Chaos

    Supply chain management has always been retail's most punishing backstage act — a constant juggle of demand signals, vendor spreadsheets, warehouse bottlenecks, and institutional knowledge that tends to disappear the moment a veteran employee clocks out for the last time. This episode of Automatic digs into the growing body of evidence for how large language models are reshaping retail operations — not as novelty, but as genuine infrastructure woven into the decisions that keep shelves stocked and margins intact. The episode walks through four major operational domains where LLMs are already driving measurable change: Demand forecasting: LLMs move beyond static historical averages by reading purchase data as narrative — surfacing contextual patterns, explaining forecast shifts, and giving procurement teams the "why" that turns a recommendation into a fast decision.Inventory choreography: With sharper forecasts as the foundation, models can simulate shelf velocity across regions, account for lead times and buyer behavior, and distribute stock so product lands on the floor just as demand peaks — reducing both stockouts and costly clearance markdowns.Warehouse efficiency: From optimizing pick paths to translating natural-language merchandising instructions into robot-ready commands, LLMs cut the small inefficiencies that compound into big operational drag — including spotting conveyor bottlenecks in real time before supervisors see them with the naked eye.Procurement intelligence: Models normalize supplier spreadsheets into apples-to-apples comparisons, continuously monitor vendor risk signals across news, trade forums, and filings, and propose contract language that balances margin protection with compliance — compressing what used to be weekend-long tasks into minutes.Continuous improvement loops: Help-desk tickets, shift handoff notes, and staff chat logs contain operational wisdom that normally evaporates. LLMs classify and surface those patterns as readable weekly digests — and serve as on-demand advisors for new hires navigating their first weeks on the floor.The episode closes with a broader argument: supply chains will always carry surprises, but the difference between organizations that absorb disruption with panic versus precision increasingly comes down to whether intelligence is embedded in their workflows. More from the show: if you're thinking about how to keep AI systems like these from going off the rails, the earlier episode Guardrails for LLMs: The Digital Babysitter is a natural companion listen. Source material for this episode can be found at LLM.co. LLM

  8. 7 juil.

    Guardrails for LLMs: The Digital Babysitter

    Deploying a large language model in a real business environment is a bit like hiring someone who speaks beautifully and checks nothing. The capability is real — but so is the risk of a confident, fluent system quietly producing wrong answers at scale. This episode of Automatic draws on the full source article on guardrails for LLMs to unpack what it actually takes to make these systems safe, reliable, and worth trusting in production. The episode covers the full picture of LLM guardrails — from why they're necessary in the first place to the principles that separate well-designed systems from ones that look responsible on paper but collapse under real-world pressure: Fluency isn't wisdom. LLMs produce smooth, authoritative-sounding text whether or not the underlying information is accurate — and users tend to trust the tone rather than verify the substance.Scale turns small errors into operational problems. A single bad pattern inside a support bot or internal assistant doesn't stay contained — it multiplies across customers, employees, and systems before anyone spots it.Effective guardrails work in layers. Input filters, output filters, and access controls each address a different entry point for risk. Protecting only one layer still leaves the others exposed.The three most common deployment mistakes are rules too vague to enforce, rules so restrictive the tool becomes useless, and treating guardrails as a one-time setup rather than ongoing maintenance.Good systems include an escalation path. When a request lands in the uncertain middle ground, the right move isn't to guess — it's to pause, ask for clarification, or hand off to a human reviewer.Guardrails don't flatten creativity — they focus it. Clear boundaries give a model a defined space to operate confidently, rather than wandering into fabrication, privacy issues, or policy violations.The episode closes with three principles for building guardrails that earn genuine trust over time: starting with a clear-eyed risk assessment rather than abstract fear, writing policies specific enough for real humans to maintain and audit, and treating the system as a living product that needs continuous tuning after launch. For more from the show, check out the earlier episode Private LLMs on the Factory Floor: From SOPs to Smart Production, which explores how these ideas play out in industrial and manufacturing contexts. Automatic

Tout afficher (44)

À propos

Podcast for Automatic.co and LLM.co, the AI automation specialists.

Informations

  • Création
    Eric Lamanna
  • Années d’activité
    2026
  • Épisodes
    44
  • Classification
    Tous publics
  • Copyright
    © 2026 Automatic.co
  • Site web de l’émission
    Automatic