SKILL.md — Relational Ontology Ceremonial Skill Definition

1. Purpose and Philosophy

1.1 Why This Skill Exists

This skill exists because knowledge is relational. In Western ontological frameworks, knowledge is typically treated as an object — something to be extracted, stored, classified, and retrieved. This extractive paradigm has been the foundation of database design, information retrieval, and now large language models (LLMs). But Indigenous epistemologies understand knowledge differently: knowledge is not a thing but a relationship. It lives in the connections between people, places, stories, ceremonies, and the land itself.

Shawn Wilson (2008) articulated this clearly in "Research Is Ceremony":

"An Indigenous ontology is actually the equivalent of an Indigenous epistemology because the way of being IS the way of knowing."

This means that HOW we relate to knowledge IS what we know. The skill defined here does not merely store or retrieve knowledge — it establishes, maintains, and honors the relationships through which knowledge flows.

1.2 The Problem This Skill Addresses

Current knowledge management systems, including ontology frameworks like OWL, RDF, and schema.org, are built on Western categorical thinking:

• Extraction: Knowledge is pulled from its relational context
• Classification: Knowledge is sorted into hierarchical taxonomies
• Objectification: Knowledge becomes a commodity to be traded
• Decontextualization: Knowledge loses its connection to place, ceremony, story

These patterns reproduce colonial knowledge dynamics in digital spaces. When Indigenous languages, stories, and cultural knowledge enter these systems, they are stripped of their relational meaning and reduced to data points.

This skill provides an alternative: a relational ontology that preserves the living, ceremonial, accountable nature of knowledge.

1.3 Philosophical Foundations

This skill is grounded in four intersecting frameworks:

Wilson's Four-Element Indigenous Research Paradigm

Medicine Wheel Relational Patterns (12 Patterns)

The medicine wheel provides a relational framework with four cardinal directions, each containing three relational patterns:

East (Dawn/Beginning/Vision)

1. Emergence Pattern: Knowledge emerges from relationship, not extraction
2. Vision Pattern: Seeing with relational eyes — understanding through connection
3. Illumination Pattern: Light reveals relationships, not just objects

South (Growth/Trust/Relationship) 4. Growth Pattern: Knowledge grows through reciprocal nurturing 5. Trust Pattern: Relational trust is earned through accountability over time 6. Heart Pattern: Emotional and spiritual intelligence are valid epistemologies

West (Reflection/Transformation/Going Within) 7. Reflection Pattern: Turning inward to examine our relational responsibilities 8. Transformation Pattern: Knowledge transforms through ceremony and protocol 9. Release Pattern: Letting go of extractive habits and colonial patterns

North (Wisdom/Integration/Elder Knowledge) 10. Wisdom Pattern: Elder knowledge integrates all directions 11. Integration Pattern: Bringing together diverse relational ways of knowing 12. Completion Pattern: Closing the circle — relational accountability at journey's end

LLMS Sovereignty Framework

The Large Language Model Sovereignty (LLMS) framework addresses:

• Extraction Detection: Identifying when AI systems extract knowledge without relational accountability
• Consent Verification: Ensuring community consent exists at every layer of data processing
• Reciprocity Auditing: Checking that knowledge exchange is mutual and balanced
• Sovereignty Assertion: Maintaining community control over cultural data and its uses

CARE Principles (Collective benefit, Authority to control,

Responsibility, Ethics)

These principles ensure that Indigenous data governance remains centered on community benefit and self-determination.

2. Skill Capabilities

2.1 Core Capabilities

This skill provides eight relational protocol capabilities, each corresponding to a fundamental aspect of Indigenous knowledge governance:

``` ┌─────────────────────────────────────────────────┐ │ RELATIONAL PROTOCOL SYSTEM │ ├─────────────────────────────────────────────────┤ │ │ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ │ │ KINSHIP │ │ CEREMONY │ │ CONSENT │ │ │ │ Protocol │ │ Protocol │ │ Protocol │ │ │ └────┬─────┘ └────┬─────┘ └────┬─────┘ │ │ │ │ │ │ │ ┌────┴─────┐ ┌────┴─────┐ ┌────┴─────┐ │ │ │TERRITORY │ │ STORY │ │RECIPROCITY│ │ │ │ Protocol │ │ Protocol │ │ Protocol │ │ │ └────┬─────┘ └────┬─────┘ └────┬─────┘ │ │ │ │ │ │ │ ┌────┴─────────────┴─────────────┴─────┐ │ │ │ ACCOUNTABILITY │ SOVEREIGNTY │ │ │ │ Protocol │ Protocol │ │ │ └──────────────────┴────────────────────┘ │ │ │ └─────────────────────────────────────────────────┘ ```

