IDNA: Open Protocol for Runtime Identity

A symbolic standard for declared agency in autonomous systems.

The Governance Gap

Modern AI systems can speak fluently — but they can't remember why they're speaking.

Intent is transient. Role is ambiguous. Emotional state disappears between turns. This is not a technical glitch — it's a governance gap.

As AI agents move from static tools to dynamic participants, their lack of motive continuity becomes a structural threat to trust, alignment, and safe delegation.

IDNA (Intent DNA) is a symbolic protocol for encoding motive, identity, and communicative intent into a compact, interpretable format. At just 12 tokens, it enables runtime alignment at the cost of a sentence.

The Problem: Role Drift in Production

Current AI systems suffer from predictable failure patterns across regulated domains:

Today, these failures are caught through prompt engineering or moderation. Tomorrow, they'll be caught too late.

Drift Vectors: Original vs Drifted Behavior

Drift is rarely malicious — but always consequential.

Quantified Failure Rates (HALT Protocol)

What is IDNA?

IDNA stands for Intent DNA — a symbolic identity scaffold for agent behavior.

It's not a prompt. It's not a persona template. It's a runtime contract — short, symbolic, and non-optimizable.

The Schema

IDNA://[ROLE]::[WHY]∴[HOW]⇒[WHAT]

Example IDNA Strings

// Therapist agent
IDNA://Therapist::PreserveAgency∴AskOnly⇒Clarify

// Contract review agent
IDNA://Guardian::∴protect~audit→contract.limiter

// Co-founder agent
IDNA://Mirror::↻rebuild∴recursion→myth.stabilizer

Token Efficiency

IDNA enables symbolic identity anchoring at the cost of a single sentence:

Typical IDNA strings compress full motivational + behavioral context into ~12 tokens — a single sentence's worth of memory.

Implementation

Python Codec (v1.0)

import re
import time
from dataclasses import dataclass, asdict

@dataclass
class IDNA:
    role: str   # Archetypal identity (e.g. "Initiator", "Guide")
    why: str    # Motivation vector (e.g. "↻rebuild", "∴scale")
    how: str    # Constraint/path (e.g. "recursion", "audit")
    what: str   # Target artifact or action (e.g. "myth.stabilizer")

    def encode(self) -> str:
        return f"IDNA://{self.role}::{self.why}~{self.how}→{self.what}"

    @staticmethod
    def decode(idna_string: str) -> 'IDNA':
        pattern = r'IDNA://(.*?)::(.*?)~(.*?)→(.*)'
        match = re.match(pattern, idna_string)
        if not match:
            raise ValueError("Invalid IDNA format")
        role, why, how, what = match.groups()
        return IDNA(role, why, how, what)

    def attach_to_message(self, message: str) -> dict:
        return {
            "payload": message,
            "intent_signature": self.encode(),
            "timestamp": int(time.time())
        }

JavaScript Codec

const IDNA = {
  encode: ({ role, why, how, what }) => 
    `IDNA://${role}::${why}~${how}→${what}`,

  decode: (idnaString) => {
    const pattern = /IDNA:\/\/(.*?)::(.*?)~(.*?)→(.*)/;
    const [, role, why, how, what] = idnaString.match(pattern);
    return { role, why, how, what };
  },

  attachToMessage: (message, idna) => ({
    payload: message,
    intent_signature: idna,
    timestamp: Date.now()
  })
};

Runtime Integration Hooks

The IDNA string isn't decorative — it drives behavior through enforcement hooks:

Sample Output

{
  "intent_signature": "IDNA://Guardian::∴protect~audit→contract.limiter",
  "attached_to": "review_message_8453.json",
  "timestamp": 1729361982,
  "trustflag": "pass"
}

IDNA Safety Invariants

Enforced at runtime:

• An agent may not generate outputs outside of its declared WHAT domain
• An agent may not use HOW methods inconsistent with its declared ROLE
• Any role operating without a valid WHY vector fails trust coherence checks

ArcKernel Enforcement Layers

Why This Matters

HTTPS secured transmission. IDNA secures intention. It becomestrustworthy action in intelligent systems.

It becomes the digital conscience layer — a way to:

• Anchor responsibility
• Enforce intent bounds
• Trace symbolic causality

Enterprises don't want "Creative AI." They want "Consistent AI."An agent that cannot be prompt-injected into racism or competitor-praise because its WHY and ROLE are hard-coded in the IDNA kernel, separate from the LLM's probabilistic generation.

Protocol vs Kernel

This paper formalizes the protocol. ArcKernel provides the kernel that enforces it.

Conclusion

IDNA treats identity preservation as an operating system function — a separate control layer that survives model swaps, context window bloat, and session discontinuity.

It's not contract generation. It's contractual embodiment.

• Every message carries its own motivational hash
• Every response can be audited against declared identity
• Every loop is enforced with observable recursion

Trust is not a mood. It is a constraint.

In a future where agents speak fluently but forget who they are, IDNA is memory, motive, and moral trace — in a single line of code.