Where you train and deploy your AI model matters: The Water and Carbon Cost of Sovereign AI

Over $200 billion in sovereign AI commitments have been announced across the Global South between 2024 and 2026. The data centers behind them land in cities, and the water, energy, and carbon costs fall hardest on the places least equipped to absorb them. This talk presents findings from "The Environmental Cost of Digital Sovereignty" (arXiv:2607.13443, accepted at IEEE GHTC 2026), a comparative environmental stress analysis of sovereign AI deployments in the UAE, Bangladesh, India, and Kenya, reframed for the people who site, permit, and power urban AI infrastructure.

We model hypothetical GPU clusters at 256 and 1,024 GPUs under evaporative, hybrid, and immersion cooling regimes. The gaps are staggering. The same 1,024-GPU cluster emits 14,330 tons of CO2 per year on Bangladesh's 97.9% fossil grid but only 412 tons outsourced to Sweden's clean grid, a 35x difference driven entirely by siting. In the UAE, classified "Extremely High" water stress (4.82/5.0), evaporative cooling consumes 34.3 million liters of water per year, the daily needs of 940 people, while immersion cooling cuts that to 0.57 million, a 98.3% reduction.

We identify a sovereignty-sustainability trilemma: no country can simultaneously maximize AI sovereignty, minimize environmental impact, and keep resource access affordable for citizens. From it we derive seven design principles for environmentally responsible sovereign AI, including immersion-first cooling for hot climates, siting compute on clean grids, and desalination-loop accounting for coastal cities. City planners and infrastructure engineers will leave with a quantitative framework for evaluating where and how to deploy AI infrastructure.

Securing MCP workflows for Agentic AI

Agentic AI and MCP have proliferated widely across the tech ecosystem in the last year. WIth this, comes a whole set of security concerns and issues. In this session we look at securing Agentic AI, MCP and the entire AI pipeline.

The Human in the Loop: How TDD Keeps You in the Driver's Seat of AI-Assisted Development

AI coding assistants are rewriting the developer experience. Code appears in seconds, entire modules materialize from a prompt, and the temptation to ship first and test later has never been stronger. But speed without discipline is just faster failure.
This session tells the story of what happened when a practitioner refused to let AI bypass the fundamentals. Over the course of shipping four open-source packages to PyPI, building multiple frameworks, and building enterprise-grade systems, a pattern emerged: Test-Driven Development doesn't just survive AI-assisted workflows; it becomes the single most important practice keeping the human in control.
Through live demonstrations and real project walkthroughs, you'll see what a disciplined AI-assisted TDD workflow actually looks like in practice: the red-green-refactor cycle with a non-deterministic collaborator, the failures that taught hard lessons, the guardrails that had to be formalized into repeatable process, and the pre-push checklists that saved production more than once. This isn't a talk about testing AI models. It's about what happens to software quality when the fastest code generator in the room has no concept of accountability, and how TDD gives that accountability back to the human.
You'll walk away with a concrete, battle-tested framework for maintaining engineering rigor in AI-assisted development without sacrificing the speed advantage that makes these tools worth using in the first place.

JSON-LD Is Great (and Here's How We're Improving It): Building jsonld-ex

JSON-LD is everywhere: Google Search, Verifiable Credentials, schema.org, knowledge graphs. It's a W3C standard used on billions of web pages. And it has serious gaps: no built-in validation, security vulnerabilities in context resolution, no streaming support for large datasets, and zero affordances for the AI/ML workloads that increasingly consume it.
I conducted a deep gap analysis of JSON-LD and identified 26 specific improvements across security, performance, validation, developer experience, and AI integration. Then I started building jsonld-ex - an extended JSON-LD library for Python that implements these fixes.
In this session, I'll walk through the problems with live examples (yes, I'll break JSON-LD on stage), then show how jsonld-ex addresses them:
What you'll see live:

