- The question
- What if AI did the work—and humans only handled what actually needed their attention?
- The idea
- A command center where agents work across projects, tools, and infrastructure while the human stays focused on decisions that actually matter.
- The build
- A native macOS desktop application: an AI-native command center built around human attention, agent activity, goals, evidence, and intervention.
Randy Kendel · Product / Technology / Transformation
I rethink how work gets done.
For 20+ years, I’ve worked across product, technology, and transformation—helping organizations solve complicated problems at scale.
Today, I combine that experience with hands-on product building and AI to question the assumptions underneath those problems, simplify the model, and build what comes next.
The questionWhy does this have to be so complicated?
What I actually do
A way of working, not a list of skills.
- 01
Reimagine
Question the model behind the problem.
Find the assumption everyone has accepted simply because that’s how it has always worked.
- 02
Simplify
Start with the outcome.
Remove unnecessary processes, systems, handoffs, and complexity.
- 03
Build
Turn the idea into something real.
Prototype quickly. Test it. Learn from it. Keep going when the idea survives contact with reality.
- 04
Execute
Make it work at scale.
Move between strategy, product, technology, operations, compliance, and the people required to actually deliver the result.
The Randy Experience
Don't take my word for it. Give me a problem.
Bring something that shouldn't be this complicated. Leave with a practical Simplification Brief.
Selected work · evidence, not inventory
A few problems I couldn't leave alone.
These aren't a collection of startups. They're experiments in what happens when you question the model underneath a problem instead of simply optimizing the existing one.
02A different software foundation
What if software didn’t have to stay running?
Connected experiments
- The question
- Why are applications built around permanently running software, tightly coupled services, databases, and infrastructure?
- The idea
- Applications that can exist, connect, execute, and recover without requiring the traditional always-on stack.
- The build
- Three working layers of that model: durable state, portable capabilities, and composable applications.
- The question
- Why does messy operational work have to become a software implementation project before anything useful can happen?
- The idea
- Turn messy inputs into governed actions.
- The build
- A system that understands operational inputs and turns them into structured actions across existing business workflows.
- The question
- Authentication tells you who is acting. Why does nothing define what that actor is actually allowed to cause?
- The idea
- Authority is not identity. Separate who is acting from what they are permitted to do.
- The build
- An authority boundary: applications expose explicit capabilities, policy grants them to each principal, and every authorization decision records why it was allowed or denied.
Career proof
I've done this at scale, too.
The experiments are new. The underlying capability isn't.
I've spent 20+ years working inside complex organizations where simplifying the problem isn't optional—it's the job.
- 01
Sun Life / DentaQuest
Transformation
Simplify the enterprise after change.
- Post-acquisition integration
- Enterprise modernization
- Product, data, and workflow simplification
- 02
Amazon Web Services
Customer Experience
Make global scale feel local.
- Owned customer experience for global commerce
- International expansion initiatives
- 03
CVS Health
Delivery at scale
Deliver when the stakes are real.
- Led teams delivering and scaling the CVS Digital COVID Vaccine Scheduler
From enterprise transformation to things I build myself, the pattern is the same: understand the real problem, rethink the model, and make something happen.
Reality changes. Meaning must endure.
The environment changes.
The principles don't.
Enterprise transformation. Product strategy. AI-native software. A workflow that makes no sense. A system everyone has learned to work around.
Start with the same question
Why does it have to work this way?
Thinking
Principles for durable systems.
Build around identity, context, intent, evidence, provenance, and understanding. Everything else is a projection.
Principle 01
Durable Representation
Every meaningful domain contains an authoritative representation.
A durable representation is not simply stored data. It preserves the identity, relationships, provenance, and meaning necessary to understand what a system knows about a domain as its projections, implementations, and environments change.
It is not a view, a report, a document, or a UI. It is the stable object around which the system revolves. Everything else is a projection.
In practice
- Operations → Canonical Meaning
- Knowledge → Signals and Understanding
- Software → System Models
- Execution → Intent and Outcomes
- Testing → Runtime Truth
Bring me a complicated problem
Have a problem that shouldn't be this complicated?
Tell me what you're trying to accomplish.
I'll probably ask why you're doing it that way.