MITechCon 2026: Build the Guardrails Into the System

Rochester was founded by the Graham family in 1817 and named after Rochester, New York. It became the first European settlement in Oakland County. It was later the birthplace of Madonna and hosts the The Big, Bright Light Show which is a holiday light display that is one of the largest in the world with over 1.5 million lights bringing holiday cheer to the community.

More than two centuries later, the city welcomed Michigan's technology community to examine another kind of foundation. The systems surrounding a new capability determine how safely people can use it and how much lasting value it creates.

Michigan Technology Conference 2026 ran October 29 and 30 at Oakland University in Rochester. The sold-out event brought together 300 technology practitioners for 48 sessions across ten topic areas.

AI appeared throughout the program. The strongest sessions treated AI as one component inside a larger operating system of permissions, checks, data, people, and recovery plans.

Durable guardrails live in the system.

Build What Creates a Competitive Advantage

Jason Bressler, EVP and CTO at UWM, opened with “Build vs. Buy in the AI Era.” His framework began with a practical observation. No single answer works for every capability.

Teams should ask whether a capability differentiates the business, how much control it requires, and how deeply it must integrate. Long-term cost and the pace of AI development also shape the answer.

UWM chose ownership for systems that depend on proprietary processes and permissions. Its ChatUWM assistant began with internal process guides and training material. The company later opened parts of the experience to loan officers and used their questions as direct market research.

Adoption decides whether that investment produces value. Jason called for teams to redesign workflows, challenge existing processes, and keep experimenting. Faster execution of an unchanged process captures only part of AI's potential.

Technical leadership also requires deep business context. Engineers gain leverage when they understand how the organization operates and can connect technology decisions to business outcomes.

A Deterministic Gate Can Stop a Dangerous Tool Call

Jonathan Stewart, also known as SQLLocks, presented “Your AI Agent Just Ran DELETE Without WHERE. Now What?” The title came from a real failure. An agent ran a destructive infrastructure command against production after skipping the normal confirmation.

Prompt instructions provide guidance that can disappear inside a long conversation or lose to competing instructions. Jonathan placed a small program between the agent and its tools. The gate inspects every call and blocks recognized destructive commands before they reach the target system.

The example gate used about 200 lines of JavaScript. It added roughly 50 milliseconds to a tool call and required no model, network, or database.

A useful gate still allows safe work. Jonathan described it as a tripwire with a known perimeter. Exact command matching catches obvious destructive calls, while database permissions provide a deeper boundary.

Agents should receive the smallest account that can complete the job. Read access comes first. Write access belongs only where the workflow needs it, and delete permission can remain unavailable.

Recovery begins before the first write. Create a restore point, understand the recovery window, and rehearse the restore process. During an incident, stop the agent, record the time, and plan the repair before changing more state.

Reliable Operations Form a Closed Loop

Robert Gray III explored “The Invisible Stack: Black-Ops of Modern Enterprise.” Customers see outcomes while the operational disciplines behind them remain largely invisible.

His model connected DevOps, DataOps, AIOps, and FinOps in one loop. Delivery velocity produces a cost signature. Cost signals influence data and AI priorities. Trusted data supports prediction, and prediction enables safer delivery.

Fragmented incident, root-cause, and change data breaks that loop. Robert described a three-phase roadmap built around visibility, prediction, and action. Normalized operational data supports a shared source of truth. Predictive scoring can then feed CI/CD decisions in real time.

The resulting incident command center cut major-incident resolution time by 50 percent and reduced the number of people involved by 70 percent. Ownership after launch kept the system useful. A cross-functional group continued setting priorities, tracking value, and governing changes.

Critical Code Needs Predictable Limits

Jonathan “J.” Tower brought safety-critical engineering into modern application development with “Mission-Critical Code: What NASA's Power of Ten Can Teach Us.”

The history began with Margaret Hamilton and the Apollo guidance computer. Unexpected radar input overloaded the system during the lunar landing, while priority scheduling preserved the work required to land.

Later failures showed the stakes closer to Earth. A race condition in the Therac-25 radiation machine delivered massive overdoses. A software defect at Knight Capital created millions of dollars in losses within minutes.

NASA's original Power of Ten rules targeted C and C++. J. translated their goals into modern development. Predictable loops need explicit bounds. Collections and caches need size limits. Functions should remain short enough to understand and review.

Return values require checks, and static analysis should run continuously. Roslyn analyzers, CodeQL, and SonarQube can turn local rules into automated guardrails.

Every organization can define its own power of ten. The rules should match the consequences of failure and remain enforceable through tooling.

Purpose, Curiosity, and Honesty Strengthen Architecture

Sarah Wimberley shared “Three Lessons from a Woman in Enterprise Architecture.” Her lessons connected purpose, curiosity, and authenticity with better technical leadership.

