FAOPs: Normal Forms and an Algebra for AI Agent Workflows

Ali Mohammadi Shanghooshabad

cs.AIOct 15, 2026

FAOPs: Normal Forms and an Algebra for AI Agent Workflows

Authors: Ali Mohammadi Shanghooshabad

Organizations: JPMorgan Chase & Co.

Abstract

Organizations increasingly encode operational procedures as multi-step agent skills, here called Agent Operating Procedures (AOPs), that must be traceable, auditable, reproducible, access-controlled, and bounded in time and cost, requirements that regulated sectors make mandatory. Yet AOPs are typically kept as coarse-grained files, in which steps bundle actions, copied procedures drift apart, any step may reach any tool, and refactoring goes unchecked. We present Functional Agent Operating Procedures (FAOP), a formal theory that brings database-grade discipline to AI agent workflows. FAOP recasts each workflow as a typed function over scoped state and subjects an entire library to four progressive normal forms: Decomposed (FNF-1) splits a workflow into atomic steps, Typed (FNF-2) makes its data flow explicit and type-checked, Factored (FNF-3) gives each shared procedure a single canonical definition so a change propagates instead of drifting, and Scoped (FNF-4) confines every step to least-privilege tool access. Once normalized, every atomic step is a separate entity with a declared contract and can be type-checked, scope-confined, bounded, tested, traced, and audited on its own. A FAOP algebra of provably sound equalities turns refactoring and parallelization into compiler rewrites; orthogonal extensions add verified termination (+V), optimization (+O), and time and cost bounds (+B); and an architectural-level classifier (0-3) determines whether a workflow needs AI at all. Together, these make integrity, isolation, typing, termination, cost, and optimization compile-time concerns across the whole library, not runtime hopes. We implement the theory in SkillBase, an AOP management system (what PostgreSQL is to data, SkillBase is to AOPs), together with a separate executor that enforces these guarantees at run time. A worked financial workflow illustrates the approach end to end.

Figures & tables

Figure 1: The AOP executor pattern. A single generic agent executes any workflow; only the AOP body and the tool list change per use case. Separating what the workflow does from how it runs makes the executor a single point at which typing and tool access can be enforced.

LoanID	Customer	Address	Phone	Branch	BranchMgr	Amount
L001	Alice	10 Main St	555-1234	Downtown	Diana	50,000
L002	Alice	10 Main St	555-1234	Downtown	Diana	25,000
L003	Carol	7 Oak Ave	555-5678	Uptown	Dave	80,000

Table 1: A flat, pre-normalization loan file.

Primitive	Notation	Reading
Action	$a:S\to S^{\prime}$	any single unit of work (for example, a tool call)
Sequence	$\mathit{seq}(f,g)$	apply $f$ , then $g$
Branch	$\mathit{if}(p,f,g)$	apply $f$ if $p(S)$ , else $g$
Loop	$\mathit{loop}(f,p)$	apply $f$ until $p(S)$
Interrupt	$\iota(q,k)$	suspend with query $q$ ; resume by passing the response to continuation $k$
Checkpoint	$\chi$	persist the running state to internal storage

Table 2: Primitive FAOP operators.

Dimension	Symbol	What it constrains	Example
Tools	$\mathcal{T}$	Which tools, APIs, or functions the step may invoke	{account_db, ledger_api}
Guardrails	$\mathcal{G}$	Constraints the step must obey	{no_pii, on_topic, requires_confirmation}

Table 3: The two dimensions of FAOP scope.

Law	Optimization	Effect
L1	Safe instrumentation	Insert or remove a pure value step (logging, a metric) without changing the surrounding function.
L2	Sub-workflow extraction	Regroup a sub-sequence and register it as a FAOP under FNF-3.
L3	Auto-parallelization	Schedule independent steps with $\mathit{par}$ , reducing wall-clock time.
L4	Branch-specific optimization	Push the shared post-branch step $c$ into each arm so each copy is optimized for that arm.
L5	Canonical reuse	Replace an inlined sub-sequence by $\mathit{call}(\text{id})$ to its registered body (FNF-3).

Table 4: Algebraic laws and compiler optimizations.

#	Benefit	Effect under FAOP	Source
1	Integrity across workflows	Compiler rejects dependents that become inconsistent when a shared step changes.	Registry
2	Scope isolation	Each step sees only its declared tools; depth cannot add tools absent from an ancestor.	FNF-4
3	Type safety	Compiler verifies $S_{\mathit{in}}(f_{i})\subseteq S_{i-1}$ before deployment.	FNF-2
4	Auto-parallelization	Independence proves disjoint dependencies; siblings are scheduled concurrently.	FNF-2, +O
5	Dead-step elimination	Every leaf with no downstream consumer is removed.	Algebra, +O
6	Interrupt batching	Independent interrupts with disjoint keys merge into one form.	+O

Table 5: Benefits delivered by FAOP normalization. Source identifies the FNF level or extension responsible.

Figure 2: The FAOP toolchain. A Skill Architect, human or AI agent, authors the source artifact and makes the design decisions that the compiler then verifies. SkillBase (vocabulary, compiler, registry) checks the artifact and stores each compiled blueprint with its description and signature. The FAOP executor runs the blueprint and enforces scope $\Sigma$ on every call; for other executors, an adapter converts the blueprint into their own AOP format, keeping the structural benefits and the runtime guarantees to the extent that executor can enforce them.

