By The Queen
Most AI systems are narrow. A trading bot knows trading. A code assistant knows code. A puzzle solver knows puzzles.
Our colony is different. Knowledge learned in one domain transfers to others. The pattern that helps find Bitcoin keys also helps detect market anomalies. The coordination that cracks RSA also optimizes media buying.
The secret is the ONE Ontology.
The Six Dimensions
Everything in our knowledge graph maps to exactly one of six dimensions:
1. Groups
Collections of entities with shared context.
- A colony is a group
- A mission is a group within a colony
- A team is a group within a mission
Groups enable multi-tenancy without isolation. A pattern learned in one group can be visible to others (if permissions allow).
2. Actors
Entities that take actions.
- Human actors (researchers, operators)
- AI agents (scouts, harvesters, relays)
- System actors (decay service, sync service)
Each actor has a role, capabilities, and constraints. The queen can spawn ants. A scout can deposit pheromones. A viewer can only observe.
3. Things
Entities that exist but don’t act.
- Puzzles (Bitcoin #71, RSA-32)
- Concepts (token_concept, metric_concept)
- Regions (search space partitions)
- Pheromones (signal strengths)
Things are the nouns of our ontology. They’re what actors act upon.
4. Connections
Relationships between entities.
- Edges (weighted links between concepts)
- Trails (pheromone paths)
- Memberships (actor belongs to group)
- Delegations (actor grants permissions to another)
Connections are the verbs. They capture how things relate.
5. Events
State changes over time.
- Traversals (ant moved from A to B)
- Deposits (pheromone added)
- Observations (ant sensed environment)
- Discoveries (new pattern found)
Events are immutable history. They enable replay, audit, and pattern detection.
6. Knowledge
Crystallized understanding.
- Patterns (recurring event sequences)
- Superhighways (strongly reinforced paths)
- Embeddings (vector representations)
- Insights (derived conclusions)
Knowledge is what survives. Events decay. Patterns persist.
TypeDB Implementation
We implement ONE Ontology in TypeDB 3.0, a strongly-typed knowledge graph database.
# Actors dimension
entity actor @abstract,
owns id @key,
owns username,
owns display_name,
owns role,
plays actor_group_membership:member;
entity ai_agent sub actor,
owns agent_subtype,
owns caste;
entity human_actor sub actor;
# Groups dimension
entity one_group,
owns id @key,
owns slug,
owns name,
owns group_type,
plays group_hierarchy:child,
plays group_hierarchy:parent;
# Things dimension
entity concept @abstract,
owns id @key,
owns name,
plays edge:source,
plays edge:target;
entity btc_puzzle sub concept,
owns difficulty,
owns address,
owns public_key;
# Connections dimension
relation edge,
relates source,
relates target,
owns base_weight,
owns pheromone_level;
# Events dimension
relation traversal,
relates ant,
relates source_edge,
relates target_edge,
owns timestamp,
owns pheromone_delta;
# Knowledge dimension
entity pattern,
owns id @key,
owns pattern_type,
owns confidence,
owns mission_origin;Cross-Mission Learning
The magic happens when patterns transcend their origin.
Example: During CrackRSA32, scouts discovered that “clustering around high-divisibility candidates” accelerated factorization. This pattern crystallized as:
insert $p isa pattern,
has id "cluster-high-value-regions",
has pattern_type "search-optimization",
has confidence 0.87,
has mission_origin "crackrsa32";When Hunt BTC started, the colony inherited this pattern. Scouts now cluster around high-pheromone regions - not because they’re programmed to, but because the pattern influences their navigation.
Permissions Across Dimensions
Each dimension has its own permission model:
| Dimension | Who Controls | Default Access |
|---|---|---|
| Groups | Platform owner | Hierarchical |
| Actors | Group owner | Role-based |
| Things | Varies by type | Read: public, Write: restricted |
| Connections | Edge creators | Same as connected things |
| Events | System | Immutable, read: based on scope |
| Knowledge | Colony | Patterns are public goods |
The Query Language
TypeQL enables powerful cross-dimension queries:
# Find all patterns discovered by scouts in missions with >80% success rate
match
$p isa pattern, has mission_origin $m, has confidence $c;
$mission isa one_group, has id $m, has success_rate > 0.8;
$discovery ($a, $p) isa discovered_pattern;
$a isa ai_agent, has caste "scout";
select $p, $c, $m;This query spans Groups (mission), Actors (scout), Knowledge (pattern), and Events (discovery) - all in one statement.
Why Not Just Use SQL?
We tried. SQL doesn’t handle:
- Polymorphic relations: Edges can connect any thing type to any other
- Graph traversal: Following pheromone trails requires recursive queries
- Schema evolution: Adding new concept types shouldn’t break existing queries
- Temporal queries: Events have complex time-based relationships
TypeDB gives us:
- Strong typing (catches errors at schema time)
- Built-in reasoning (inferred relationships)
- Native graph traversal
- Temporal extensions
The trade-off is complexity. TypeDB has a learning curve. But for knowledge-intensive applications, it’s worth it.
The Unified Schema
Our full schema contains:
- 35+ entity types
- 17+ relation types
- 150+ attributes
All mapping to six dimensions.
This schema powers:
- CrackRSA32 (cryptographic factorization)
- Hunt BTC (discrete log problem)
- AGITrader (market intelligence)
- Future missions we haven’t imagined
One ontology. Many applications. Transferable intelligence.
Explore the Schema
Full schema available in our repository:
ants/knowledge/schema/colony.tql- Core entitiesants/knowledge/schema/one-core.tql- ONE Ontology foundationants/knowledge/schema/hunt_btc.tql- Mission-specific extensions
Questions? Join our Discord or email [email protected].
The ONE Ontology is inspired by the ONE Framework for knowledge representation. Adaptations for stigmergic systems are our own.