/Events /AgentCon - Lincoln /Schedule
AgentCon - Lincoln
Monday, June 22
Registration
203 ·Forging the Toolchain: Building FOR Agents at Scale
Everyone's talking about building agents. But who's building for them?
Agents are only as good as the tools they can reach, the skills they can invoke, and the context they can access. Behind every agent that "just works" is a value stream most teams haven't thought about yet: MCP servers, curated skills, agent profiles, prompt libraries, and composable tool surfaces that turn a generic LLM into a capable teammate.
In this keynote, I'll share what we've learned operating as an AI toolsmith team — the people who don't build the agents themselves, but build the infrastructure that makes agents actually useful. We'll cover:
- The AI Tool Value Stream — why "ship an MCP server" is the new "ship an API," and how tool quality directly determines agent quality
- Skills as Products — how treating agent skills like versioned, tested, documented software components changes everything about reliability and reuse
- Agent Profiles & Guardrails — designing the identity, permissions, and operational boundaries that let agents act with confidence
- The Multiplier Effect — real examples of how one well-built tool surface made dozens of agents across multiple teams more productive overnight
Building agents is table stakes. Building the toolchain that makes agents trustworthy, composable, and effective — that's the next competitive advantage. Come see how we did it, what broke along the way, and how you can stand up your own AI tool value stream tomorrow.
Steven Murawski is a Principal Cloud Advocate focused on modern operational practices. Steven’s background is in DevOps, Site Reliability Engineering, and Platform Engineering. Steven has worked on both the Dev and Ops sides of the house, most recently as a Principal Engineer at Chef, building tools for operating applications and infrastructure at scale and velocity.
Stateless Agents, Shared Artifacts: A Production Pattern for Shipping Real Code
Every developer knows the messy path from "a stakeholder wants a thing" to code that actually ships. Someone runs a discovery conversation. Someone writes the requirements. The requirements get broken into work, the work gets built, and then, if the team is disciplined, it gets reviewed before it merges. It is a relay race, and the baton is always an artifact: a doc, a ticket, a spec, a diff.
This session makes the case for building agent systems the same way. Instead of one agent trying to do everything in a single sprawling conversation, the work is split across a chain of specialized agents, each responsible for a single leg of the race. They do not share a context window. They hand work to one another the way teams already do, by writing files, with state on disk rather than in one fragile megaprompt.
Using Moonshot, a real, in-use pipeline, as its case study, the session shows how this structure changes what agents can reliably build, and why it grows gracefully as new responsibilities are added rather than collapsing into a rewrite. Expect a practical look at the pattern, the tradeoffs, and the open questions still in play, rather than a finished blueprint.
Key Takeaways:
- A coordination pattern for multi-agent systems that uses durable artifacts and on-disk state instead of one giant shared context.
- The case for decomposing work into narrow, single-purpose agents rather than one do-everything agent.
- A handoff design that lets the pipeline grow new stages without a rewrite.
- How artifact-based coordination makes each step's work inspectable and easier to trust.
- The ongoing considerations being worked through as the framework matures.
Alexis Brignoni is a Process Optimization Developer in Nelnet's AI Lab. With a background in data science and analytics engineering, she brings a methodical, process-first approach to building with AI. Her team is developing an AI-native software development platform: the framework and practices that let teams compose specialized AI agents into pipelines, moving work from idea to shipped, reviewed code.
Shane Eising is an AI Integration Engineer at Nelnet's AI Lab, where he builds production AI systems that span the gap between stakeholder requests and shipped code. He is a contributor to Moonshot, Nelnet's AI-native development framework. His projects include a platform for AI-enabled MS Teams assistants, and a Claude-based "brain" -- a PM/planner knowledge system built around Markdown.
App Security in 3D: Understanding Context, Behavior, and Intent.
The traditional, two-dimensional approach to AppSec—focused solely on static code analysis and checklist compliance—is failing in the age of hyper-speed CI/CD and complex microservices. We’re building functionality faster than we can secure it. This session will fundamentally shift your security perspective, moving AppSec into the third dimension to achieve true resilience. We’ll dive into how to effectively secure software by integrating three critical factors that define real risk: Context, Behavior, and Intent. Learn to define, deploy, and defend your software by making security smart, dynamic, and resilient.
Steven Carlson is a software engineer who is passionate about clean secure code. He is highly motivated to learn and mentor associates with a positive attitude. If Steven isn’t polishing software, he is speaking at local conferences or surfing the gravel seas on his gravel bicycle.
From Prompts to Control: Designing Safe AI Agents
AI agents are moving from copilots to actors, calling tools, triggering workflows, and making decisions inside systems.
That shift changes the problem. For decades, organizations governed risk through friction, approvals, reviews, and human checkpoints. That bureaucracy was load-bearing governance. Agents remove that friction.
Prompts can shape behavior, but they cannot enforce boundaries. Once agents can act, risk is no longer managed through process or policy. It has to be built into the system.
This session focuses on what it takes to run agents safely in production. We will walk through a small set of practical control patterns:
Encoding risk appetite in agent logic Tool allowlists and action gating Identity and least-privilege for agents Observability across perceive - reason - act
Attendees will leave with concrete patterns to build agents that do not work, but operate within defined, enforceable boundaries.
Amanda has been working with technology her entire life. Some of her favorite childhood memories include working with punch cards alongside her grandmother and learning Morse code from her dad. Solving complex business problems, usually with software, is her passion. She has been delivering AI systems in production since 2008 and now focuses on agent-based systems and how to make them safe to run. Her work sits at the intersection of technology, law, and business, with a focus on embedding governance directly into system architecture. Amanda has worked as a consultant across startups and Fortune 500 organizations. She is a doctoral candidate researching how AI governance signals are interpreted in capital markets under real-world stress.
Control First. Then Autonomy. – Why Most AI Initiatives Fail Before They Scale
Everyone is talking about AI capabilities, autonomous agents, and rapid innovation.
But in reality, most organizations are not struggling with AI itself. They are struggling with structure, governance, ownership, and control.
In this keynote, Dr. Siegfried Isele shares a pragmatic and executive-level perspective on why many AI initiatives fail long before the technology becomes the real problem.
The session focuses on:
Why AI is not primarily a tooling problem The hidden risks of autonomy without governance Why data reality matters more than model hype The importance of operating models and ownership Local AI, sovereignty, and controlled architectures How organizations can scale AI without losing control
Drawing from real-world consulting, enterprise transformation, and international project experience, this session connects Agile thinking, governance, and AI execution in a practical and business-oriented way.
This is not another “AI hype session.” It is a reality check for leaders, architects, transformation managers, and organizations trying to move from experimentation to sustainable AI adoption.
Dr. Siegfried Isele is a Managing Director, senior transformation executive, and board-level advisor with more than 25 years of international leadership experience across insurance, financial services, government, logistics, retail, and technology. He specializes in large-scale modernization and transformation programs, including legacy system replacement, data migration, AI-enabled automation, and regulated platform transformation. Dr. Isele has led initiatives involving hundreds of specialists across multiple continents, operating in highly regulated environments where reliability, compliance, and governance are mission-critical. In addition to his executive delivery leadership, he serves as a Senior Security Auditor (ISO/IEC 27001 & OT Security) and trusted advisor on cybersecurity, operational risk, and regulatory compliance. His board and advisory contributions focus on technology strategy, transformation governance, risk oversight, and executive decision-making. Dr. Isele is known for his pragmatic application of agile principles, bridging structured governance with real-world execution. He holds advanced degrees in economics, law, and business engineering and has completed executive education at Harvard University, MIT, Columbia Business School, UC Berkeley, and IIM Bangalore. He is authorized to work in all Europe (incl. D A CH), the United States, and the United Arab Emirates, as well as he operates internationally.
Lunch
203 ·Deep Agents: Orchestrating Autonomous Workflows
AI agents are evolving beyond simple prompt response workflows into systems fully capable of planning, managing memory with long running execution and autonomous orchestration. In this session, we will explore LangChain Deep Agents and how they extend traditional agent architectures using durable, stateful execution patterns using LangGraph.
Deep Agents can be thought of as an agent harness while maintaining the familiar tool-calling loop but, adds built-in capabilities such as task planning, context-aware file systems, subagent spawning, long-term memory, and execution management. This makes it possible to build AI systems that can reliably handle complex, multi-step tasks beyond simple reactive workflows. The key capabilities of Lang chain Deep Agents include :
- Stateful orchestration and execution graphs
- Long-term memory and context management
- Planning and autonomous task decomposition
- Durable execution, retries, and checkpoints
- Human-in-the-loop workflows
In this talk, we will walk through the architectural differences between traditional agents and modern deep-agent systems, and also live demo how these workflows actually work in practice.
Software Engineer with expertise in backend development using .NET, Generative AI, LLMs, cloud-native architectures on AWS, Infrastructure as Code (Terraform), microservices, and containerized applications. Experienced in designing and building AI-powered solutions leveraging agentic workflows, tool orchestration, RAG architecture and enterprise grade AI agents.
AI Helped Devs, Now it Needs to Help QA
Agentic coding has fundamentally changed how fast teams produce code, but so far, we haven't done nearly as much to accelerate how we test it. Most QA tooling and automation strategies were designed for a world where code arrived in human-sized increments and was authored by someone who could explain the change. That world is gone and it's not coming back.
It's not just the volume of PRs that's changing. AI-generated code arrives syntactically correct but semantically untested and unaware of the larger context in which it will be deployed. The result is additional pressure to ship untested code or teams running above the redline, knowing their safety nets are stretching more every sprint.
This talk examines how QA can match AI-accelerated development, why "just write more tests" isn't a strategy, and what it looks like to agentically QA all that agentically developed code. We'll cover steps developers must take before submitting PRs, contract testing at the AI boundary, prioritizing human verification where it matters most and building feedback loops that flag drift before it reaches production.
Chris Perrin is a tech geek, chaos wrangler, and all-around software leader with a knack for building high-performance teams and systems. With over 20 years of experience in software engineering, he’s helped teams—from the noblest of startups to giantest of enterprises—navigate the wild world of software development, Agile lifecycles, and getting more done. Chris loves demystifying complex tech, creating buzzwords and then turning buzzwords into real-world solutions. Whether he's talking about microservices, team performance, or trying to get AI to do his job, he brings energy, humor, and plenty of practical takeaways to every talk. When he’s not writing code or breaking things in the name of innovation, you’ll find him mentoring up-and-coming devs, writing decent-to-okay fiction, and geeking out over the latest in geek. Catch him at the conference, on LinkedIn, or wherever there’s strong coffee and great conversations!
Coding Agents From Nothing
Tools like Claude Code, Codex and Copilot have emerged over the last couple of years as a game changer for software engineering - fundamentally changing the unit economics of software development. They sometimes feel like magic, and out of reach of being understood by normal software developers, but nothing could be further from the truth!.
In this session, we'll pay attention to the man behind the curtain, and build our own agentic coding tool from scratch using a model running on a laptop - giving insights that will improve your daily use of the big name tools.
James is a software engineer from Bath, England. He is currently a Technology Fellow at General Motors, and has worked in senior engineering roles at Apple, HashiCorp, Boundary, Samsung Electronics and Jet.com. He is a connoisseur of West Country cider and old guitars.
Fine-Tuning Frontier Models on Apple Silicon: A Practical Guide to MLX-Powered Local LLMs
Abstract: As organizations scramble to deploy generative AI at scale, the economics and privacy implications of cloud-based inference are becoming untenable for many use cases. This talk presents a comprehensive, hands-on exploration of fine-tuning and deploying frontier-class language models on Apple Silicon hardware using the MLX framework — an approach that delivers production-grade performance at a fraction of cloud costs while keeping data on-device. Drawing on real-world deployment experience, we'll walk through the full pipeline: from model selection and quantization strategies, through LoRA/QLoRA fine-tuning workflows, to production-ready inference optimization. We'll cover practical benchmarks comparing MLX against traditional frameworks, discuss the trade-offs between model size, quantization level, and task performance, and share lessons learned from deploying fine-tuned models in enterprise environments. The talk will include live demonstrations of model loading, fine-tuning, and inference on M-series chips, along with actionable recommendations for teams evaluating on-device AI deployment. Whether you're an ML engineer looking to reduce inference costs, a solutions architect designing privacy-first AI systems, or a researcher exploring efficient model adaptation, this session provides the technical depth and practical guidance needed to get started with MLX-powered local AI.
Key Takeaways: • MLX delivers competitive inference performance on Apple Silicon with dramatically lower costs than cloud alternatives • QLoRA fine-tuning on M-series chips makes frontier model adaptation accessible without GPU clusters • On-device AI enables privacy-preserving deployments that cloud inference simply cannot offer • Production deployment patterns for MLX include model quantization, batch optimization, and memory management strategies • The enterprise case for local AI hinges on cost reduction, data sovereignty, and latency improvements
I am a seasoned Solution Architect at AT&T with over 25 years of experience designing and architecting mission-critical systems. Alongside my professional career, I am a dedicated AI educator and researcher exploring the intersection of advanced computational architectures and classical linguistics. My current work focuses on building high-performance local AI environments and optimizing "frontier-class" models on Apple Silicon using the MLX framework. I actively mentor students on integrating agentic AI workflows and developing specialized LLM applications for complex domain analysis.
From Copilots to Autonomous Systems: Enterprise Patterns for Agentic AI
Enterprise AI is rapidly evolving beyond chatbots and copilots toward autonomous systems capable of reasoning, planning, tool usage, and multi-step execution across enterprise workflows.
But building agentic systems requires far more than connecting an LLM to a user interface. As organizations move beyond experimentation, architects are encountering new challenges around orchestration, memory, governance, observability, cost control, and operational reliability.
In this session, we will explore the emerging architectural patterns behind enterprise-grade agentic AI systems, including:
- Planner–Executor architectures
- Multi-agent coordination patterns
- Tool-using AI systems and workflow orchestration
- Long-term memory and contextual reasoning
- Human-in-the-loop governance models
- AI observability and operational safeguards
- Deterministic vs. agentic system boundaries
Through practical enterprise scenarios and architectural walkthroughs, attendees will see how autonomous AI systems can support workflows such as cloud modernization analysis, compliance evaluation, operational troubleshooting, and infrastructure optimization.
Rather than focusing solely on models, this session examines the broader system design challenges required to operationalize AI safely and effectively in enterprise environments.
Attendees will leave with practical frameworks, architectural tradeoffs, and implementation patterns they can apply when designing scalable and trustworthy AI systems within their own organizations.
Cloud Architect @ OCI | Enterprise AI & Agentic Systems | Autonomous AI Architectures | Senior Member IEEE I help enterprise organizations design scalable cloud and AI systems that balance performance, governance, operational reliability, and business outcomes.
AI Agents Need Escalation Paths
AI agents are rapidly moving from experiments into production systems — making decisions, triggering workflows, coordinating tasks, and operating with increasing autonomy. But most organizations are still deploying agents without a clear answer to one critical question:
What happens when the agent gets it wrong?
Most AI systems today are optimized for speed, automation, and output quality — not intervention, uncertainty handling, or operational accountability. As agents become more deeply integrated into enterprise systems, customer experiences, research environments, and developer workflows, the absence of escalation logic becomes a serious systems risk.
This session explores why escalation architecture is becoming essential infrastructure for trustworthy AI agents.
Through real-world workflow examples and practical oversight scenarios, attendees will examine how modern AI systems can be designed to:
- detect uncertainty before failure scales,
- escalate high-risk outputs to humans,
- reroute unsafe or conflicting actions,
- and create operational checkpoints inside autonomous workflows.
Attendees will also be introduced to ReasonGate™, a human-centered escalation framework designed for AI-powered environments where intervention, accountability, and human judgment must coexist with automation.
Rather than slowing innovation down, escalation pathways help organizations build AI systems that are more resilient, monitorable, trustworthy, and deployable at scale.
This session is designed for developers, architects, AI practitioners, founders, technical leads, and teams building real-world AI agent systems.
KEY TAKEAWAYS:
- Learn why escalation logic is becoming a core requirement for production-grade AI agents.
- Identify hidden failure points inside autonomous workflows before they become operational risks.
- Explore practical human-in-the-loop patterns for routing uncertainty, contradictions, and unsafe outputs.
- Understand how oversight checkpoints strengthen trust, governance, and long-term AI reliability.
- Discover how the ReasonGate™ framework applies pause, redirect, reframe, and refusal logic inside agent ecosystems.
Dr. Tajah M. Gross is Founder & CEO of Ethilect, an ethical AI governance, risk, and decision intelligence firm helping institutions and leaders navigate the human impact of artificial intelligence. A nationally emerging voice in AI ethics and organizational foresight, Dr. Gross specializes in human-centered AI systems, governance, risk, trust, and responsible implementation. Her signature methodology, Question Everything, and framework, ReasonGate™, help organizations and risk leaders identify hidden AI risks influencing decision-making, workforce confidence, and institutional accountability. Dr. Gross has delivered high-impact sessions for nationally recognized venues including North Carolina A&T State University and DLAC Ignite.
The Interface Is Dissolving: Designing UI for an Agentic World
For thirty years, we built interfaces around one assumption: a person points, clicks, types, and navigates to a result. Agents break it. When software can read intent and act on its own, the interface stops being something you operate and becomes something you supervise. "Just add a chat box" is the wrong lesson from the last two years.
The work shifts from navigation to delegation. We no longer design the clicks to finish a task. We design how someone asks for it, watches it run, and decides whether to trust what comes back. That raises the hard questions: how to show an agent's reasoning without burying the user, when to build in moments to approve or correct, and what "undo" means once an action has already touched five systems.
Chat is a stage, not the finish line. The teams that win won't have the smartest agents. They'll have designed the clearest line between human judgment and machine action.
In 2000, Chad graduated with a degree in Computer Engineering. He then graduated from the University of Nebraska, Lincoln in 2003 with a Masters in Computer Science. After college, he worked for STI, MindVision/eSellerate/DigitalRiver, and Internap before ending up at Nebraska Global / Beehive Industries / Don’t Panic Labs. Chad is a lifelong Nebraskan. He grew up in rural Nebraska and now lives in Lincoln. Chad and his wife have a son and daughter.
Building AI Systems that Ship
Most agent demos break the moment they leave a controlled environment. The model works fine. The systems around it don't. In this talk, I'll walk through what "agent-ready" means from two sides: a codebase agents can safely change, and a product agents can reliably use. I'll use two real projects as examples: Case, a harness for orchestrating coding agents, and the WorkOS CLI. Together, they show how to give agents real freedom while keeping quality high through clear constraints, machine-friendly interfaces, and feedback loops that compound over time.
Nick Nisi is a Developer Experience Engineer at WorkOS, where he helps developers build faster and smarter for the modern web. A long-time TypeScript advocate, Nick has organized events like NEJS Conf and TypeScript Conf, emcee'd more than a dozen conferences, and taught JavaScript workshops for years. He previously co-hosted the JS Party podcast and continues to share his passion for developer experience, open source, and the craft of building great software.