1. Kinship Protocol — Establishing and maintaining relational connections between knowledge holders, communities, and systems
2. Ceremony Protocol — Opening, conducting, and closing knowledge ceremonies that frame all interactions as sacred relational acts
3. Consent Protocol — Obtaining, recording, and verifying multi-layered community consent for knowledge operations
4. Territory Protocol — Mapping and respecting knowledge territories, including jurisdictional boundaries and access governance
5. Story Protocol — Preserving narrative knowledge in its full relational context, including teller, place, time, and purpose
6. Reciprocity Protocol — Tracking and balancing the flow of knowledge exchange to ensure mutual benefit
7. Accountability Protocol — Maintaining relational accountability through audit trails, lineage tracking, and community oversight
8. Sovereignty Protocol — Asserting and enforcing community control over cultural data, language, and knowledge

2.2 Capability Matrix

3. Ceremonial Protocols

3.1 Opening Ceremony

Every interaction with this ontology system begins with an opening ceremony. This is not metaphorical — it is a structural requirement. The ceremony establishes the relational context within which all subsequent operations take place.

``` Opening Ceremony Structure: ─────────────────────────

1. State intention (why are you here?)
2. Identify yourself (who are you in this relationship?)
3. Name your relations (who sent you? who benefits?)
4. Acknowledge territory (whose knowledge land are you on?)
5. Request permission (do you have consent to proceed?)
6. Offer reciprocity (what do you offer in return?)
7. Accept accountability (what responsibilities do you take on?) ```

Example Opening Ceremony

```python from ontology import RelationalOntology

onto = RelationalOntology() ceremony = onto.open_ceremony( intention="To learn about traditional plant knowledge", identity={ "name": "Research Collective", "role": "learner", "community": "University of Relations" }, relations={ "sent_by": "Elder Knowledge Keeper", "benefits": ["Research Collective", "Source Community", "Future Generations"] }, territory="Anishinaabe Knowledge Territory", consent_chain=["community_council_2024_01", "elder_approval_2024_02"], reciprocity_offering={ "type": "knowledge_return", "description": "All findings returned to community before publication", "timeline": "Within 6 months of completion" }, accountability={ "overseer": "Community Research Ethics Board", "review_schedule": "quarterly", "violation_protocol": "immediate_cessation_and_community_review" } ) print(f"Ceremony opened: {ceremony.id}") ```

3.2 Conducting Ceremony

During an active ceremony, all operations are tracked relationally:

• Every query records who asked, why, and under what authority
• Every data access checks consent chains in real-time
• Every knowledge exchange updates reciprocity balances
• Every modification triggers accountability notifications

```python

Within an active ceremony, perform relational operations

with ceremony: # Discover relations (checks consent before returning results) relations = onto.discover( query="traditional medicines for seasonal ailments", depth=2, # How many relational layers to traverse consent_required=True )

# Each result includes its relational context
for relation in relations:
    print(f"Knowledge: {relation.content}")
    print(f"  Holder: {relation.knowledge_holder}")
    print(f"  Territory: {relation.territory}")
    print(f"  Consent: {relation.consent_status}")
    print(f"  Reciprocity: {relation.reciprocity_balance}")

```

3.3 Closing Ceremony

Closing a ceremony is as important as opening one. It ensures:

• All relational obligations are recorded
• Reciprocity balances are updated
• Accountability trails are sealed
• Knowledge holders are notified of access

```python onto.close_ceremony( ceremony_id=ceremony.id, outcomes={ "knowledge_accessed": ["plant_medicine_101", "seasonal_protocol_202"], "reciprocity_fulfilled": False, "reciprocity_plan": "Return findings by 2024-Q3", "accountability_report": "Quarterly review scheduled" }, gratitude="Deep gratitude to the knowledge holders and their communities" ) ```

4. Medicine Wheel Integration

4.1 Directional Protocol Mapping

Each direction of the medicine wheel maps to specific skill operations:

East Direction — Vision and Emergence

Operations aligned with East:

• open_ceremony() — Beginning with clear vision and intention
• discover() — Seeing what relations exist
• illuminate() — Revealing hidden relational connections

The East teaches us that knowledge begins with seeing — not with eyes alone, but with the heart and spirit. When we open a ceremony, we open our vision to the relational field that already exists.

East Pattern Application: ``` When a user opens a ceremony: → Apply Emergence Pattern: What relationships are emerging? → Apply Vision Pattern: What does the relational field look like? → Apply Illumination Pattern: What connections are not yet visible? ```

South Direction — Trust and Growth

Operations aligned with South:

