Adao Aparecido Ernesto

@milesdeutscher Skills are an important evolution. But instead of creating many specialized skills, we can define a protocol base that can be extended through a logical layer of business knowledge. I explore this idea here: x.com/adaoaper/statu…

Grok just completely changed the game for real-time financial research. We just got the preview to "Grok Skills," and they look 10x more powerful than Claude Skills. In seconds, you can create workflows that keep you up to date on the latest financial news, analysis & more - directly sourced from the best accounts on 𝕏: (works for all niches btw)

Same governed workflow, now with OpenAI Codex as the executor: youtu.be/Dw67ljuSdEU?si…

Structuring AI Workflows with Governance by Design This experiment uses a complex Small Molecule HTL Optimization Campaign Simulation to demonstrate AIURM/AIUAR as a protocol layer for governed cognitive workflows. The goal is to show how an executor agent can resolve a multi-step workflow over a persistent, addressable substrate, generating intermediate artifacts, ranked outputs, and operational traces. Claude Code acts as the executor. The filesystem acts as the structured substrate. Governance defines the workflow. Data, logic, and results become addressable artifacts. Code is dynamic and instrumental. All chemistry data, campaign parameters, and outputs are synthetic and used strictly for demonstration purposes. youtu.be/_HRhcLiD2iE?si… #AI #LLM #AIURM #AIUAR #AIAgents #EnterpriseAI

Experiment scale: 24 JSON files 84K records in one JSON artifact 3.9M lines in one JSON artifact 574 MB of total JSON output This matters because governed AI execution needs more than a final answer. It needs persistent state, intermediate artifacts, traceability, and reuse.

Beyond Agent Memory I’ve been seeing many interesting proposals around protocols for agent memory. That matters. But I think we can go one step further: standardizing the agent’s operational space. Not only what the agent remembers, but where the agent works. Data, logic, rules, governance, execution state, results, audits, logs, and code artifacts should be persistent, addressable, governable, and substrate-agnostic. Memory is part of the operational space. The operational space is the agent’s execution environment. Here is a practical experiment: x.com/adaoaper/statu… #AI #LLM #AIAgents #ClaudeCode #Codex #EnterpriseAI

Do we need more hardcoded agents? Or more governed workflows? Maybe the better question is not: “Which agent do we need to create for this workflow?” But: “How do we structure this workflow so that a general-purpose agent can resolve it?” #AI #LLM #AIAgents #ClaudeCode #Codex #EnterpriseAI

This also changes the operating model: From: - many domain-specific skills - agent-centric workflows - monolithic context passed to the model - persistence in a specific format To: - a base set of protocol skills - project-governed execution - explicit separation of Data, Logic, and Result as addressable artifacts - persistence in an addressable, substrate-agnostic operational space

Do we need more hardcoded agents? Or more governed workflows? Maybe the better question is not: “Which agent do we need to create for this workflow?” But: “How do we structure this workflow so that a general-purpose agent can resolve it?” Read more: x.com/adaoaper/statu… #AI #LLM #AIAgents #ContextEngineering #ProtocolEngineering #GovernedWorkflow

One way to frame the shift: From: - LLM as a node in a workflow - logic embedded in code - fixed orchestration code To: - LLM as a governed runtime resolving the workflow - logic as artifact - code as an instrument, generated or used dynamically

Credit Risk Assessment workflow using AIURM/AIUAR Context Space Workflow Specification with DLR methodology and an addressable substrate. Multi-Session Worker Pattern: one proposal per session. The pipeline operates as a queue-driven worker: A producer instance writes one normalized loan application per session. An executor instance claims pending sessions, resolves them sequentially, and writes the result markers. Logic and policy parameters are anchored in session_1 and resolved through cross-session reference. A reviewer instance verifies the applied policies and generates comments and insights. Composition: Producer → Executor → Reviewer - 3 AI agent instances - Protocol layer - Addressable substrate - Code as a dynamic instrument - No framework - No orchestrator Same workflow: Codex in Filesystem Claude Code in SQLite Practical experiment: x.com/adaoaper/statu… #AI #LLM #AIURM #AIUAR #AIAgents #EnterpriseAI

I believe the choice of file format depends on the use case. In many cases, I advocate for a substrate-agnostic abstraction layer. This abstraction allows the same contextual structure to persist across multiple substrates. FILESYSTEM | JSON_FILE | MARKDOWN_FILE | SQLITE folders/ | {"nested"} | ## headings | tables Here are some practical experiments in this direction: x.com/adaoaper/statu…

I agree with this distinction between a knowledge base and an operational layer. Many solutions are emerging in this direction, often in proprietary ways. It would be interesting to have a model-agnostic and substrate-agnostic approach. This is the direction I have been exploring with a protocol layer. The operational layer preserves state through normalized context in a shared, addressable operational space, where data, logic, rules, governance, and results can exist as artifacts over a substrate. Here is a practical experiment using Filesystem and SQLite as substrates: x.com/adaoaper/statu…

