TL;DR
Reconfigurable Action Theories (RAT) provide a formal mathematical framework for AI agents that can change their own "rules of the game" at runtime. By treating tool loading and policy changes as actions that modify the underlying action theory itself, RAT allows developers to formally verify if an agent can still reach its goals after its capabilities are dynamically reconfigured.
What Problem Does This Paper Address?
Traditional AI action theories—the formalisms used to describe how actions change the world—typically assume a fixed "vocabulary" and a static set of "causal laws." For example, a robot might know how to pick_up a block, and the laws governing that action never change.
However, modern Agentic AI operates differently. Agents live within "harnesses" (like DeepSeek Harness or OpenHands) that dynamically load tools, switch between LLM providers, or update security policies during execution. If an agent loads a calculator tool, its vocabulary suddenly expands to include multiply, and new causal laws come into force. Existing formalisms struggle to model these "meta-actions" that change the theory itself. Without a formal foundation, it’s difficult to prove that adding a new tool won't break existing behaviors or make a critical goal unreachable.
Methods
The author introduces Reconfigurable Action Theories (RAT), extending nonmonotonic causal logic to handle dynamic changes.
Key Components:
- Theory Modules: Instead of one big theory, RAT uses named fragments containing a vocabulary, causal laws, and an initializer (which defines the starting state of a module's private fluents).
- Configurations: A state in RAT is a pair $\langle K, s \rangle$, where $K$ is the set of currently active modules and $s$ is the physical world state.
- Meta-Actions: The framework reserves
load(M)andunload(M)actions. These are governed by ordinary causal laws but have the special effect of changing the active module set $K$.
The Transition Semantics
A central challenge is deciding which laws govern a step that changes the theory. RAT uses a "split" approach:
- Before the action: The current module set $K_t$ determines if the action is executable and what its direct effects are.
- After the action: The new module set $K_{t+1}$ provides the static laws that determine the final state's consistency and indirect effects.
The paper also provides a translation of RAT into Answer Set Programming (ASP), a form of declarative logic programming. This allows standard solvers (like clingo) to perform automated planning, diagnosis, and reachability analysis on reconfigurable systems.
Datasets
The paper evaluates RAT using two approaches:
- Real-world Harness Workflows: The author created RAT models for recorded execution traces from three major agent harnesses: DeepSeek Harness, Pi, and OpenHands. These tests involved file editing, tool disabling, and calling tools through intermediate interfaces.
- Synthetic Scalability Benchmarks: To test the ASP implementation, the author generated three families of models:
- Tool sequences: Loading, using, and unloading $n$ tools in order.
- Provider choices: Selecting compatible LLM providers from $n$ candidates.
- Resource allocation: Assigning $n$ jobs to $r$ dynamic workspaces.
Key Insights and Ideas
- Complexity Parity: Surprisingly, allowing actions to change the theory doesn't make reasoning harder in the worst case. Bounded reachability remains NP-complete, and unbounded reachability remains PSPACE-complete, matching standard static action theories.
- Preservation Theorems: The paper identifies "read-only extensions"—modules that read existing state but don't interfere with existing laws. The author proves that loading such modules is guaranteed not to break the agent's current capabilities.
- Initialization Matters: Unlike standard logic, unloading and then immediately reloading a module does not necessarily return you to the previous state. The module's initializer resets its private state (e.g., clearing a calculator's memory), which is a critical detail for modeling real software.
- Commutativity: The author establishes formal conditions under which the order of loading two tools doesn't matter, ensuring the final configuration is identical regardless of the sequence.
Key Results
- Predictive Accuracy: The RAT models perfectly predicted the outcomes (success or rejection) of 31 out of 39 attempted operations in the DeepSeek Harness tests, matching the behavior of the actual implementation.
- Scalability: The ASP-based reasoner handled configurations with up to 320 providers or 256 tools. While planning (finding a sequence) is significantly harder than configuration checking, the system could solve complex resource allocation problems with 20+ jobs in a few seconds.
- Formal Verification: The framework successfully identified cases where a security policy (modeled as a module) would correctly block a file-write action that was previously allowed.
Limitations and Future Work
- No Concurrency: RAT currently assumes actions happen one at a time. It cannot model overlapping tool calls or background processes.
- Fixed Catalog: You can only load modules that were defined at the start; the agent cannot "discover" or "invent" entirely new modules during a run.
- Harness Action Theory (HAT): The author suggests a future extension called HAT to handle "unfinished work." For example, if you unload a provider while a request is still pending, what happens to that request? RAT currently lacks a built-in way to track these transient states.
Summary updated