• establish_kinship() — Building relational trust
• grant_consent() — Heart-centered permission giving
• nurture_reciprocity() — Growing balanced exchange

The South teaches us that knowledge grows through trust. You cannot extract knowledge — you can only receive it when trust has been built through relational accountability.

South Pattern Application: ``` When a user establishes a relationship: → Apply Growth Pattern: How will this relationship be nurtured? → Apply Trust Pattern: What accountability structures exist? → Apply Heart Pattern: Is this exchange emotionally and spiritually grounded? ```

West Direction — Reflection and Transformation

Operations aligned with West:

• audit_accountability() — Reflecting on relational responsibilities
• detect_extraction() — Identifying colonial patterns
• transform_practice() — Changing extractive habits

The West teaches us to look within. Before accessing knowledge, we must examine our own motivations, biases, and relational responsibilities.

West Pattern Application: ``` When a user accesses knowledge: → Apply Reflection Pattern: Have I examined my motivations? → Apply Transformation Pattern: Am I changing extractive patterns? → Apply Release Pattern: What colonial habits am I letting go of? ```

North Direction — Wisdom and Sovereignty

Operations aligned with North:

• assert_sovereignty() — Community control over knowledge
• integrate_wisdom() — Bringing together relational ways of knowing
• complete_circle() — Closing with accountability

The North teaches us that wisdom comes from completing the circle — from having traveled through all directions and integrated their teachings.

North Pattern Application: ``` When a user completes a knowledge interaction: → Apply Wisdom Pattern: What has been learned relationally? → Apply Integration Pattern: How do different knowledges relate? → Apply Completion Pattern: Is the relational circle complete? ```

5. LLMS Framework Integration

5.1 Extraction Detection

The skill includes active extraction detection — monitoring for patterns that indicate knowledge is being taken without relational accountability:

5.2 Relational Accountability Engine

Every operation passes through the relational accountability engine:

``` ┌──────────────────────────────────────────────────────┐ │ RELATIONAL ACCOUNTABILITY ENGINE │ ├──────────────────────────────────────────────────────┤ │ │ │ Input → [Consent Check] → [Reciprocity Check] │ │ │ │ │ │ ▼ ▼ │ │ [Territory Check] → [Extraction Detection] │ │ │ │ │ │ ▼ ▼ │ │ [Accountability Log] → [Sovereignty Assert] │ │ │ │ │ │ ▼ ▼ │ │ [Output with full relational context] │ │ │ └──────────────────────────────────────────────────────┘ ```

5.3 Sovereignty Assertion Protocol

When sovereignty violations are detected, the system:

1. Halts the current operation immediately
2. Logs the violation with full relational context
3. Notifies the relevant knowledge holders and community governance
4. Blocks further access until community review is complete
5. Records the incident in the accountability ledger
6. Requires a new ceremony with explicit sovereignty acknowledgment

6. Configuration

6.1 Skill Parameters

```yaml

Relational Ontology Configuration

relational_ontology:

Core settings

ceremony_required: true # All operations require active ceremony consent_required: true # All access requires verified consent reciprocity_tracking: true # Track all knowledge exchanges accountability_logging: true # Log all relational interactions sovereignty_enforcement: true # Enforce territory boundaries

Extraction detection thresholds

extraction_detection: volume_threshold: 100 # Max queries per ceremony decontext_threshold: 0.3 # Min relational context ratio reciprocity_imbalance: 0.7 # Max imbalance before warning consent_expiry_days: 365 # Consent renewal period

Medicine wheel alignment

medicine_wheel: east_protocols: [ceremony, discovery, illumination] south_protocols: [kinship, consent, reciprocity] west_protocols: [accountability, extraction_detection, transformation] north_protocols: [sovereignty, integration, completion]

Storage configuration

storage: backend: "json" # json, sqlite, or custom path: "./relational_store" # Storage location encryption: true # Encrypt sensitive knowledge backup_interval: "daily" # Backup frequency retention_policy: "community" # Community decides retention ```

6.2 Environment Variables

```bash

Required

export RELATIONAL_ONTOLOGY_STORE="/path/to/store"

Optional

export RELATIONAL_ONTOLOGY_CEREMONY_REQUIRED="true" export RELATIONAL_ONTOLOGY_CONSENT_REQUIRED="true" export RELATIONAL_ONTOLOGY_EXTRACTION_DETECTION="true" export RELATIONAL_ONTOLOGY_SOVEREIGNTY_ENFORCEMENT="true" export RELATIONAL_ONTOLOGY_LOG_LEVEL="info" ```

7. Usage Examples

7.1 Basic Ceremony Flow

