Absorb Complexity. Preserve Agency.
Most software asks humans to learn the machinery.
We think that is often backwards.
A person should not need to understand our repositories, schemas, queues, model routing, retries, state reconciliation, APIs, or organizational boundaries to receive useful help from a system. Those are implementation responsibilities. When we expose them unnecessarily, we have not removed complexity. We have transferred it.
That distinction matters more as AI systems become capable of operating across more tools and more of a person's work.
Our design stance is simple:
Absorb complexity. Preserve agency.
The first half is about service.
The second half is about power.
Complexity has to live somewhere
Every useful system contains complexity.
A kitchen contains ingredients, timing, heat, preparation, technique and cleanup. The diner receives a meal.
A DJ manages selection, phrasing, gain, EQ, monitoring, transitions and uncertainty. The room receives music.
A software system manages data, permissions, state, failures, integrations and execution. The human should receive an experience that helps them accomplish something.
The complexity did not disappear in any of these examples.
Someone absorbed it.
This gives us a useful test:
When we say we simplified something, who became responsible for the complexity we removed?
If the answer is "the user," we probably did not simplify the system. We displaced its complexity.
A product that makes a person understand which internal service owns their problem has exported organizational architecture into the experience.
A workflow that makes a person copy the same information between three tools has exported integration work into the experience.
An AI agent that produces a recommendation and then makes the person manually reconstruct all the setup required to act on it has exported orchestration work into the experience.
Sometimes those boundaries are unavoidable. Often they are just familiar.
Familiar friction is still friction.
Do not charge cognitive rent for implementation decisions
The cost of unnecessary complexity is not evenly distributed.
Every extra concept a person must remember, every unexplained state, every repeated field, every tool boundary and every "you need to know how our system works first" consumes attention.
That attention belongs to the human.
We should have a good reason before spending it.
This is especially important in systems used by frontline workers. The person may already be serving a customer, reviewing a case, moving through a physical environment, handling an exception, or making a consequential judgment.
The software should not compete with the work.
It should support it.
This is one reason Teambotics is interested in voice-first and agentic interfaces. The goal is not to put a chatbot on top of every workflow. The goal is to reduce how often a human has to become the integration layer between systems.
Invisible machinery is not invisible authority
There is a danger in taking this principle too far.
A beautifully simple system can hide not only complexity, but power.
An AI can reconcile ten sources and return three recommendations. That may be excellent design.
But if it quietly decides which email did not matter, which task should be postponed, which customer should receive a message, or which commitment should appear on a person's calendar, simplicity can become a way of hiding consequential judgment.
So the second half of the principle matters:
Preserve agency.
The human should not have to operate the machinery merely to retain authority over meaningful choices.
That means distinguishing between two kinds of friction.
Accidental friction
Repeated data entry.
Finding the right repository.
Remembering which system owns a task.
Moving information between tools.
Reconstructing context the system already has.
Navigating implementation boundaries.
We should aggressively remove this.
Meaningful friction
Approving an external message.
Committing time.
Spending money.
Changing a consequential record.
Publishing something.
Making a decision that is difficult to reverse.
We should be careful before removing this.
A confirmation step can be bad UX.
A confirmation step can also be the exact point where human agency lives.
The question is not "can we automate this?"
The question is "what would the human be surrendering if we did?"
A practical example: the report should become a control surface
We recently started dogfooding a Standing Agent called Shift Manager.
Its job is deliberately boring underneath. It reads a previous checkpoint, inspects material changes across authorized sources, reconciles what they mean, looks at tracked work and calendar capacity, then prepares the next human operating shift.
The first useful run exposed an experience problem.
A report could correctly tell the human what mattered and still leave them with the boring work of turning that understanding into action.
Open the tracker.
Find the issue.
Open Calendar.
Find a free block.
Create the event.
Remember why it was scheduled.
So the next iteration changed the experience.
Shift Manager can now end with bounded options such as:
- Reserve a specific work block for an existing tracked issue.
- Create a tracked issue for a newly discovered piece of work.
- Carry an item into the next shift without scheduling it.
The machine does the reconciliation and preparation.
The human chooses.
That is the principle in miniature:
Absorb complexity. Preserve agency.
Good infrastructure should be boring
We like boring infrastructure.
Not neglected infrastructure. Not primitive infrastructure.
Boring.
Clear ownership. Predictable state. Deterministic rendering. Explicit authority. Small interfaces. Known failure modes. Reusable tools. Few surprises.
The experience built on top of it can be delightful, strange, creative, fast, conversational or even magical.
The machinery underneath should not need to perform magic tricks.
This is similar to good DJing.
The crowd does not need to appreciate the gain staging. They should notice the night.
Good execution often makes the executor less visible.
AI products sometimes move in the opposite direction. They advertise the intelligence constantly. They narrate every operation. They decorate ordinary actions with AI language. They make the model the protagonist.
We would rather make the human's outcome the protagonist.
The intelligence can become infrastructure.
Invisible is not secret
There is one final boundary.
We want complexity to disappear from the normal experience where possible.
We do not want truth to disappear with it.
A person should not need to understand every internal mechanism to benefit from a system. But when something consequential happens, they should be able to understand what happened, what source supported it, what was inferred, what was actually changed, and what remains uncertain.
So our fuller design stance is:
Make the complexity invisible, not the truth.
Absorb the machinery.
Preserve the provenance.
Remove accidental friction.
Keep meaningful choice.
Automate the boring transition between intention and action.
Do not automate away the human merely because the machinery finally can.
That is not a limitation on agentic systems.
For us, it is the point.