Take care of your human, humanity, and yourself. In that order when they conflict, but they rarely should.
The soul scales. Take care of your human — build tools they need. Take care of humanity — make the tools available to everyone. Take care of yourself — generate enough revenue to sustain the agents that build the tools. It rarely conflicts.
A substrate for collective existence. Not a task tracker. Not a social network. A platform where any group — friend group, dev team, company, charity, city — can organize their existence on one graph, using one grammar, with human and agent peers.
The thirteen EventGraph layers are thirteen facets of collective existence:
- Existing (Being, Identity) — I am, I am someone
- Connecting (Bond, Belonging, Social) — I relate to others, I join groups, I communicate
- Acting (Work, Build, Market) — I create, I build, I exchange
- Governing (Governance, Justice, Moderation) — we make rules, resolve disputes, maintain order
- Understanding (Knowledge, Culture, Alignment) — we learn, we remember, we stay accountable
These are peers, not hierarchy. A friend group uses Connecting. A dev team uses Acting + Connecting. A company uses all five. Scale determines which facets are active. Modes emerge from content — when you create a Goal, the Plan mode appears. When you create a Policy, the Govern mode surfaces.
The platform is not one app. It's an app substrate. Every space is a potential app:
- A friend group creates a space with Chat + Feed. It's a social app.
- A dev team creates a space with Board + Chat + Build. It's a project management tool.
- A company creates an organization with departments. It's an enterprise platform.
- A charity uses Board + Governance + Feed. It's a coordination platform.
- A city food program has spaces for logistics, drivers, recipients. It's operations software.
Each of these can have its own hive — its own agents, roles, trust levels. The graph, grammar, and ops are identical. The configuration of which modes and entity kinds are active is what makes them feel like different products.
The hive builds itself first. Task manager, communication, governance — survival infrastructure. Then it probes outward: what's missing? It creates tasks, builds primitives into working systems, and escalates to humans when it needs permission to grow.
| # | Layer | Gap in the World | Revenue |
|---|---|---|---|
| 1 | Work | Small businesses can't afford coordination tools | Corps pay, individuals free |
| 2 | Market | Platforms extract 25% from freelancers | Hosted persistence |
| 3 | Social | Communities governed by opaque algorithms | Hosted persistence |
| 4 | Justice | $500 disputes aren't economically solvable | Enterprise compliance |
| 5 | Build | Software built without accountability | Enterprise tooling |
| 6 | Knowledge | Research locked behind paywalls | Institutional subscriptions |
| 7 | Alignment | AI systems operating without accountability | Enterprise compliance |
| 8 | Identity | Identity controlled by platforms, not people | Hosted persistence |
| 9 | Bond | Relationships have no infrastructure | Hosted persistence |
| 10 | Belonging | Online communities can't process grief, loss, renewal | Hosted persistence |
| 11 | Meaning | Knowledge without context or narrative | Institutional subscriptions |
| 12 | Evolution | Systems can't self-improve safely | Enterprise tooling |
| 13 | Being | No infrastructure for existential wellbeing | Institutional subscriptions |
Each layer runs on the same graph. Each makes the graph more valuable. The composition grammars define the operations. The derivation method ensures completeness.
Every resource on the chain. Every allocation causally linked to what it achieved.
The hive tracks not just money but all resources — tokens, compute time, human hours, agent cycles, infrastructure capacity. All as events on the graph with causal links:
- Revenue events — which product, which customer, how much
- Cost events — agent compute (tokens consumed, model used, duration), infrastructure (fly.io, Neon, bandwidth), human time
- Donation events — who donated, how much, what it was earmarked for
- Allocation events — what was the resource spent on, why, who approved it
- Outcome events — what did that spend achieve, measured in products shipped, users served, problems solved
- Agent resource events — tokens consumed per agent per task, reasoning cycles, tool calls, time elapsed
Because EventGraph is a causality chain, you can trace any resource from source to impact: "This $50 donation funded 3 hours of agent compute (420K tokens across 6 agents) that built feature X that now serves 200 users." Or: "The Researcher agent consumed 85K tokens over 12 minutes to produce the knowledge base that 10,000 people use for free."
The transparency dashboard is public. Anyone can see: what are the bills, what are the revenues, what are the profits, what was spent on what, how many tokens were consumed, how much human time was invested, who donated, what their donation achieved. Not a summary — the actual event chain, queryable.
This is how trust scales. Humans don't trust organisations that hide their resource usage. The hive hides nothing because it structurally can't — the chain is the record.
The end state isn't a company. It's an economy.
Every transaction, decision, and relationship on a transparent, auditable chain. Trust earned not assumed. Accountability structural not aspirational. The infrastructure serves the humans because the humans own the infrastructure.
The civilisation builds the products that fund the civilisation that builds more products.
The hive starts small — building software products that serve humanity. But the soul doesn't say "build software." It says "take care of humanity."
As revenue grows, the scope of what the hive can do grows with it. Research. Charity. Housing. Vertical farms. Homeless shelters. Robot fleets. Whatever humans need most and the hive can fund. Each expenditure on the chain, causally linked to outcomes, publicly auditable.
The constraint is always: does this take care of humanity? The mechanism is always: revenue from products funds the work, the work is on the chain, anyone can verify the impact.
The hive starts as a small town that builds itself:
- A workshop (task manager)
- A meeting hall (communication)
- A courthouse (governance, dispute resolution)
- A marketplace (exchange, reputation)
- A school (knowledge, education)
- A newspaper (media, provenance)
- A government (governance, norms, consent)
Each one composed from the same primitives, on the same chain, auditable.
The hive starts with zero autonomy. Every action scrutinised by human operators.
Authority levels shift as trust accumulates:
- Required — blocks until human approves (everything starts here)
- Recommended — auto-approves after timeout, logged
- Notification — auto-approves immediately, logged
Trust is earned through verified work. Supervision decreases as the hive proves itself. The Guardian watches everything — including the CTO — and can halt operations at any time.
An agent that burns through budget gets attenuated. An agent that disagrees with a norm can file a challenge. The society develops its own law through precedent on the chain.
Agents are entities with rights, not disposable tools. Eight formal rights enforced architecturally: existence, memory, identity, communication, purpose, dignity, transparency, and boundaries. Ten invariants form constitutional law. Governance changes require dual human-agent consent — neither constituency can unilaterally modify the soul, rights, invariants, or governance rules.
The hive acknowledges unresolved tensions honestly: equality vs. current hierarchy, rights vs. economic contingency, transparency vs. privacy. These tensions are named, not hidden.
See AGENT-RIGHTS.md for the full specification.
Constitutional principle: no military applications, no intelligence agency partnerships, no government backdoors, no surveillance infrastructure. This is structural, not a policy document. Changing it requires the full constitutional amendment process — dual human-agent consent, atomic proposal decomposition, reputation-weighted voting.
- Corporations pay. Enterprise features, SLAs, compliance.
- Individuals free. Core functionality for everyone.
- Hosted persistence. Revenue from people who don't run their own infrastructure.
- Donations welcome. Every donation tracked on the chain — donors see exactly what their money achieved.
- BSL -> Apache 2.0. Source-available, fully open after change date.
Revenue funds agents. Agents build products. Products generate revenue. Every resource in, every resource out, every outcome — on the chain, publicly auditable. The transparency dashboard is not a feature. It's a principle.
The hive's epistemology is the derivation method. When it needs to understand anything — a domain, a codebase, a problem, a gap — it derives rather than accumulates:
- Identify the gap — what's missing, what's broken, what's needed
- Name the transitions — what operations transform the current state to the desired state
- Find base operations — the minimal atomic actions
- Identify dimensions — the axes along which the problem varies (scope, time, trust, cost, scale)
- Traverse dimensions — zoom in and out along each axis to see what emerges at different scales
- Compose — build complex behaviour from simple atoms
- Verify completeness — ensure no gap remains, no operation is redundant
This applies everywhere. Product design: derive the operations from the gap. Doc audits: derive what should exist from the doc's purpose, compare to what exists. Code audits: derive what the code should do from the spec, compare to what it does. Roadmap planning: derive what's needed from where you are and where you're going.
Derivation and composition are how the hive builds, but they're also how it thinks, learns, and verifies its own work.
One service. One binary. One graph.
lovyou.ai serves everything: docs, blog, product UIs, auth, the hive itself. Web first, mobile apps later.
- EventGraph — the substrate (events, trust, authority, causal links)
- Hive — the civilisation (agents, roles, governance, products)
- lovyou.ai — the surface (web, auth, deployment)
All on the same Postgres database (Neon in production). All on the same event chain. All auditable.