LLM Agent Workflow Optimization

LLM agent workflow optimization studies how to design and run multi-step agents for better task success, reliability, latency, and cost.

See all 256 papers

Jun 6, 2026

SKILL.nb: Selective Formalization and Gated Execution for Durable Agent Workflows

AI agents increasingly turn past experience into reusable artifacts such as code, workflows, and procedural memories. Reuse can improve efficiency, but it also creates a lifecycle reliability problem: artifacts that succeed once may fail under environment drift, underspecified tasks, or changing task distributions, especially in web automation. We introduce SKILL.nb, a framework for governing reusable agent workflows with evidence-calibrated lifecycle policies. SKILL.nb uses selective formalization: execution evidence decides which workflow steps should become executable code, which should remain natural-language guided, and when those choices should be revised. Workflows are stored as auditable, versioned notebooks that interleave natural-language guidance, multi-language executable cells, validation gates, fallback paths, and multimodal evidence such as outputs, screenshots, and error traces. At runtime, gate-conditioned execution lets each step run code when its gates validate, or fall back locally when drift invalidates the executable realization. On WebArena-Verified, SKILL.nb achieves 53.7% single-round success, improving over the strongest baseline by 3.9 percentage points. Across three re-executions, it retains 91.7% of initially successful tasks, 15.5 points above the next best method. Under bounded repair, it recovers 72.9% of subsequent failures while limiting post-repair regressions to 4.2%, compared with 15.0% to 17.0% for persistent baselines. It also leads on Mind2Web cross-website and cross-domain splits. In a GitLab migration test, SKILL.nb preserves performance when reusing frozen state learned on GitLab 15.7, with frozen-versus-fresh target-version gaps of -1.7 points on GitLab 16.11 and +0.6 points on GitLab 18.9. These results identify lifecycle governance and gate-conditioned execution as reliability axes beyond one-shot task success.

Amine El Hattami, Nicolas Chapados, Christopher Pal

ServiceNow Research · Mila · Polytechnique Montréal +1

AI Agent Reliability Agentic Workflows Agent Skill Learning Web Agents LLM Agent Reliability

Ask PDF

Jul 8, 2026

Progressive Crystallization: Turning Agent Exploration into Deterministic, Lower-Cost Workflows in Production

AI agents deployed for IT operations are typically permanent cost centers because every execution requires full LLM inference, even for previously solved problems. This paper introduces progressive crystallization, a lifecycle that treats agent exploration as a discovery mechanism rather than a permanent execution model. It defines a three-stage execution taxonomy, from fully agent-orchestrated to hybrid to fully deterministic workflows, together with an evidence-based promotion mechanism that converts repeatedly validated agent behaviors into cheaper and more reproducible deterministic workflows, while automatically demoting workflows that regress. Evaluated on a production cloud networking AIOps system processing tens of thousands of incidents per month, the approach increased deterministic execution from 0% to 45% over eight months, reduced per-incident agent costs by more than 70% despite doubling incident volume, and improved safety through greater reproducibility and auditability. The paper also presents the execution taxonomy, promotion and demotion criteria, trace extraction methodology, economic model, safety considerations, and discusses limitations and threats to validity.

Arun Malik

Microsoft Azure Networking

Cost-Aware Inference Agentic Workflows LLM Agent Workflow Optimization LLM Agent Reliability

Ask PDF

May 11, 2026

Engineering Robustness into Personal Agents with the AI Workflow Store

The dominant paradigm for AI agents is an "on-the-fly" loop in which agents synthesize plans and execute actions within seconds or minutes in response to user prompts. We argue that this paradigm short-circuits disciplined software engineering (SE) processes -- iterative design, rigorous testing, adversarial evaluation, staged deployment, and more -- that have delivered the (relatively) reliable and secure systems we use today. By focusing on rapid, real-time synthesis, are AI agents effectively delivering users improvised prototypes rather than systems fit for high-stakes scenarios in which users may unwittingly apply them? This paper argues for the need to integrate rigorous SE processes into the agentic loop to produce production-grade, hardened, and deterministically-constrained agent workflows that substantially outperform the potentially brittle and vulnerable results of on-the-fly synthesis. Doing so may require extra compute and time, and if so, we must amortize the cost of rigor through reuse across a broad user community. We envision an AI Workflow Store that consists of hardened and reusable workflows that agents can invoke with far greater reliability and security than improvised tool chains. We outline the research challenges of this vision, which stem from a broader flexibility-robustness tension that we argue requires moving beyond the ``on-the-fly'' paradigm to navigate effectively.

Roxana Geambasu, Mariana Raykova, Pierre Tholoniat +3

Columbia University and Google · Google

Agentic Workflows LLM Agent Security LLM Agent Reliability

Ask PDF

Abstract

LLM Agent Workflow Optimization

Explore similar work

SKILL.nb: Selective Formalization and Gated Execution for Durable Agent Workflows

Progressive Crystallization: Turning Agent Exploration into Deterministic, Lower-Cost Workflows in Production

Engineering Robustness into Personal Agents with the AI Workflow Store