🤖 machine learning

Agentic Skill Optimization over Lie Algebroids

This paper introduces LASKO, a novel framework that models agentic skill optimization using Lie algebroids to represent edit policies and their non-commutative compositions, enabling order-of-magnitude speedups by screening edits via inexpensive Lie-bracket tests before costly LLM validation.

Original authors: Sridhar Mahadevan

Published 2026-07-14

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Sridhar Mahadevan

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to fix a giant, complex machine made of Lego blocks, where each block is a specific instruction, a rule, or a checklist for a robot. This machine is an "agentic system" designed to do smart things. The problem is, when the robot makes a mistake, you can't just swap out one Lego block and hope for the best. Sometimes, the order in which you swap blocks matters immensely. If you fix the "safety rules" before you fix the "math rules," the machine works. But if you swap them in reverse, the whole thing falls apart.

This is the puzzle that the paper LASKO (Lie Algebroid SKill Optimization) tries to solve.

The Problem: The "Order Matters" Trap

Think of the robot's instructions as a long story written in a special language called Markdown. To make the robot better, an AI optimizer tries to edit this story. It suggests tiny changes: "Add a rule here," "Delete that example," or "Fix this schema."

In the old way of doing things (called SKILLOPT), the optimizer acts like a clumsy gardener. It tries one change, sees if the plant grows, then tries another. It assumes every change is independent, like adding a single flower to a garden. But the paper argues this is wrong. These changes are more like gears in a clock. If you try to fix the spring before fixing the gear it connects to, the clock won't tick. The paper shows that two changes that look perfectly fine on their own can fail miserably if you do them in the wrong order.

The paper explicitly argues against the idea that you can just try every possible combination of edits one by one. It says that trying every single order (a "brute-force" approach) is too expensive and slow because it requires running the robot through a massive, expensive test every time. It also argues against the idea that a single "score" for a change tells the whole story; sometimes a change looks good immediately but ruins the robot's ability to learn later.

The Solution: The "Secret Handshake" Detector

The authors propose a new framework called LASKO. To understand it, imagine the robot's instructions aren't just a flat list, but a 3D structure with hidden layers.

The Visible Layer (The Anchor): This is what you see on the screen—the actual words changing in the document.
The Hidden Layer (The Kernel): This is the invisible stuff: the internal routing, the template variables, and the "mood" of the robot that you can't see immediately but affects how future changes behave.
The Secret Handshake (The Bracket): This is the paper's big idea. It's a mathematical test that checks if two changes "shake hands" correctly. If you do Change A then Change B, does it feel the same as doing Change B then Change A?

In the world of LASKO, if two changes don't "commute" (meaning the order changes the result), the system flags them as a "high-bracket" pair. This is like a traffic cop at a busy intersection. Instead of letting every car (every possible edit order) drive through and see if they crash, the cop uses a quick, cheap sensor to check the traffic flow.

The Magic: Speeding Up by 15 Times

Here is where the numbers get exciting. The paper ran a series of tests to see if this "traffic cop" idea actually works.

They set up a challenge where the robot had to fix a workflow with 10 specific anchors (like "schema," "tool contract," "validator," etc.).

The Old Way (Brute Force): To find the perfect fix, you would have to try every possible order of edits. For 10 items, that's 90 different ordered pairs. If you run each one through a giant AI model (like the DeepSeek V3.1 4-bit model with 671B parameters mentioned in the paper), it takes forever.
The LASKO Way: The system first runs a super-fast "bracket probe." This is a tiny, cheap calculation that takes microseconds (specifically, the paper notes a probe took about 0.000127 seconds in one test). This probe predicts which pairs of edits are likely to be the "high-bracket" ones that actually matter.
The Result: Instead of testing all 90 pairs, LASKO runs 90 bracket probes to filter the list, then validates only the top 10 predicted pairs.

In their experiments, this approach achieved a speedup of almost 15× compared to the brute-force method. In one specific test with a DeepSeek V3.1 model, the brute-force method took 538.1 seconds to validate all options, while LASKO did the same job in just 36.2 seconds. That's a 14.85× speedup.

Even more impressively, in a test with a Nemotron 70B model, the time dropped from 712.4 seconds to 86.0 seconds (an 8.28× speedup). Across all the models they tested, the average speedup was 6.94×.

