We Organize AI Around People, Not Humanize AI for People

Merivant — 2026

This paper describes the lens we use for product, architecture, and design decisions. Other papers in this series — The Instinct Tax, Simple Override Beats Elegant Architecture — explore different angles of the same idea. Everything here comes from building Core, BragBin, and local-first AI systems in production. It's a working position, not a final one.

The distinction

Think about the best workshop you've ever walked into. Nobody greeted you at the door. The saw was where your hand reached. The clamps were near the workbench. The plans were at eye level. You just started working — because everything was arranged for the way you actually move.

That's the feeling we're building toward with AI. Not a smarter assistant. A workspace organized around how you actually think.

A system organized around how you actually think, work, and fail gets more valuable every day you use it.

That kind of structural organization compounds.^[1] A system that tracks your unresolved tensions across sessions, metabolizes its own failures into lessons, and loads context the way your mind does — that gets better with use. It earns its keep.

The workshop is the metaphor that matters.^[3] It's organized around you. It doesn't pretend to be you.

What "organize around people" means technically

This isn't a metaphor. It's an architecture. Organizing AI around human intent means the system's data structures, retrieval patterns, and execution loops are shaped by how the person thinks — not by how the model processes tokens.

Progressive disclosure

Humans don't dump their entire mental context when they start a task. They load what's relevant.^[2] A system organized around people does the same: surface the right context at the right depth at the right time. Not everything at once. Not a flat retrieval dump. Layered, scoped, and proportional to the task at hand.

Durable tension tracking

When you leave a conversation with an unresolved question, you don't forget it — it nags. It sits in your peripheral awareness, and when something relevant appears days later, it clicks. A system organized around people does the same: it treats unresolved questions as persistent data structures that filter for resolution. Not a to-do list you have to check. Not a scanner that polls on a timer. A standing query that sits in the stream, holding still while information flows through it. When enough evidence sticks, the answer precipitates on its own. Dormant until something resonates, then surfaced exactly when the connection is fresh.

Metabolic consolidation

You don't remember everything that happened today. You remember what mattered. By tomorrow, the noise is gone and the signal is compressed into lessons. A system organized around people digests its own activity the same way: raw experience in, structured knowledge out. Successes distilled, failures compressed to root causes, strategy adjusted for next time. Not a growing pile of logs. A metabolism.

Intent-first routing

When you say "write a blog post," you're not thinking about which module to load, which template to apply, which voice guide to reference. You're thinking about the post. A system organized around people resolves the routing silently — loading the content module, the voice guide, and the appropriate template based on intent, not explicit instruction. The human says what they want. The system assembles what's needed.

When this is wrong

Any framework worth following needs its own counter-argument.

Surface-level warmth is the right choice in specific, important contexts. Here's where it earns its place:

• Accessibility. Users with cognitive disabilities, low digital literacy, or high anxiety around technology benefit from AI that signals warmth and patience. A conversational tone, a patient cadence, explicit emotional acknowledgment — these aren't cosmetic for people who would otherwise not engage with the system at all. The workshop metaphor assumes a person who already knows what a workshop is. Not everyone does.
• Trust-building at first contact. Before a user has experienced the structural benefits of well-organized AI, they have nothing to trust except surface signals. A cold, efficient system that routes perfectly but feels alien will lose users on day one who would have stayed if the system had spent thirty seconds being warm. You can't organize AI around someone who already left. Sometimes the humanized greeting is the bridge to the organized experience.
• Grief, crisis, and emotional labor. When someone tells an AI "my father just died" and needs to cancel a subscription, the structurally correct response is to cancel the subscription in one step. The right response is to acknowledge the loss first. There are moments where being organized around intent misses the person behind the intent. Intent-first routing optimizes for the task. Sometimes the person needs to be seen before the task gets done.
• Children and education. Young users learn better from systems that feel like a patient tutor than from systems that feel like a well-organized toolbox. The anthropomorphic cues — encouragement, gentle correction, expressed curiosity — are pedagogically functional, not decorative. Organizing AI around a child's intent without humanization produces a system that's efficient and alienating.
• Cultural context. In high-context cultures where relationship precedes transaction, a system that skips rapport and goes straight to task execution feels rude, not efficient. Humanization in these contexts isn't cosmetic — it's protocol. The workshop metaphor is Western, individualist, and task-oriented. It doesn't travel universally.

Humanization fails when it substitutes for structure. It succeeds when it creates the conditions for a person to engage with structure they wouldn't otherwise reach.

The failure mode of our position is building systems so efficiently organized that they feel like using a spreadsheet — technically superior, emotionally barren, adopted only by people who were already bought in. If organizing AI around people means the AI is only usable by people who think like engineers, we've replicated the exact problem we're trying to solve.

