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.
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.
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)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: true
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" groupEach group type has smart defaults based on its use case:
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.
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
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
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.
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.
A complete example showing how all six dimensions of the ONE Ontology work together in a real feature.
Website is built within "SaaS Startup" group boundary. All pages and components belong to this group (can be nested).
Product owner authorizes the intent: "Build landing page with pricing table."
The system resolves the intent to concrete Things: the website (astro_site), landing page (astro_page), and pricing table component (react_component).
ONE asserts a `contains` relationship between page and components with layout metadata.
An immutable `page_created` event records who built what, when, and how.
Knowledge labels give downstream agents context for optimization, SEO, and improvements.
Result: One intent now touches every dimension—group scope, authorization, page/component entities, layout relationships, creation events, and framework context—ready for deployment to the edge.
Isolation Layer: Everything happens within a group boundary (can be hierarchically nested). Perfect multi-tenant separation, resource quotas, billing boundaries.
Policy Layer: Humans set outcomes, attach limits, and approve execution. Every workflow starts with explicit intent.
Entity Layer: ONE resolves intent into typed Things—people, agents, offers, content—and versions every change.
Relationship Layer: Defines how value moves—ownership, membership, authority—and stores actionable metadata on every edge.
Audit Layer: Records what happened, when, by whom. Builds the immutable timeline for analytics, compliance, and automation.
Intelligence Layer: Adds labels, embeddings, and summaries so agents can recall, reason, and personalize.
Plain-English features compile straight into the ontology. You can inspect each dimension, test assumptions, and ship new automations with confidence.
Describe what you want in plain English. The compiler checks every line against the ontology, generates TypeScript and tests, and deploys to the edge.
WEBSITE: Add blog to site
CREATE content collection "blog"
WITH schema: title, date, author, tags
WITH markdown support
CREATE page /blog
LIST all posts in grid view
ADD search and filter by tags
CREATE page /blog/[slug]
SHOW full post with TOC
ADD share buttonsNine lines of English. The compiler generates Astro pages, content collections, and React components.
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.
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.
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.
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)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 isn't just theory—it's production-ready architecture that scales from solo creator to global enterprise.
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.