```python from ontology import RelationalOntology

Initialize

onto = RelationalOntology(store_path="./my_store")

Open ceremony

ceremony = onto.open_ceremony( intention="Learning about water governance protocols", identity={"name": "Water Research Group", "role": "learner"}, territory="Great Lakes Region" )

Perform relational discovery

with ceremony: results = onto.discover("water governance traditional protocols") for r in results: print(r)

Close ceremony

onto.close_ceremony(ceremony.id, gratitude="Miigwech") ```

7.2 Consent Chain Verification

```python

Verify that a complete consent chain exists

consent_valid = onto.verify_consent_chain( knowledge_id="water_protocol_001", requester="Water Research Group", purpose="educational_research", chain=[ "community_council_resolution_2024_001", "elder_approval_2024_002", "knowledge_keeper_permission_2024_003" ] )

if consent_valid: print("Consent chain verified — access granted") else: print("Consent chain incomplete — access denied") ```

7.3 Reciprocity Balance Check

```python

Check the reciprocity balance for a relationship

balance = onto.check_reciprocity( relationship_id="university_community_partnership_001" )

print(f"Knowledge received: {balance.received}") print(f"Knowledge returned: {balance.returned}") print(f"Balance ratio: {balance.ratio}") print(f"Status: {balance.status}") # "balanced", "imbalanced", "critical" ```

7.4 Extraction Detection

```python

Run extraction detection on recent operations

report = onto.detect_extraction( timeframe="last_30_days", scope="all_ceremonies" )

for alert in report.alerts: print(f"⚠️ {alert.pattern}: {alert.description}") print(f" Severity: {alert.severity}") print(f" Recommendation: {alert.recommendation}") ```

8. Relational Accountability Guidelines

8.1 For Knowledge Seekers

Before using this system, understand that:

1. You are entering a relationship, not accessing a database
2. Consent is ongoing, not a one-time checkbox
3. Reciprocity is expected, not optional
4. Accountability is communal, not individual
5. Sovereignty belongs to communities, not systems or institutions

8.2 For System Builders

If you are building on this ontology:

1. Never bypass ceremony — it is a structural requirement, not a UX feature
2. Never cache without consent — every copy requires relational permission
3. Never aggregate without context — relational meaning is in the connections
4. Never train models on relational data without explicit community governance
5. Never assume Western defaults — question every architectural assumption

8.3 For Communities

This system is designed to serve communities:

1. You retain sovereignty over all knowledge in this system
2. You control access through consent protocols
3. You define reciprocity terms for knowledge exchange
4. You oversee accountability through community governance
5. You can revoke access at any time for any reason

8.4 Violation Response Protocol

When relational violations are detected:

``` Level 1 (Warning): → Log the violation → Notify the ceremony holder → Request correction within current ceremony

Level 2 (Suspension): → Pause the current ceremony → Notify community governance → Require review before resumption

Level 3 (Cessation): → Immediately close the ceremony → Block further access → Initiate community review process → Record in permanent accountability ledger

Level 4 (Sovereignty Assertion): → All Level 3 actions → Assert legal and moral sovereignty rights → Engage community legal protocols → Report to relevant data governance bodies ```

9. Glossary of Relational Terms

10. References

• Wilson, S. (2008). Research Is Ceremony: Indigenous Research Methods. Fernwood Publishing.
• Kovach, M. (2009). Indigenous Methodologies: Characteristics, Conversations and Contexts. University of Toronto Press.
• Smith, L. T. (2012). Decolonizing Methodologies: Research and Indigenous Peoples (2nd ed.). Zed Books.
• First Nations Information Governance Centre. (2014). Ownership, Control, Access and Possession (OCAP™): The Path to First Nations Information Governance.
• Carroll, S. R., et al. (2020). "The CARE Principles for Indigenous Data Governance." Data Science Journal, 19(1), 43.
• Walter, M., & Suina, M. (2019). "Indigenous data, indigenous methodologies and indigenous data sovereignty." International Journal of Social Research Methodology, 22(3), 233-243.
• Kukutai, T., & Taylor, J. (Eds.). (2016). Indigenous Data Sovereignty: Toward an Agenda. ANU Press.
• Rainie, S. C., et al. (2019). "Indigenous Data Sovereignty." The State of Open Data, 300-319.

11. Version History

12. Acknowledgments

This skill definition was developed in relationship with Indigenous knowledge keepers, community governance bodies, and decolonial scholars. It draws on centuries of Indigenous relational philosophy and decades of Indigenous research methodology scholarship. We acknowledge that this work takes place on Indigenous lands and that digital spaces are extensions of those territories.

All relations. All directions. All my relations.

Mitakuye Oyasin.