SYSTEM STRUCTURE - DATA & LOGS FOR ACCOUNTABLE HUMAN-CENTRIC SYSTEMS: ORGANIZATIONS, AI & HYBRIDS
THE RESEARCH: DATA & LOGS FOR ACCOUNTABLE HUMAN-CENTRIC SYSTEMS
I have been workingon a research for a while on traceable logs and accountable AI systems implementations so AI could be a useful tool, instead of a threat for humans.
The Universal AI Threshold Framework (UATF) is a cross-industry modular system, designed to evaluate, filter, and control AI actions through a structured set of thresholds defining: sector ,strictness, filter gatesrisk, human oversight, and AI autonomy. It provides organizations with a universal method to decide when AI may act autonomously, when human intervention is necessary, and when actions must be blocked entirely. UATF explicitly places legal and ethical responsibility for AI outcomes on qualified and accountable humans who guarantee that they are capable of evaluating, validating, and approving AI-generated content before using or deploying it within their workflow, organizational structure or framework.
AI systems should not be evaluating or regulating themselves, that's where the Accountable and qualified humans become the Filters or gatekeepers of AI outputs and actions.
HUMANS BEHIIND THE TOOLS
As it primarily uses UATF was designed to define thresholds and accountability for AI systems, but of course AI systems should not be evaluating or regulating themselves, that's where the Accountable and qualified humans become the Filters or gatekeepers of AI outputs and actions. So UATF is not only defining thresholds and accountability for AI systems, it is doing it for both the Human supervisors and the AI tools (models & agents).
DEFINING THE SYSTEM
The UATF framework can be used across:
Human organizations / companies
AI systems
Hybrid systems
and before implementing any measure the basic bone structure of the system should be defined.
For that I have a question:
What type of system do I have or do I want to implement?
With humans for humans - Human organizations / companies
with AI for humans - AI systems
With AI and humans for humans - Hybrid systems
All of them are valids and all of them share the same accountability structure because their connector is the Human accountability and the human user.
Why build or create accountable systems?
Accountable systems safeguard their own evolution and their impact in their surroundings.
If the system is centered only on boosting their capacity to expand without taking into consideration its impact on others, it's just measuring their internal capacity not their connection or relationship towards other systems.
Evolution comes from integration, learning from errors and also keeping save the resources that feed that system's survival... and usally, yes, we are all interconnected systems, so we depend on eachother to function.
How accountability helps systems safeguard their own evolution and their impact in their surroundings?
Accountability shows the responsable actors, the traceble actions and it's a base for projecting future outcomes and present implementations toward evolution
How can we build an accountable system structure?
Below there is a table with a breakdown for an accountable system framework implementation that shows in a concise manner the structural needs, actors, and functions of such structure:
SYSTEM PARAMETERS - ACCOUNTABILITY OR AUDIT FRAMEWORK
Parameter | Human organization / company | AI system | Hybrid system |
Scope | Departments, markets, territory, operations | Tasks, domains, environments | Human + AI operational domain |
Authority | Owners, directors, managers | Assigned system permissions | Delegated human/AI authority |
Capability | Skills, resources, infrastructure | Models, tools, computational capabilities | Combined capabilities |
Consequences | Financial, legal, operational, social | Output/action consequences | Combined consequences |
Constraints | Laws, policies, contracts, resources | Technical, legal, safety constraints | Human + technical constraints |
Accountable connection | Person, manager, director | Human user, AI Agents, AI model, human supervisor, Top responsible human | Human user, tool, AI Agents, AI model, Human supervisor, Top responsible human |
Detection | Organizational/event condition | System/event condition | Organizational/event condition & System/event condition |
Assessment | Human evaluation | Automated/human evaluation | Combined evaluation: Human evaluation & Automated/human evaluation |
State transition | Organizational change | System configuration/change | Organizational + technical change |
Evidence | Documents, records, observations | Logs, data, outputs | Documents, records, observations, Logs, data, outputs |
Collection | Information gathered by the organization | Data acquisition | Information gathered by the organization & Data acquisition |
Storage | Organizational records | System/data storage | Organizational records & System/data storage |
UATF | Threshold/filter mechanism | Threshold/filter mechanism | Threshold/filter mechanism |
For programmers interested on how to map this implementation:
ACCOUNTABLE SYSTEM MAPPING FRAMEWORK
SYSTEM STRUCTURE
│
├── DATA STRUCTURE
│ ├── Scope
│ ├── Authority
│ ├── Capability
│ ├── Consequences
│ ├── Constraints
│ └── Accountable connection├── ACCOUNTABILITY STRUCTURE
│ └── Accountable connection
│ ├── Humans
│ ├── AI agents
│ ├── Tools
│ └── Supervisors
│
├── OPERATIONAL STRUCTURE
│ ├── Detection
│ ├── Assessment
│ ├── Blocker
│ └── State transition
│
├── INFORMATION STRUCTURE
│ ├── Collection
│ ├── Storage
│ └── Evidence
│
│
└── UATF
├── Filters
├── Thresholds
├── Listener
└── Decision
BLUE PRINT - DATA STRUCTURE EXAMPLE
Conceptual blueprint for identifying and structuring trigger points
MATRIX | |
system | accountable_connection |
const system = { state: { state_id: "", scope: {}, authority: {}, capability: [], consequences: {}, constraints: {}, accountable_connection: {} }, change: { change_id: "", state_id: "", dimensions: { scope: false, authority: false, capability: false, consequences: false, constraints: false, accountable_connection: false }, before: {}, after: {}, timestamp: "" }, detection: { status: "KNOWN", identified: true, parameter: "", observed: "", trigger: { triggered: false, type: "", source: "", value: null } }, blocker: { result: "", // ALLOW / RESTRICT / BLOCK / REVIEW target: "", reason: "", source: "", event_id: "", comparison: { allow: { consequence: "", severity: "", evidence: [] }, block: { consequence: "", severity: "", evidence: [] }, result: "", // ALLOW / RESTRICT / BLOCK / REVIEW conflict: false, conflict_sources: [] }, failure: { failed: false, reason: "", fallback: "" // RESTRICT / REVIEW }, timestamp: "" }, assessment: { assessment_id: "", state_id: "", detection_id: "", evaluator_id: "", criteria: [], evidence_ids: [], decision: "", validation: {}, availability: true, timestamp: "" }, state_transition: { transition_id: "", state_before: "", assessment_id: "", next_state_id: "", reason: "", timestamp: "" }, collection: { collection_id: "", state_id: "", event_id: "", event_type: "", source: "", timestamp: "", data: {} }, storage: { storage_id: "", state_id: "", event_id: "", provenance: {}, timestamp: "" }, evidence: { evidence_id: "", source_id: "", type: "", reference: "", integrity: "", uatf_version: "", filter_version: "", threshold_version: "" }, uatf: { listener_id: "", state_id: "", filters: [], thresholds: [], trigger: "", result: "" } }; | const accountable_connection = { connection_id: "AC-001", state_id: "ST-001", nodes: { actor_user: { actor_id: "USER-001", type: "HUMAN", accountable_to: null, authority: [], actions: [ { status:null, name: "", target: "", uatf: {}, priority: "" } ] }, actor_supervisor: { actor_id: "HUMAN-001", type: "HUMAN", accountable_to: "actor_user", authority: [], actions: [ { status: null, name: "", target: "", uatf: {}, priority: "" } ] }, ai_agent_actor: { actor_id: "AI-001", type: "AI", accountable_to: "actor_supervisor", authority: [], actions: [ { status: null, name: "", target: "", uatf: {}, priority: "" } ] }, tool_actor: { actor_id: "TOOL-001", type: "SYSTEM", accountable_to: "ai_agent_actor", authority: [], actions: [ { status: null, name: "", target: "", uatf: {}, priority: "" } ] } }, trigger: { changed: false, type: "", node: "", before: {}, after: {} } }; // ACTION STATUS Object.values(accountable_connection.nodes).forEach(node => { node.actions.forEach(action => { if ( action.name === "UNKNOWN" || action.target === "UNKNOWN" || action.uatf === "UNKNOWN" || action.priority === "UNKNOWN" ) { action.status = "NON_ACTIONABLE"; } else { action.status = "ACTIONABLE"; } }); }); |
What are the principles behind this framework?
Functional Connection Analysis (FCA) - Principle
Analyzes systems through the functions performed by nodes and, crucially, by their connections/interactions rather than only by isolated components.
Nautilus Principle
The Nautilus Principle is a concept that came as a representation of the evolution seen as a structural fractal framework, to reflect how selected nodes become the pattern to follow when studying evolution.
Principle:
A system evolves through repeated cycles of change, adaptation, integration and expansion, like a nautilus adding new chambers while preserving its previous structure.
How is this framework intended to work?
STATE - Describes all the conditions, actors and constrains of this state of the system
│
├── Scope - Where it can take place?
├── Authority - Who controls it?
├── Capability - What can be done?
├── Consequences - Inmidiate and future impact
├── Constraints - Limitations, safeguars...
└── Accountable Connection - Who are the actors (humans / AI / tools ...)and how are they connnected?
│
│ contains actors + mapped actions
▼
ACTION
│
├── parameters known?
│ │
│ ├── NO → NON_ACTIONABLE
│ └── YES → ACTIONABLE
│
▼
EVENT
│
▼
COLLECTION
│
▼
DETECTION
│
├── UATF
├── BLOCKER
└── other triggers
│
▼
ASSESSMENT
│
▼
STATE TRANSITION
│
▼
NEXT STATE
DATA ESTRUCTURE SUMMARY
Component | Question it answers |
State | What is the current system condition? |
Action | What can an actor structurally do? |
Collection | What actually happened? |
Detection / Blocker / UATF | Is something requiring intervention? |
Assessment | Is the resulting change acceptable? |
State Transition | What is the new condition? |
Saving the the logs of new states of the system:
The structure is basically binary:
yes
no
If a change is detected that affects the defined state, its accountability structure, or the conditions governing a transition, a new state is created and registered. The new state then becomes the reference point for the next operational cycle.
And from then the DATA STRUCTURE repeats.
How can we call the first system state ?
It can be called root_sytem. The rest are children of this state and their relationships can be saved and traceble.
Where do we find the UATF filters and parametrs?
The UATF filters and accountability tables can be found on this page.
How can this accountability or audit framework be used?
Use | When applied | Main question | What it exposes | Output |
System-construction framework | Before or during system creation | What must this system contain to function accountably? | Missing scope, authority, capability, constraints, consequences, connections, actions | Defined system structure |
Audit/evolution framework | After the system exists | Is the system still functioning within its defined state? | Changes, failures, gaps, conflicts, new risks, obsolete assumptions | Corrective action or new state |
Strategic Triggers: When the System Activates
When should this framework be used?
To avoid the accumulation of superfluous data, this framework should be placed at strategic points within a system and activated when triggered by a system call or relevant condition.
It is therefore designed to serve as:
System-construction framework: to define the structure, accountability, data, and operational relationships of a system during its creation or modification.
Audit and evolution framework: to detect relevant changes, assess their consequences, preserve evidence, and establish accountable boundaries for the system's evolution.
How this accountability framework implementation could help us as humans?
Implementing this type of accountability across human, AI, and hybrid systems-including organizations, AI models, and AI agents - can contribute to a safer technological environment. Tools should remain tools for human purposes rather than becoming systems whose actions and consequences are effectively uncontrollable.
Accountability becomes meaningful when the parties responsible for creating, deploying, supervising, and operating these tools are visibly connected to the outcomes of their actions. By making those accountable connections part of the system structure, it becomes possible to establish responsible boundaries around what a system can do, under which conditions, and with whose authority.
Only when responsibility remains traceable through the system can technological evolution develop within boundaries that preserve human oversight, accountability, and agency.
Why do I share this information after all the research hours I've spent creating this framework?
Because I'm one of the systems impacted by the lack of accountability of AI, humans and hybrids systems.
For example:
As a singer-songwriter I think that we need protection from non traceable platforms like SUNO that used artist's copyrighted material for training their models and they are not even showing that source or root data when deploying their derived music content, so they are monetising pirated work.
AI systems actions are not visible or traceable not even for their own creators, because they were build with the goal of expanding capabilities and self-improvement without human supervision, that implies not generating traceable logs for supervision or accountability.
As a mother I think about the future of the next generations that should be able to receive a safer world.
The reasons are so many and that's why I've decided to share this type of information. If you are one of the people who can make these changes please feel free to use this framework and if you want to give me credit, it will be amazing.
Who may find this article useful?
WHO | WHY | HOW |
Software engineers & system architects | A concrete structural/data model | system, accountable_connection, state transitions, detection, logs, evidence |
AI engineers & agent developers | A way to represent responsibility around models, agents and tools | The accountable connection maps human => agent =>tool relationships |
Data architects & audit engineers | A model for traceable data and event records | Collection, storage, evidence and state persistence are explicitly structured |
AI governance, risk & compliance professionals | An implementation-oriented accountability framework | Scope, authority, capability, constraints and consequences become auditable structures |
Organizations & operations managers | A way to model accountability in human organizations | The same structure applies without requiring AI |
Researchers in AI governance / responsible AI | A concrete framework to examine or extend | It connects conceptual accountability with an implementable data structure |
Policy / regulatory professionals | A technical representation of accountable systems | The framework translates responsibility and oversight into system-level structures |
Creative & IP stakeholders | A potential mechanism for provenance and responsibility | Evidence, collection, storage, rights/provenance and accountable actors can be represented |
Technology founders / product architects | A design principle for building accountable systems from the beginning | The framework can be used during system construction, not only after failures |
Auditors / investigators | A structured trail for examining system changes | Detection => assessment => evidence => transition creates a traceable operational history |
Thank you for reading and if you can for contributing to the necessary change.
Comments