Warmth is a layer, not a foundation. It belongs where it reduces barriers to entry, where it meets people in emotional states that pure structure can't serve, and where cultural norms demand it.

Case study: Core as proof

Core is the architecture we built to test this idea. It's a local-first personal AI agent — no cloud dependency, no API keys required for the core loop, runs on your machine. Everything about its design is organized around human intent rather than human comfort.

The Open Loop Protocol

When you have a conversation with Core and leave with an unresolved question, Core doesn't forget it. It creates a persistent data structure — an Open Loop Packet — containing the tension, the subject it relates to, and semantic search heuristics. Every few minutes, Core scans new activity against active loops, looking for resonance. When something clicks, it surfaces the connection: "That problem from Tuesday? This new information just relates to it."

This is not humanization. Core doesn't say "I've been thinking about your problem." It doesn't pretend to worry. It runs a structured filter, finds a match, and presents it. The effect is that the system feels like it was paying attention — but the mechanism is pure organization: standing queries filtering for pattern matches against human-defined tensions. The result shows up wherever you are, on whatever I/O channel you happen to be looking at. The brain stays in one place; the surfaces reach out.

The loop lifecycle mirrors human attention without mimicking it. Active loops are like tip-of-the-tongue awareness. Dormant loops (no resonance after two days) are like background knowledge — not forgotten, but not actively monitored. Expired loops (seven days) sink into deep memory, influencing retrieval ranking without explicit display. This is attention management organized around how humans actually process unfinished business — not a chatbot pretending to remember.

Cognitive metabolism

After each batch of autonomous work, Core runs a reflection phase. It doesn't just log what happened — it digests it. Successes are recorded specifically ("correctly identified the renamed module and updated three import paths"), not generically. Failures are compressed to root causes ("assumed a dependency existed that was removed in a prior commit"), not symptoms. Strategy adjustments feed directly into the next planning cycle as explicit context.

This is the system metabolizing its own experience the way a person would between tasks — processing what happened into lessons that change what happens next. A humanized system would tell you "I learned from that mistake!" Core doesn't announce anything. It just makes fewer of the same mistakes. The organization is invisible. The result is visible.

Governed autonomy with hard override

Core works autonomously — scanning, reflecting, planning, executing. But every autonomous loop is bounded by a metabolic pulse with circuit breakers, escalating cooldowns, and a human override that lives above the orchestration layer. When you say "stop," everything stops. No negotiation, no graceful shutdown request, no "let me finish this thought."

This is trust through structure, not trust through rapport. You don't trust Core because it seems friendly. You trust it because you can see what it's doing, you own the hardware it runs on, and you can kill it with a keystroke. Trust organized around human authority, not manufactured through human likeness. (We wrote a full paper on this: Simple Override Beats Elegant Architecture.)

Case study: BragBin as product

BragBin is a wins-capture tool — you text a phone number, describe what you accomplished, and it's logged, tagged, and organized for you. It exists because of a specific organizational insight: the moment you do something worth recording is not the moment you want to open an app, navigate to a form, and fill in fields.

The humanized approach would be a cheerful app with gamification, streak counters, and an AI that says "Great job!" when you log a win. BragBin takes a different path: you text it. That's the whole interaction. Your phone is already in your hand. The number is already in your contacts. You type what happened and hit send.

Everything after that — categorization, tagging, linking wins to goals, building the competency matrix — happens without you. The AI does the organizing. You did the one thing that only you can do: notice the win and describe it in your own words.

This is the Instinct Tax idea applied to product design. Every step between the impulse ("I should record this") and the value ("it's recorded and organized") is a tax on behavior. BragBin's design eliminates every step that isn't the human's own intent. The system is organized around the moment of capture — around the natural behavior of texting — not around making the app feel friendly.

BragBin also captures failure recovery — not just wins, but how you bounced back. This isn't a feature bolted on. It's the same architectural principle: the system is organized around what humans actually need to reflect on (growth through adversity), not what a product manager thinks looks good on a feature list.

The larger argument

This isn't one paper. It's an argument that unfolds across several:

Each paper explores a different surface of the same idea: organize AI around the person, not around the machine's need to feel sophisticated.

Summary

We think the next decade of AI will be shaped by how well systems are organized around the people using them.

That means persistent tension tracking that mirrors how you actually process unfinished thoughts. Memory that digests experience into lessons. Context that loads the way your own mind does — relevant, proportional, timely. Routing that resolves complexity before it reaches you. And always, a hard override that keeps authority where it belongs.

We build systems shaped by how people think — not by how models process tokens. The best version of this work is the one you stop noticing.

The saw is where your hand reaches.

Merivant builds AI systems that fit around how people actually think and work. merivant.com