What This Actually Means

The paper is very careful to say this isn't a magic wand that fixes everything instantly. It doesn't remove the need for the expensive "validation" step where the robot actually tries the fix. Instead, it acts as a filter.

Think of it like a bouncer at a club. The "bracket probe" is the bouncer checking IDs at the door. It's fast and cheap. It stops the people who definitely won't get in (the bad edit orders) so the expensive "served validation" (the actual club entry) only has to deal with the people who have a real chance.

The authors suggest that this method allows the system to find the perfect repair sequence (getting a score of 1.000) while spending only a fraction of the time and money. In a test with 160 edits, the brute-force method would need 25,441 expensive validation checks. LASKO, using its bracket screening, only needed 168 probes (a combination of bracket checks and final validation calls) to get the same perfect score.

The Bottom Line

The paper suggests that by treating skill editing not as a flat list of options, but as a structured system where the order and hidden context matter, we can optimize AI agents much faster. It's not about guessing better; it's about knowing which guesses are worth the expensive test.

While the results are promising and the speedups are measured in real experiments with large models, the authors frame this as a new framework for optimization. They show that the "Lie bracket" (the order-sensitivity test) is a powerful tool for filtering out bad paths before they cost us time and money. It turns a chaotic search through a maze into a guided tour, ensuring we only walk the paths that are most likely to lead to the exit.

Technical Summary: Agentic Skill Optimization Over Lie Algebroids (LASKO)

1. Problem Statement

Agentic skill optimization, exemplified by frameworks like SKILLOPT, involves improving agent performance by editing structured artifacts (prompts, rubrics, schemas, tool contracts, validators, and traces). The central difficulty identified in this paper is that the search space for these edits is not flat.

Non-Commutativity: The order of edits matters. Repairing a schema before applying a normalization rule may yield different results than applying them in reverse. Two edits that appear locally reasonable may fail when composed, or weak edits may only become productive in a specific sequence.
Latent Structure vs. Visible Effects: An edit policy chosen by an optimizer is not identical to the visible change observed in a document or rollout. Controlled interventions often carry internal implementation coordinates, latent state, routing context, or template variables that are invisible at the first order but significantly impact future composition.
Inefficiency of Current Methods: Short-horizon loops that validate only single edits miss critical interaction effects, while exhaustive enumeration of ordered edit programs is computationally prohibitive due to the high cost of Large Language Model (LLM) rollouts and validations.

The paper posits that this is a geometric problem: the local algebra of edits around a typed skill artifact requires a formalism that distinguishes between controlled interventions and their visible effects.

2. Methodology: LASKO Framework

The paper introduces LASKO (Lie Algebroid SKill Optimization), a framework that models skill optimization over a controlled Lie algebroid $A \to M_d$ rather than a simple tangent bundle.

2.1 Mathematical Formalism

Base Category ( $M_d$ ): The base space is a tangent category of typed, anchored Markdown objects. These include documents, plans, tool contracts, and validator traces. Unlike Euclidean parameter spaces, these are structured artifacts with specific anchors (e.g., guardrails, schema fields, evidence edges).
The Lie Algebroid ( $A$ ): The fiber $A_x$ at a skill state $x$ contains controlled edit policies (sections $s, t \in \Gamma(A)$ ). These are not yet visible changes but represent modes of intervention (e.g., "strengthen guardrail," "repair schema").
The Anchor Map ( $\rho$ ): A bundle map $\rho: A \to TM_d$ $ρ : A \to T M_{d}$ maps a controlled intervention to its visible infinitesimal effect on the Markdown artifact.
- Kernel ( $\ker(\rho)$ ): Represents latent structure (template variables, routing choices, hidden state) that has no immediate visible effect but influences future composition.
The Lie Bracket ( $[\cdot, \cdot]_A$ ): Measures the order-sensitivity of composing two edit policies. If $[s, t]_A \neq 0$ , the edits do not commute. The bracket captures the "composition defect" before the intervention is projected into observable dynamics.

2.2 Operational Mechanism

LASKO utilizes a forward-backward process:

