Johnmicah Joseph Potter · Principal AI architect · fractional AI CTO
Most enterprise AI stops at the demo. I set the strategy with your executives and own the architecture that answers it, then stay on the hook until it’s running in production and can clear a security review.
Twenty years at Fortune-500 scale. Led architects and platform teams. Co-inventor on a filed patent.
Twenty years at Fortune-500 scale
Twenty years at Fortune-500 scale
Companies I built software inside, as an engineer and as an architect. This is where I worked. They are not clients of this practice and not endorsements.
Built, not described
Twenty years building enterprise software in banking and healthcare.
Agentic AI I built and still run in production.
Co-inventor on a filed patent for enterprise code generation.
Security and governance I owned across a regulated cloud estate.
The pilot trap
A demo wins the room. Then it meets the integration work, the security review, and the budget conversation, and it quietly stops moving. MIT’s 2025 study of enterprise generative AI found 95% of pilots produced no measurable P&L impact. Almost none of that is the model’s fault. What’s missing sits underneath it: architecture, engineering discipline, and someone senior enough to answer for it when it breaks.
The demo lands, and then someone asks where the data lives, who pays for the tokens, and which team carries the pager. Usually the answer is nobody.
No evaluations, no logs, no data lineage. When someone asks how the system reached that answer, there’s nothing to show them.
A prompt wrapper takes a weekend, and a competitor can have one by Friday. The work that pays for itself is the system that takes a whole task off someone’s desk.
Strategy, architecture, and delivery sit with three different people, and nobody answers for whether it works.
What I do
The same operating model every time. Set the AI strategy with your executives, own the architecture that answers it, and stay accountable for what reaches production. Whatever works gets packaged so your engineers can build the next one themselves.
Multi-agent systems that carry real work.
Specialized agents that research, decide, act across your tools, and check their own work — grounded in your data, inside limits a regulated business can defend.
Make the engineering org AI-native, and make it stick.
Code-generation agents, automated pull-request review, and sprint automation your engineers keep using after the novelty wears off. Plus accelerators that make the next project faster than the last.
Executive AI leadership, without the full-time hire.
Strategy set with your leadership team, architecture owned, delivery answered for, and reporting a board can act on. One, two, or three days a week, depending on what the work needs.
The unglamorous layer that decides whether AI survives.
Retrieval you can trust, evaluations that run before release, observability, access control, and a cost line that stops surprising you.
The path
Every organization sits somewhere on this path. Most are stuck in the first two stages — plenty of activity, nothing a CFO can see yet. The work is naming your stage without flattering yourself, then making one jump well.
The first two stages don’t compound. The advantage lives in the last three.
Experiments
Subscriptions, prompts, a few pilots. Nobody owns it, nothing is measured, and no decision has changed because of it.
Copilots
Copilots and assistants doing real, repeatable work. A person is still in every loop, and the savings are hard to find in the numbers.
Autonomy
Agents take multi-step action across your systems — grounded in your data, inside guardrails, and monitored like any production service.
Leverage
AI runs through engineering, operations, and how decisions get made. New work is designed for agents from the start.
Compounding
Systems that improve on their own evaluation data, with people on the exceptions and a trail behind every decision.
You can’t plan the jump until you know which stage you’re on. The assessment places you in about five minutes.
Start the assessmentWhat actually matters
Models stopped being the hard part a while ago. What separates a demo from something people rely on is underneath it: how it’s grounded, what it’s allowed to touch, how its answers get checked, and how it behaves on a bad day. That’s the part I’ve spent years on.
The craft underneath
Answers from your systems, with the source attached.
Multi-step work across your tools, start to finish.
It can only do what you allowed.
Evaluations catch the weak answer before a person does.
Every run traced. Every decision explainable later.
Designed in from the first sprint, while it’s still cheap.
Cost, latency, and reliability that survive real volume.
How engagements work
The organizations I work with usually run from 500 to 5,000-plus people, in regulated or publicly accountable settings, where AI has to clear a security review, an audit, and a budget conversation before it ships. Every engagement starts the same way: a read of where your AI really is, not where the pilot deck says it is. From there comes an architecture and a roadmap your board can approve. And when the work is big enough to need it, an experienced AI leader in the room every week, answerable for what ships.
A baseline, in about five minutes.
No cost
Self-serve, no call required. It places you on the five-stage path from experimenting with AI to running on it, names the constraint holding you up — data, architecture, governance, or delivery — and tells you the one move worth making next.
The architecture, and the build that proves it.
From $30K · fixed-fee
I own the technical design and stay on it through delivery. You get an architecture your security team can review and your CFO can cost, agentic systems grounded in your own data, evaluations and observability that catch a bad answer before a customer does, and controls that hold up under scrutiny. Your engineers build it with me on the hard parts — agent orchestration, retrieval, evaluation, the infrastructure underneath. $30K is where a diagnostic starts; a full production build runs from $125K.
Thirty minutes, one on one.
Projects are fixed-fee against a written scope, agreed before any work starts; fractional leadership is a monthly retainer with a short initial term. You keep the architecture, the code, the evaluations, and the decision record — including anything reusable we build along the way.
Why me
Co-inventor on a filed patent for a multi-agent code-generation platform inside a large financial institution, still in production today. Around it: an MCP server searching millions of meeting-transcript segments, and agents that read every pull request before a human does.
Strategy with executives, the architecture, accountability for what ships, and the governance under all of it. Since 2021 I’ve held an executive advisory seat inside a large healthcare organization, close enough to the budget that AI proposals reach me before they get funded. I’ve also led a developer-experience team serving other engineering groups, run the infrastructure behind 17 production AI applications, and owned every security policy and remediation across a regulated cloud estate.
Teams I’ve actually run: five architects whose standards the rest of engineering built against, five platform engineers whose one-on-ones and retros I ran, front-end teams I hired and trained, and a startup’s entire engineering organization built from nothing. I also still write the agent orchestration and the evaluation harness myself. And the engineers who inherit one of these systems have been taught what it does on a bad day.
Credentials
The short version, for anyone doing diligence. Every line is checkable, and I’ll walk through any of it on a call.
Twenty years at Fortune-500 scale
Banking, healthcare, retail, and manufacturing. Systems serving millions of users, on platforms used by more than a thousand engineers.
Co-inventor on a filed patent
For the multi-agent code-generation platform built inside a large financial institution.
Trained by Anthropic’s enterprise team
Anthropic’s own engineers trained the enterprise team I was part of on building with Claude in production.
Led architects and platform engineers
Five architects setting the standards a much larger engineering organization built against, plus platform and front-end teams.
Degree and certifications
B.S. Computer Information Science; Google Cloud certified; Certified ScrumMaster (Scrum Alliance); Red Hat Certified Administrator.
Toptal — top 3% network
Member since 2020.
Published author on containers
“Risk vs. Reward: A Guide to Understanding Software Containers.”
The comparison
These are the three real options. Here’s where each one genuinely wins, including where I don’t.
Not sure where you stand? The AI Maturity Assessment places you in about five minutes.
Questions
Next to your leadership and above the code. I set the AI strategy with your executives, own the architecture, and stay accountable for delivery quality while your engineers do the building. I’ve led architects and platform teams inside large enterprises, so I know the difference between an outsider handing down opinions and someone who has to defend a design in the room with security and finance. Your team keeps the work. I make sure it holds up.
Both, deliberately. I architect the system and I write code on the hard parts: the agent orchestration, the retrieval layer, the evaluation harness, the infrastructure it runs on. Advice that has never survived production is just an opinion. Engagements end with something running.
Senior AI leadership without the full-time hire. I own the strategy, the architecture, the roadmap, and the standards your teams build against, and I report to your board in language they can act on. Companies use it when they need an AI executive in the room now and can’t justify a permanent one yet.
By designing for it first, because governance bolted on afterward never holds. Answers are grounded in your own data with sources you can trace. Evaluations run before a release ships. Logging is detailed enough for someone to reconstruct what the system did and why, months later. Every tool an agent can reach is least-privilege, and a person stays in the loop wherever the decision warrants one. I owned the security vulnerabilities, policies, and remediation for a regulated healthcare cloud estate, and I built AI inside a financial institution under the same kind of scrutiny. Both taught the same lesson: the system that can explain itself is the one that gets to stay in production.
We agree the measure before the build starts. Usually cycle time, cost per task, deflection rate, error rate against a human baseline, or plain license and infrastructure spend — instrumented inside the system, so the number comes from telemetry and not from a slide. On the code-generation platform I co-invented, the measure was development cost avoided: millions a year. Elsewhere it was cloud spend down 30–50% after we went through it line by line. If a workload can’t be measured, that’s usually a sign it isn’t the right first workload.
All of it: the code, the architecture, the prompts and context strategy, the evaluation suites, the infrastructure-as-code, and the written record of why each decision went the way it did. Teaching your engineers is part of the scope, scheduled and paid for like everything else — pairing, code review, and working sessions on agentic design patterns and responsible deployment. I’ve run programs like that for years. Anthropic’s enterprise team trained the team I was on, directly, on building with Claude, and I’ve been passing that on ever since.
Start with the AI Maturity Assessment. It takes about five minutes and places you on the five-stage path from experimenting with AI to running on it. Pilots usually stall for one of four reasons: nobody senior enough owns it, there’s no architecture underneath it, there’s no path through security, or nobody agreed on the measure. The assessment tells you which one is yours. The first working session turns that into a plan you can fund.
Small, and in writing. Most begin with a paid working session or a two-to-three-week diagnostic, fixed fee and scoped before anything starts, so you see how I think before committing to a build. Projects run from $30K for a diagnostic to $125K and up for a production build; fractional leadership is a monthly retainer from $15K. The assessment is free and tells you which one fits.
You can stop. Projects are fixed-fee and scoped up front, so there’s no runaway bill, and the retainer runs month to month after a short initial term instead of a multi-year lock-in. You keep the architecture, the code, and the reasoning either way. I’d rather tell you early that a workload isn’t worth automating than bill you to discover it slowly.
The assessment takes about five minutes and gives you your stage, your real constraint, and the next move worth funding. If you’d rather talk it through, take thirty minutes with me. You’ll get a real answer either way, whether or not we end up working together.