Purpose improves motivation, resilience, and decision-making. Honest goals provide useful fuel because people invest more consistently in work they genuinely value.

Curiosity pushes architects to dig deeper and approach a system with empathy. Authenticity builds trust and makes room for people to contribute ideas that differ from the dominant view.

Sarah also encouraged leaders to acknowledge where their knowledge ends. Visible limits create a professional roadmap and reduce the exhaustion of pretending to have every answer.

“Be better, not right.”

AI Enablement Should Raise the Floor

Adam Broadbent reported on a five-phase enterprise rollout in “Floors, Not Ceilings: Lessons from 6 Months of AI Enablement at a $10B Company.”

The rollout started by collecting engineers' fears before training. People raised concerns about surveillance, job stability, and pressure to maximize token usage. Those fears gave the program a more realistic starting point.

Security controls initially blocked so much network access that the coding assistant became an expensive autocomplete tool. The team adjusted the boundary and kept deterministic checks around consequential actions.

“A rule is a hope. A check is a fact.”

Early productivity estimates reached 300 percent when AI calculated the result. A grounded review found about 30 percent improvement, alongside a 43 percent increase in bugs. Ten people generated 58 percent of all sessions.

Those numbers shifted the goal toward capability. Leaders began asking what each person could do now that they could not do before. A learning ladder gave engineers clear skills and levels, while facilitators focused on quieter people who needed help taking the first step.

Context Costs Drive Agent Architecture

Rajkumar Sakthivel examined the economics of context in “Your AI Reads Entire Files. It Only Needs 6%. Here's How We Fixed It.”

Input accounted for about 90 percent of token spending in the project. Better prompts, model settings, and output compression produced little improvement.

The team inserted a local search layer between the codebase and the model API. Tree-sitter parsed the code, hybrid retrieval found relevant sections, and a confidence score filtered the final context. The intentionally simple architecture reduced the material sent to the model.

Team memory created a harder problem. Each developer's agent accumulated decisions in separate local folders. Sharing everything threatened privacy, while sharing nothing encouraged teams to contradict one another.

Rajkumar separated personal memory from explicit shared records. Local network synchronization and Git signals helped surface relevant decisions at query time. Fully local, private, and team-aware memory remains an open design challenge.

Edge AI Starts With Physical Constraints

Jared Rhodes mapped the edge from regional infrastructure to leaf devices in “AI on the Edge.” Latency, connectivity, privacy, and bandwidth determine where inference belongs.

Emergency-response training provided one example. Smoke from a simulated disaster could disrupt connectivity, so local inference kept critical analysis available. Traffic cameras offered another. Pole-mounted hardware processed video and sent smaller telemetry streams to the transportation facility.

Industrial sites add financial and safety pressure. Pipeline and factory downtime can cost hundreds of thousands of dollars per hour. Remote locations may also sit hours away from the nearest technician.

Model selection begins with memory, speed, accuracy, portability, and maintenance. False negatives can carry severe consequences, so the acceptable accuracy tradeoff depends on the use case.

Distillation, quantization, and pruning can fit capable models onto smaller hardware. Fleet orchestration then handles versions and deployment across cloud and edge environments.

Communication Structures Become Software Structures

Luis Fernandez connected organization design with system design in “Don't Let Your Org Chart Write Bad Code.”

Essential complexity comes from the problem itself. Accidental complexity enters through the people, structures, and decisions surrounding the work.

Large software systems have many authors across teams. Communication paths shape the interfaces and boundaries those teams create. Conway's law explains why the same technical design can produce very different systems inside different organizations.

Luis compared a standardized fast-food kitchen with a Michelin restaurant. Standardized roles let one operation absorb staff changes. Specialized expertise makes the other operation more dependent on particular people.

Architecture has to account for those human dependencies. Team Topologies offers patterns for shaping communication so the organization can support the system it wants to build.

Design the Boundary Before Granting the Capability

MITechCon 2026 showed how much of technology's value comes from the structures around it.

Build-versus-buy decisions depend on business context. Agent safety depends on executable gates and restricted accounts. Critical code depends on explicit limits. AI enablement depends on training, measurement, and checks that survive pressure.

Context layers can reduce cost. Edge architectures can preserve service through weak connectivity. Team design can reduce the accidental complexity that becomes software.

Your author presented “Probably Secure: What We Misunderstand About AI and Determinism Is Making Us Less Secure.” The session explored the same conference-wide lesson. Probabilistic systems create useful options, while deterministic controls enforce the boundaries around consequential actions.

Rochester's first settlement established a foundation for the communities that followed across Oakland County. Modern technology programs need foundations of their own. Permissions, recovery plans, shared context, and enforceable checks give powerful tools a safe place to operate.

Build the guardrails into the system.