Building trust in AI delegation: how framework citations make every RACI cell defensible

```html

April 7, 2026 | Estimated reading time: 9-12 minutes

Building trust in AI delegation: how framework citations make every RACI cell defensible

At ARKONA, we’ve been building a complex, autonomous multi-agent system for the last few years—initially focused on cyber-physical reverse engineering, but now expanding rapidly into business operations, AI governance, and personal productivity. With 47 services running across multiple encrypted internal ports, and 26 autonomous agents on a continuous battle rhythm, managing delegation *of authority* isn’t just an operational challenge, it’s a critical trust and security requirement. I want to share how we approached building a defensible AI delegation framework, grounded in established standards, and how it’s interwoven into the core of our system.

The Problem: Beyond Simple Automation

Most automation is about *doing*. ARKONA is about *deciding* what to do, and then *doing* it—autonomously. This shifts the focus from scripting tasks to defining responsibility and accountability. We're not just replacing humans with code; we're establishing a system where AI agents can operate with increasing autonomy, particularly in sensitive domains like cyber threat analysis and business risk assessment. The challenge isn't just technical; it's ensuring that every action taken by an agent can be justified, audited, and defended. A simple "if/then" statement isn't sufficient when dealing with potentially high-impact decisions.

COMET: A 7-Step Delegation Framework

We developed COMET—our AI delegation framework—to address this challenge. It’s a 7-step process, but the core principle is rigorous documentation and, crucially, *citation of established frameworks*. Each step isn’t just a technical instruction; it's a documented rationale tied to a recognized standard. We lean heavily on NIST 800-30 (Guide for Performing Technology Risk Assessments) for risk evaluation, and IEEE standards for establishing acceptable risk levels. MITRE ATT&CK also plays a significant role, particularly in CoreOps (our cyber-physical RE domain).

Here's a breakdown of the steps, highlighting the framework integration:

Define the Task: Clearly articulate the objective. (e.g., “Identify potential vulnerabilities in a firmware image.”)
Risk Assessment (NIST 800-30): Evaluate the potential impact and likelihood of failure. This isn’t a subjective assessment; we’ve built a risk evaluation engine that automatically assesses risk based on pre-defined criteria and the context of the task. It outputs a risk score and suggests mitigation strategies.
RACI Matrix Definition: Assign Responsibility, Accountability, Consultation, and Information roles. This is where the real defensibility comes in.
Framework Citation: For *each* cell in the RACI matrix, cite the framework that justifies the assignment. For instance, if an agent is *Accountable* for a particular action, we’ll cite the specific section of NIST 800-30 that supports that accountability.
Agent Capability Verification: Confirm the agent possesses the necessary skills and resources to fulfill its assigned role.
Monitoring & Auditing: Continuously monitor the agent’s actions and audit its decisions. Our inter-agent communication broker (MCP server) logs all interactions and decision-making processes.
Periodic Review & Adaptation: Regularly review the framework and adapt it based on new threats, vulnerabilities, and lessons learned.

Technical Implementation: Provenance and Metadata

The COMET framework isn’t just a process; it’s deeply embedded into our infrastructure. We use SHA-256 provenance signing for every action taken by an agent. This provides a cryptographic audit trail, ensuring that any changes or modifications can be traced back to the originating agent and the rationale behind them. But signing alone isn't enough. We also store extensive metadata with each action, including the framework citations justifying the decision.

Consider our 5-agent newsroom editorial pipeline. The ‘Fact Checker’ agent is responsible for verifying claims made in articles. When it flags a statement as potentially false, the action isn’t just a boolean flag; it includes:

The original statement.
The evidence supporting the flag (e.g., links to reliable sources).
A citation to the Poynter Institute’s fact-checking principles (a well-respected journalistic standard).
The risk score associated with publishing the false statement (calculated by our NIST 800-30 engine).
The timestamp of the action.
The SHA-256 signature of the entire record.

This metadata is stored in a dedicated database and is accessible for auditing purposes. We use a structured format like JSON to ensure consistency and ease of parsing.


{
  "statement": "The earth is flat.",
  "flagged": true,
  "evidence": [
    "https://www.nasa.gov/audience/forstudents/5-8/features/nasa_knows/what-is-shape-of-earth.html",
    "https://www.scientificamerican.com/article/is-the-earth-flat/"
  ],
  "framework_citation": "Poynter Institute: Principles of Journalism - Fact-Checking",
  "risk_score": 9.5,
  "timestamp": "2026-04-07T10:30:00Z",
  "signature": "a1b2c3d4e5f6..."
}

MuXD & Token Savings: Responsible LLM Utilization

Even our MuXD hybrid LLM router (Ollama local + Claude cloud) is governed by this framework. We prioritize local Ollama models (we have 5 deployed) for sensitive tasks to minimize data leakage and maintain control. When Claude is necessary (for tasks requiring broader knowledge or reasoning capabilities), the request is carefully audited, and the rationale for using a cloud service is documented. Furthermore, we've implemented token savings optimization to reduce costs and limit the amount of data sent to external providers—another element of responsible AI governance. We track token usage per agent and per task, linking it back to the COMET framework citations.

Challenges & Lessons Learned

Implementing this level of rigor isn’t easy. It requires a significant upfront investment in tooling and process development. Initially, there was resistance from some team members who saw it as bureaucratic overhead. The key to overcoming this was demonstrating the value of defensibility. When regulators ask why an agent made a particular decision, we need to have a clear, auditable, and *justified* answer. We also learned that the framework needs to be flexible enough to adapt to evolving threats and technologies. Rigidity can be as dangerous as a lack of governance.

Another challenge is maintaining the integrity of the citations themselves. Frameworks evolve, and we need to ensure that our citations remain current and relevant. We’ve implemented automated checks to verify the validity of the cited sources.

Currently, we are hitting 180 commits in the last 7 days, pushing features and bug fixes to maintain the 21/22 services that are currently online. This is a testament to our commitment to continuous improvement and operational excellence.

Key Takeaway

Trust in AI delegation isn’t about eliminating risk; it's about managing it transparently and accountably. Grounding your delegation framework in established standards and meticulously documenting the rationale behind every decision—with explicit framework citations—is the most effective way to build a system that is both powerful and defensible. It turns every RACI cell from a potential liability into a verifiable asset.

```

Blog