Satyam PariyarThe Expanding Circle: What a Late Night Conversation Taught Me About Building Systems That Don't Break
It started with a question someone threw into a late night conversation with friends: what would you do if...
I don't remember the exact scenario. What I remember is my answer — that a person always starts by caring about themselves first. Not as a character flaw, but as a natural starting point. Then they expand outward. Family. Community. Country. Humanity. If they keep growing, eventually all sentient life.
Someone pushed back. Isn't that just selfishness?
I said no. The egocentric person isn't broken — they're just early. The goal isn't to replace self-care with worldcentric care. It's to grow your circle until it includes more.
That conversation led me back to Ken Wilber's developmental model — egocentric, ethnocentric, worldcentric, cosmocentric — and something clicked. Not just about human development. About the knowledge system I'd been building for the past several weeks. About why it was working.
I had accidentally encoded the expanding circle into software.
What Wilber's Model Actually Says
Wilber's Integral Theory describes human development as a series of expanding circles of care:
Egocentric: I care about my own survival and needs. Not evil — foundational. A child lives here. So does anyone under enough stress.
Ethnocentric: My circle expands to include my tribe — family, religion, nation. I'll sacrifice for them. People outside the tribe still feel like "other."
Worldcentric: I care about all humans, regardless of tribe. Rights, justice, global empathy become real concerns, not abstractions.
Cosmocentric: The circle expands to all sentient life, to the universe itself.
The key insight isn't the names. It's the geometry. Each stage includes the previous one rather than replacing it. You don't stop caring for yourself when you become worldcentric. You care for yourself and humanity. The circle expands — it doesn't relocate.
And healthy development moves outward. Pathological development stays stuck, or collapses inward under pressure.
There's a more commonly cited model that uses similar language — the idea of focusing only on what you can control, letting go of everything else. It's useful advice for managing anxiety. But it's fundamentally a different claim. That model is flat and reactive: it tells you where to direct attention when you're overwhelmed. It doesn't describe growth.
Wilber's model is developmental and generative. The key word is includes. Each stage doesn't replace the previous — it transcends and includes it. You don't stop caring for yourself when you become worldcentric. The earlier care is still there, integrated, no longer the ceiling.
That inclusion property is what makes the model structurally interesting. And it's what makes it map onto systems design in a way the other version doesn't.
The Conversation I Had With Myself Building a Vault
Around the same time as that conversation, I was building an Obsidian vault — a knowledge system for my work on startups, content, and personal thinking. And I was designing how AI agents would operate inside it.
The problem I kept running into: how do you give an AI agent enough context to be useful, without giving it so much authority that it breaks things?
If the agent reads everything globally, it gets confused — it tries to apply Signal Theory's content rules to Operating Context Graph research. If it reads too narrowly, it lacks context to do anything meaningful.
The solution I landed on was scope inheritance. The vault has layers:
- A root layer with global policy that applies everywhere
- Domain scopes that inherit global policy and add local rules
- Folder-level instructions that inherit domain rules and narrow further
Each layer can only add to what the parent already handles. It cannot override root policy. It cannot reach up and change its parent. It governs only within its own boundary.
I wrote this rule explicitly into every scope:
Child scopes add deltas only, never govern the parent.
I even built a validator check for it. If a local instruction file repeats global policy verbatim — trying to re-assert rules it already inherits — the validator flags it. The system enforces its own circles.
It wasn't until the late night conversation that I realised what I'd actually built.
The Geometry Is the Same
Look at the shapes side by side — but pay attention to which direction they run.
Human development (centrifugal — you grow outward):
- Egocentric: the centre. Where you begin. Care bounded to self.
- Ethnocentric: first expansion. Tribe. Inherits self-care, adds local loyalty.
- Worldcentric: wider still. Humanity. Inherits all previous, adds universal empathy.
- Cosmocentric: the outermost ring. All life. Includes every prior stage within it.
Vault scope inheritance (centripetal — authority flows inward):
- Root layer: the outermost ring. Universal policy. Governs everything within it.
- Domain scope: inherits root, adds domain-specific rules only.
- Folder scope: inherits domain, adds narrower workflow rules only.
- Task context: the centre. Where the agent acts. Most specific, most local.
The geometry is identical: each outer ring transcends and includes everything inside it. In Wilber's model, the cosmocentric person doesn't abandon ego — they include it. In the vault, the root layer doesn't replace domain rules — it contains them. The outer ring is always the largest circle of care, the most universal authority.
But there is one difference, and it matters: the direction of travel.
Wilber's development moves outward across a lifetime. You begin at ego and grow toward cosmos. The circle expands as you do.
An agent navigates inward across a task. It enters the vault at the outermost ring — root policy, universal context — and follows the thread toward the centre, narrowing scope at each ring until it reaches the specific task. The work happens at the most local, most specific point. The outermost rings are the frame, not the destination.
This is actually what the name is pointing at. Ariadne gives Theseus the thread that lets him navigate the labyrinth — enter at the boundary, find the centre, return. The thread doesn't tell him what to do at the centre. It tells him how to get there and how to get back. That's what the scope system does. Root policy is the thread. The task is the centre.
This isn't a metaphor I stretched to fit. I genuinely built it without naming it, and only recognised it when a friend's question sent me to Ken Wilber. The principle now has its own note in the vault design concepts because it belongs there as much as it belongs in this essay.
Bounded Emergence · seed 2605
Why This Matters for AI Systems Specifically
Human beings who regress under pressure — who collapse back to egocentric when things get hard — cause interpersonal problems. Relationships break. Trust erodes. But the damage is slow and recoverable.
AI agents that lose their scope boundaries cause different problems. Faster. Harder to reverse.
An agent with no scope context will try to be helpful everywhere, applying rules from one domain to another, restructuring things it doesn't understand. An agent with too broad a mandate will optimise the wrong thing at scale before anyone notices.
The pathology in both cases is the same: the thread gets dropped. In humans, Wilber calls it regression — the circle contracts back to a smaller stage. In agentic systems, it's scope collapse — the agent stops following the thread inward and starts acting on context it was never meant to hold. An agent that doesn't know where its circle ends will either retreat to doing nothing, or expand recklessly until something breaks.
The solution in both cases is the same: clear circles. Each layer knows exactly what it is responsible for. It inherits what it should. It adds what it must. It governs nothing beyond its boundary.
This is why the companies I'm thinking about most — building AI automation into complex organisations — keep failing at the same point. Not because their models are too weak. Because their context isn't bounded. Agents don't know which circle they're operating in. Policy bleeds across boundaries. Local rules conflict with global ones. The circles were never drawn.
What Building This Taught Me
The expanding circle model is usually taught as personal growth advice. Grow your empathy. Care about more people. Become cosmocentric and enlightened.
That's fine. But the structural version of the insight is rarer and more immediately useful: healthy systems at every scale encode bounded authority.
A child scope that only governs within its circle isn't restricting itself. It's enabling the whole system to scale without becoming incoherent. The local layer can be changed, adapted, specialised — without breaking the global layer that everyone depends on.
And the global layer can evolve — without every local layer needing to be rewritten.
This is how Unix permissions work. How Kubernetes Kustomize works. How CSS specificity works. How constitutional law works. Different domains, same geometry — each layer governs within its circle, inherits from outside it, and cannot corrupt what it didn't create.
I built it into a knowledge system because that's where I was working. But the principle doesn't care where you apply it. It just wants you to draw the circles clearly, and respect where each one ends.
Postscript: On Late Night Conversations
The best thinking I've done hasn't happened in front of a screen.
It's happened in the in-between spaces — a conversation that ends at 2am, a question that doesn't have an obvious answer, someone pushing back on something I said too confidently.
The vault, the system, the validator check that fires when a scope tries to override its parent — all of it traces back to someone asking what would you do? and me trying to answer honestly.
I didn't set out to encode Wilber into file system rules. I set out to solve a practical problem. The connection came later, through a conversation, through noticing the shape of what I'd already built.
That's usually how it goes.
The system described here — the scope inheritance model, the validator, the agent routing — is open source at github.com/pariyar07/ariadne.