Context injection attacks against standard JSON-LD processors: and how jsonld-ex prevents them
SHACL/ShEx shape validation integrated directly into the processing pipeline
Confidence scores and provenance tracking baked into JSON-LD nodes: critical for AI systems consuming linked data
A working MCP (Model Context Protocol) server that lets AI agents query and validate knowledge graphs through jsonld-ex

What you'll walk away with:

Understanding of JSON-LD's real-world limitations beyond the spec
Practical techniques for securing JSON-LD in production APIs
How linked data and AI agents intersect through MCP
A Python library you can extend or contribute to

If you work with APIs, knowledge graphs, semantic web, or AI systems that consume structured data: this talk shows you what's broken under the hood and how to fix it.

Hands-On XAI Evaluation: How to Know If Your Model's Explanations Are Trustworthy

Explainability methods like SHAP, LIME, and Integrated Gradients are widely adopted in production ML systems; but run three different methods on the same model and input, and you'll often get three different answers. How do you know which explanation to trust? This hands-on workshop introduces quantitative evaluation of explanations, a rapidly growing area of XAI research that gives practitioners objective tools to measure explanation quality instead of relying on intuition or visual inspection. Working through three progressive Google Colab notebooks, attendees will first generate explanations from multiple methods on a real dataset and see exactly how and why they disagree. Next, they'll apply evaluation metrics across three dimensions: faithfulness (does the explanation reflect what the model actually uses?), robustness (is the explanation stable under small input changes?), and complexity (is the explanation simple enough to act on?). Finally, attendees will use a full evaluation pipeline to build comparison tables and learn a practical decision framework for choosing the right explainer for different deployment scenarios: regulatory audits, customer-facing products, and stakeholder communication. No prior XAI experience is required; attendees need only intermediate Python, familiarity with scikit-learn or PyTorch, and a Google account for Colab. Everyone leaves with working notebooks and the ability to integrate explanation quality checks into their ML pipelines immediately.

Bringing the Heat: Supercharging Your ML Pipelines with HuggingFace

Follow one model from the Hugging Face Hub through fine-tuning, evaluation, optimization, and inference. This practical session uses a runnable Colab exercise with DistilBERT and AG News to connect the pieces of a measurable ML workflow: Transformers, PEFT LoRA, Accelerate, and Optimum.

We pin model and dataset revisions, separate training, validation, and test data, then export and quantize to ONNX INT8. We evaluate the exported model and compare quality, per-class recall, latency, and model size. An executable release policy shows both a promoted result and a deliberately blocked regression, making acceptance criteria part of the pipeline.

Attendees leave with slides, source code, a Colab notebook, and a repeatable method for evaluating their own deployment tradeoffs. Familiarity with Python and basic machine learning is helpful.

Delivered to a standing-room-only audience at DeepStation AI Demo Night in Miami on September 17, 2026.

Slides, notebook, source, and recorded results: https://github.com/jemsbhai/bringing-the-heat

Run the Colab: https://colab.research.google.com/github/jemsbhai/bringing-the-heat/blob/main/demo/Bringing_the_Heat_Colab.ipynb

Organizer recap: https://www.linkedin.com/posts/deepstationai_deepstation-is-excited-to-share-the-post-event-activity-7507809905546821632-UT_f

The Power of No: Building Agents That Refuse, Pause, and Prove

An AI agent's proposed action needs a decision before it becomes a real-world side effect. This session introduces Pollard, a runtime for governing execution at that boundary while leaving the application's model client, tools, prompts, and agent loop under the developer's control.

We examine how explicit limits, registered tool actions, and an auditable execution tree help an agent refuse an inadmissible step, pause for human oversight, and preserve evidence of what happened. Recorded results support replay and testing; live revalidation checks for observable changes without replacing the original record.

The session gives developers a practical way to reason about agent control, auditability, and the limits of replay. Attendees will see where these controls belong in an application and how to distinguish a verifiable record from a guarantee about the outside world.

Pollard source and documentation: https://github.com/jemsbhai/pollard

Audience: developers and technical leaders building AI agents.