Forward Pass (Tangent Functor): Local edits are pushed forward through rewrites, rollouts, and observation contexts.
Backward Pass (Cotangent Structure): Validation losses, critiques, and failure signals are pulled back to specific artifact anchors (diagrammatic backpropagation).
Curvature Diagnostics: The system computes residuals to measure non-closure and path dependence:
- Visible Frobenius Residual ( $R_{vis}$ ): Measures if visible edits close under the Lie bracket.
- Anchor Defect Residual ( $R_{anchor}$ ): Measures the gap between the estimated intervention algebra and observed visible brackets.
- Kernel Residual ( $R_{ker}$ ): Captures hidden procedural interactions where visible artifacts agree but traces differ.
- Diagrammatic Backpropagation Curvature ( $Curv_D$ ): Measures path-dependence in credit assignment (blame).

The optimization objective minimizes a combined loss involving task performance and these curvature residuals, seeking low-curvature fixed points where edits commute or their non-commutativity is accounted for.

3. Key Contributions

Geometric Formulation: The paper reframes agentic skill optimization as optimization over a Lie algebroid, distinguishing between the controlled intervention (section) and the visible effect (anchor).
Lie-Bracket Screening: It proposes using the Lie bracket as a cheap screening statistic. High-bracket pairs are identified as candidates for expensive validation, while low-bracket pairs are filtered out. This replaces brute-force sequence enumeration with targeted pair probing.
Tangent Category of Markdown: It defines a formal tangent category for typed Markdown workflows, allowing for the rigorous treatment of local edits, dependencies, and workflow morphisms.
Empirical Validation: The paper provides preliminary benchmark results demonstrating that LASKO can recover the performance of exhaustive ordered-pair search with a fraction of the validation cost.

4. Experimental Results

The paper reports results across several controlled benchmarks, comparing Greedy Single-Edit, Random Ordered Pairs, Exhaustive Ordered Pairs, and LASKO-Prioritized strategies.

Ten-Anchor Benchmark: In a controlled 10-anchor chain, LASKO achieved a score of 1.000 (matching exhaustive search) using only 10 validation probes (plus 90 cheap bracket probes). In contrast, the greedy approach scored 0.240, and random pairs scored 0.266 (mean).
Scalability: As the number of edits increased (up to 160), LASKO maintained a score of 1.000 with a linear number of validation probes, whereas exhaustive search required quadratic growth in probes (e.g., 25,441 probes for 160 edits vs. 168 for LASKO).
Real-World Workflows:
- 10-K Financial Research (BASKET/ROCKET): LASKO prioritized valid repair orders (e.g., table extraction before numeric gating) to achieve 1.000 score with 29 validation probes, compared to 183 for exhaustive search.
- Democritus/PSR Causal Manifolds: In repairing causal manifolds for physical exercise and GLP-1 drug studies, LASKO achieved 1.000 score with 21 validation probes, matching exhaustive search (111 probes).
- Product Feedback (Lovesac): Similar results were observed in a product review repair task, with LASKO achieving 1.000 score using 19 validation probes.
Speedup: When tested with various served models (including DeepSeek V3.1 4-bit, Nemotron, and Llama variants), LASKO demonstrated speedups ranging from 3.69× to 14.85×. The primary driver was the reduction in expensive LLM validation calls, as the bracket screening took microseconds (e.g., 0.000508 seconds for 72 probes) compared to seconds per validation call.

5. Significance and Claims

The paper claims that LASKO offers a structural solution to the inefficiency of agentic skill optimization. By modeling edits as sections of a Lie algebroid, the framework explicitly accounts for:

Order-Dependence: Recognizing that the sequence of repairs is critical.
Latent State: Acknowledging that edits carry hidden context (kernel) that affects future interactions even if the immediate artifact looks unchanged.
Validation Economics: Providing a mathematically grounded method to filter the search space. The Lie bracket acts as a "screening device" that identifies high-value edit interactions before incurring the cost of full rollout validation.

The authors emphasize that this is a preliminary framework. The results show "order-of-magnitude speedups" in specific controlled benchmarks, suggesting that the geometric structure of skill edits can be exploited to make agentic self-improvement scalable. The paper does not claim to solve all agentic alignment or reasoning problems but specifically addresses the optimization of structured skill artifacts where edits are anchored, typed, and order-sensitive.