Avoiding Agent Sprawl: Workflow as an Executable Project Just as skill explosion can happen, agent sprawl can also emerge. One agent for credit risk. One agent for contract review. One agent for HR analysis. One agent for portfolio risk. One agent for every business workflow. This works in many cases, but over time, business rules, prompts, tools, assumptions, criteria, and operational logic start becoming embedded inside each agent. The result is a growing fleet of specialized agents that are difficult to maintain, version, audit, compare, replace, and govern. Maybe the question should not be: “Which agent do we need to create for this workflow?” But rather: “How do we structure this workflow as a project that a general-purpose agent can resolve?” In this sense, the agent does not need to become the domain. This becomes possible by defining a protocol layer over an addressable operational space. The protocol layer gives the agent the structure to resolve the cognitive workflow. The substrate preserves the artifacts the agent operates on. Domain logic can exist as addressable, versionable, and auditable knowledge inside the operational substrate. The model can change. The executor can change. The substrate can change. But the workflow remains preserved as a project. Instead of many agents, we can have many projects. From: agent-centered workflows. To: project-centered execution. Project as workflow structure. Governance as contract. Logic as rules, constraints, and domain knowledge. Data, Logic, and Result as addressable artifacts. Substrate as persistence. Model as governed resolver. Agent as executor. Code as instrument. I explored this concept in a practical experiment here: AIURM/AIUAR: A Protocol Layer for Cognitive Workflows x.com/adaoaper/statu… #AI #LLM #AIURM #AIUAR #AIAgents #EnterpriseAI #ProtocolEngineering

Avoiding Skill Explosion Skills represent an important evolution in the AI ecosystem, shifting the focus from the raw capabilities of models to practical application, especially in workflows with different levels of complexity. This works in many cases, but over time it can create a nightmare of maintenance, versioning, coupling, and governance. Hundreds of skills start competing with each other, duplicating logic, hiding business rules, and fragmenting the operational context. The structural approach of AIURM/AIUAR follows a different path. The skill acts as a protocol instruction layer. It guides the agent in recognizing, resolving, and operating a protocol-based set of conventions and abstractions for persistent, governable, and extensible cognitive workflows across different domains and levels of complexity. A summary of the fundamental protocol skills for an extensible operational space: - markers as semantic anchors for context and artifacts - addressing as a logical representation of the structure - explicit separation between data, logic, and results - governance as the pipeline contract - data as operational inputs, regardless of form or structure - logic as a layer of rules, constraints, and domain knowledge - results as outputs produced by applying logic over data From there, business knowledge does not need to become a new skill for every domain, rule, or operational procedure. It can exist as an addressable domain logic layer, written as an artifact inside the operational substrate itself: [*logic_credit_policy] [*logic_hr_retention_risk] [*logic_molecule_prioritization] [*logic_contract_review] [*portfolio_risk_criteria] The rules live as logical artifacts: versionable, auditable, replaceable, and addressable. This distinction helps prevent skill proliferation and shifts the center of the operational structure: From many specialized skills to a base set of protocol skills operating across multiple layers: Skill as interpreter. Protocol as structure. Logic as addressable knowledge. Model as governed resolver. Agent as operational executor. Code as instrument. Substrate as persistence. I explored this concept in a practical experiment here: AIURM/AIUAR: A Protocol Layer for Cognitive Workflows x.com/adaoaper/statu… #AI #LLM #AIURM #AIUAR #AIAgents #EnterpriseAI #ProtocolEngineering

Filesystem, database, JSON, Markdown... What is the best substrate for agents? Maybe there is no absolute best. It depends on the workflow. What matters is whether the substrate is structured, persistent, addressable, and resolvable by the model. See these substrate-agnostic practical experiments: Filesystem | JSON | Markdown youtu.be/HdJRO5C5TYg?si… Filesystem | SQLite youtu.be/PP6XBnEPeEA?si… #AI #LLM #AIURM #AIUAR #AIAgents #CognitiveWorkflow

Substrate as shared operational space in governed cognitive AI workflows: In many AI integrations, context is passed into the model at execution time. But in governed workflows, context can persist as structured, addressable, and versionable artifacts over a shared substrate. The workflow artifacts, such as governance, data, logic, and result, are organized within a hierarchical addressable structure: contextspace → entity → project → session → marker And this structure can be materialized in: Filesystem, Database, JSON, Markdown, or any other structure the model can resolve. The key point is that the substrate becomes a shared operational space where agents and systems can read, write, and operate over the same context space. Protocol gives structure. Addressing gives location. Substrate gives persistence. The model resolves execution. Code is dynamic and instrumental. This is one of the ideas I have been exploring with AIURM/AIUAR. I show a practical experiment in this article, with the video link at the end: x.com/adaoaper/statu… #AI #LLM #AIURM #AIUAR #AIAgents #GovernedWorkflow #AddressableSubstrate

I strongly agree. Beyond being versioned, context also needs to become a shared and addressable operational space, where data, logic, rules, governance, and results can exist as structured artifacts. If agents are guided by instructions, rules, and memory, then context becomes part of the execution layer, not just something passed into the model. This is the direction I've been exploring with a protocol layer: x.com/adaoaper/statu…

Context may be the most under-engineered layer in AI coding today. In this keynote, @patrickdebois, argues that if agents are driven by prompts, rules, and memory, then context deserves the same rigor we already give code. youtube.com/watch?v=bSG9wU…

Code as instrument in governed cognitive AI workflows: In many frameworks, code remains the main orchestration layer, and the LLM is treated as a node. But in governed cognitive workflows, this can be inverted: the LLM can perform the orchestration, guided by a protocol layer. The workflow is structured as addressable artifacts: intent → governance → data → logic → result The model operates as the governed runtime environment. Code becomes an instrument that can be used dynamically when indicated for: IO, validation, deterministic logic, runtime support, persistence, and reproducible computation. The agent’s goal is not just code generation, but using code as an operational resource to resolve complex governed workflows. Code supports execution. The protocol layer governs execution. The substrate preserves execution. The model resolves execution. In many cases, the bottleneck is not the model’s intelligence, but how we structure the problem so the model can operate by modulating inference and deterministic execution. This is one of the ideas I have been exploring with AIURM/AIUAR. I show a practical experiment in this article, with the video link at the end: x.com/adaoaper/statu… #AI #LLM #AIURM #AIUAR #AIAgents #GovernedWorkflow #InstrumentalCode