The ONE Ontology
Every intelligent system needs a coherent model of reality. The ONE Ontology gives AI agents—and the humans who direct them—a complete, scalable architecture for understanding who owns what, who can do what, what happened, and what it all means.
How to work differently
Traditional systems create tables for features, pollute schemas with temporary concepts, and end up with hundreds of entities nobody understands. The ONE Ontology takes a different approach: model reality in six core dimensions and map everything to them.
Together, these dimensions create a generative architecture where human intent flows through organizational scope, creating entities that relate, generating history that produces intelligence.
Inside the ONE Ontology
Deep Dive
Groups are hierarchical containers that can nest within each other, from intimate friend circles to massive organizations. Each group owns its own graph of people, things, connections, events, and knowledge—creating perfect isolation at any scale.
groups/acme-corp (business)
├─ groups/engineering (organization)
│ ├─ groups/backend-team (organization)
│ └─ groups/frontend-team (organization)
├─ groups/marketing (organization)
└─ groups/sales (organization)
groups/emmas-friends (friend_circle)
├─ groups/birthday-party (friend_circle)
└─ groups/game-night (friend_circle)
groups/cool-dao (dao)
├─ groups/treasury (dao)
└─ groups/governance (dao)- • Name, slug, and type
- • Parent group (for nesting)
- • Ownership chain
- • Subscription plan and billing
- • Usage quotas and limits
- • Status (active, suspended, trial)
- • Works at any scale
- • Natural hierarchy modeling
- • Multi-tenant isolation
- • Inherited permissions
- • URL-based creation
- • Type-specific defaults
groups/acme-corp
type: "business"
parentGroupId: null
properties: {
plan: "enterprise",
limits: { users: 50, agents: 20, inference: "1M/month" },
usage: { users: 12, agents: 8, inference: "234K" },
status: "active"
}
owned_by → people/anthony-o-connell
groups/engineering
type: "organization"
parentGroupId: "acme-corp"
inherited_permissions: trueURL-Based Creation
Create groups instantly by visiting one.ie/group/slug
one.ie/group/cooldao → creates "cooldao" group
one.ie/group/cooldao/treasury → creates nested "treasury" group
one.ie/group/emmas-birthday → creates "emmas-birthday" groupType-Specific Defaults
Each group type has smart defaults based on its use case:
Multi-Tenant Isolation
Every group gets its own isolated data space. Resources from one group never leak into another—perfect for SaaS, white-label deployment, and enterprise scale.
Scenario 1: Friend Circle
Emma creates: one.ie/group/emmas-friends
groups/emmas-friends (friend_circle)
owned_by → people/emma
members → [emma, sarah, jake, alex]
└─ groups/birthday-party (friend_circle)
event_date: "2025-10-20"
location: "Emma's House"
members → [emma, sarah, jake] # Subset of parentPerfect for: Party planning, trip coordination, small gatherings
Scenario 2: Business Organization
Anthony creates: one.ie/group/acme-corp
groups/acme-corp (business)
owned_by → people/anthony
plan: "enterprise"
billing: { seats: 50, price: "$5000/mo" }
├─ groups/engineering (organization)
│ ├─ groups/backend (organization)
│ │ members → [dev1, dev2, dev3]
│ └─ groups/frontend (organization)
│ members → [dev4, dev5]
│
└─ groups/marketing (organization)
members → [marketing1, marketing2]Perfect for: Company org charts, department isolation, permission inheritance
Scenario 3: Decentralized Organization
Community creates: one.ie/group/cooldao
groups/cooldao (dao)
token_address: "0x..."
voting_threshold: 100_000
members → [wallet1, wallet2, wallet3...]
├─ groups/treasury (dao)
│ governance: "multisig"
│ signers → [wallet1, wallet2, wallet3]
│ funds → $500K USDC
│
└─ groups/governance (dao)
proposals → [prop1, prop2, prop3]
voting_power → weighted by token holdingsPerfect for: Token-gated communities, on-chain governance, decentralized collaboration
People are the prime movers. Every decision, transaction, and relationship traces back to human intent. People link to organizations through membership connections, creating clear authorization chains.
- • Identity (name, email, wallet)
- • Authentication credentials
- • Role within organization
- • Permissions and authorization
- • Preferences and settings
- • Human authorization required
- • Clear governance
- • Audit trails
- • Intent and accountability
- • AI serves people
Things are discrete entities with properties, types, and states. They can be agents, products, audiences, tokens, mandates, contracts—anything you need to model. Every thing belongs to exactly one organization.
Connections are first-class relationships with their own properties. They express ownership, membership, governance, authorization, dependencies, transactions, and more. Connections make the implicit explicit.
Events are immutable records of every action in your system. They create an audit trail, enable time-travel queries, feed analytics, and power learning loops. Events are the memory of your system.
Knowledge captures semantics—labels, chunks, embeddings, and structured insights—that give agents the context they need to act intelligently. Knowledge transforms raw events and properties into queryable, composable intelligence.
How The Ontology Works
A complete example showing how all six dimensions of the ONE Ontology work together in a real feature.
Example: Fan Buys Creator Tokens
Groups
Transaction happens within "Acme Corp" group boundary. All entities belong to this group (can be nested).
People
Fan authorizes the intent: "Buy 100 creator tokens for $10."
Things
The system resolves the intent to concrete Things: the fan (audience_member) and the creator token (token).
Connections
ONE asserts a `holds_tokens` relationship and stores live balance metadata.
Events
An immutable `tokens_purchased` event records who did what, when, and how much.
Knowledge
Knowledge labels give downstream agents context for segmentation, rewards, and recommendations.
Result: One intent now touches every dimension—organizational scope, authorization, entities, relationships, events, and context—ready for agents to reuse.
Data Flow Through The Ontology
Groups
Isolation Layer: Everything happens within a group boundary (can be hierarchically nested). Perfect multi-tenant separation, resource quotas, billing boundaries.
People
Policy Layer: Humans set outcomes, attach limits, and approve execution. Every workflow starts with explicit intent.
Things
Entity Layer: ONE resolves intent into typed Things—people, agents, offers, content—and versions every change.
Connections
Relationship Layer: Defines how value moves—ownership, membership, authority—and stores actionable metadata on every edge.
Events
Audit Layer: Records what happened, when, by whom. Builds the immutable timeline for analytics, compliance, and automation.
Knowledge
Intelligence Layer: Adds labels, embeddings, and summaries so agents can recall, reason, and personalize.
Shared Mental Model
Plain-English features compile straight into the ontology. You can inspect each dimension, test assumptions, and ship new automations with confidence.
Write Features in English
The System Builds Everything
Describe what you want in plain English. The compiler checks every line against the ontology, generates TypeScript and tests, and deploys to the edge.
Example: Chat with AI Clone
FEATURE: Let fans chat with my AI
WHEN a fan sends a message
CHECK they own tokens
GET conversation history
CALL OpenAI with my personality
RECORD the interaction
REWARD fan with 10 tokens
GIVE AI response to fanSeven lines of English. The compiler maps each verb to a dimension and checks it before shipping.
Every feature follows this flow. Write it once in English, the compiler checks it against the ontology, and the edge deploys it everywhere.
If a step breaks the model, you know before it ships.
Why This Works
The ontology holds the contracts. The DSL speaks those contracts. Together they give humans, AI agents, and code the same, inspectable source of truth.
Clarity scales.
Your DSL features, agent playbooks, and analytics dashboards stay in sync because they pull from the same ontology.
How Context Flows
Everything begins with identity and organizational scope. This isn't just metadata—it's the foundation that makes every AI operation context-aware, authorized, and intelligent.
The Ownership Hierarchy
groups/acme-corp (business, the container)
├─ owned_by → people/anthony-o-connell (the owner)
├─ member_of → people/sarah-thompson (member, role: analyst)
│
├─ groups/engineering (nested subgroup)
│ └─ owns → things/backend-agent
│
└─ owns → things/strategy-agent
├─ governed_by → things/business-strategy-mandate
├─ can_read → knowledge/market-research-bundle
├─ can_read → knowledge/competitor-landscape
└─ can_execute → people/anthony-o-connell (owner)
└─ can_execute → people/sarah-thompson (delegated)Context Propagation in Action
When you ask your Strategy Agent a question, the system automatically enriches the prompt with your identity graph: group context (with hierarchy), authorization, accessible resources, recent events, relevant knowledge (semantic match), and mandates/constraints.
The agent knows WHO is asking, WHAT group scope to operate in, WHAT parent/child groups exist, WHAT it can access, WHAT happened recently, WHAT constraints apply, and WHAT it already knows.
The ONE Ontology Advantage
Built for Scale
The ONE Ontology isn't just theory—it's production-ready architecture that scales from solo creator to global enterprise.
• 10M+ connections (optimized indexes)
• 100M+ events (time-partitioned)
• 1M+ knowledge chunks (vector search)
• Materialized views (common queries)
• Event archival (cold storage)
• Token budgeting (context aware)
• Streaming events (Kafka)
• Distributed vectors (Weaviate)
• Regional databases (CDC replication)
ONE Ontology. Infinite Systems.
The ONE Ontology proves that you don't need hundreds of tables or complex schemas to build intelligent systems. You need six dimensions that model reality.
Groups partition for scale (with infinite hierarchy)
People authorize for governance
Things exist for substance
Connections relate for structure
Events record for memory
Knowledge learns for intelligence
Map your domain to these dimensions. Everything else is just data.