Pith.

Artificial Intelligence · arXiv:2610.22061 v2 · submitted 15 Oct 2026

FAOPs: Normal Forms and an Algebra for AI Agent Workflows

Ali Mohammadi Shanghooshabad (JPMorgan Chase & Co.)

The paper says

“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, as regulated sectors require.”

more of the abstract

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 sub-workflow a single canonical definition so a change propagates instead of drifting, and Scoped (FNF-4) checks that each FAOP lists resources used by its own actions and the FAOPs it calls, while guardrails declared by it and by FAOPs that call it remain attached to their sources. A FAOP algebra of provably sound equalities turns refactoring and parallelization into compiler rewrites; orthogonal extensions add optimization (+O), bounded completion with time and cost limits (+B), and reachability checks (+R); and an architectural-level classifier (0-3) determines whether a workflow needs AI at all. Together, these make integrity, isolation, typing, stopping limits, 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), and a separate executor that loads FAOPs from SkillBase and enforces these guarantees at run time. A worked financial workflow illustrates the approach end to end.

from the abstract

Pith says

Machine review · deepseek-v4-flash · 16 Oct 2026 · of version 1 of the paper; version 2 is newer · what was read was not recorded · not checked by a person

It can be wrong. Challenge this review or reply to it.

Holds up, with conditions. The formal core is sound under its stated assumptions and the normal-form framework is a genuine contribution, but the abstract overclaims relative to the body, and the auto-parallelization law rests on an assumption about LLM calls that no compiler check enforces. This line is wrong

3 major objections · 5 minor

How often objections from reviews like this one are right: not yet measured

Are you an author? What you can do.

Not checked: figures, code, what the references say.

The paper says, at §3.5 (A2), §3.6.1, Table 5 row 4, Abstract

The review did not quote this passage.

A classifier read this sentence of the paper as acknowledging the concern (probability 0.65):

“Soundness.Three honesty conditions (each just re- stating a rule the normal forms already enforce) make the model exact.(A1) Honest footprint:a leaf’s out- put recordδℓ(σ)is fixed by the fields it declares to read plus its own effect outcome, and it never reads an un- declared field: this is what a truthful FNF-2 schema means.(A2) Outcomes follow the leaf:the result of a nondeterministic effect (say, an LLM call) is fixed once as a value (a singledrawfrom its distribution) that belongs to the leaf’s identity, not to its position in the running order; reordering the leaf does not change its val”

Pith says: Objection 1 of 3 · major

Theorem 1 is sound as a conditional statement, but the paper's headline benefit — automatic parallelization as a compile-time concern — is asserted unconditionally even though it rests on A2 (b241), which is a semantic property of external effects that no normal-form pass or compiler check verifies and that cannot be read off the workflow text.

more of objection 1

The op_LLM leaf is the flagship case, and real model calls are typically sensitive to prompt context, hidden state, and concurrency timing; when A2 fails, the L3 rewrite seq(a,b) to par(a,b) changes the output, so the +O claim that the compiler 'certifies' rewrites as safe and semantics-preserving (§3.6.1) overreaches, as does the abstract's 'not runtime hopes' phrasing and Table 5 row 4. The authors explicitly label A2 an assumption (b241) and condition the propositions on truthful declarations (b156), so the proof itself is not in question; the paper should either qualify the benefit claims so they carry A1-A3, or restrict the L3/par rule to effect classes with a stated commutation guarantee (for example, op_compute and op_db leaves under declared isolation) and require an explicit commutation certificate before parallelizing nondeterministic leaves.

The paper says, at §3.5 (semantics and equality), Definition 2, L3

The review did not quote this passage.

Pith says: Objection 2 of 3 · major

Equality in the algebra is equality of final states ('two bodies are equal when they denote the same transformer'), while Definition 2 defines a mutating effect as externally observable business work that crosses the leaf's boundary. These two notions are in tension for the laws' advertised application: two effectful leaves with disjoint output fields (say two op_email or op_queue leaves) …

more of objection 2

… are independent by Definition 7, so L3 commutes or parallelizes them, yet reordering or running them concurrently changes the externally observable effect history (which effect fires first, whether a second write observes the first). For traceability and auditability — the paper's stated motivation — the effect history is part of observable behavior. The L3 proof is correct for the state-transformer semantics; the paper should either enrich the denotation with an effect trace and prove the laws for that richer equality, or explicitly restrict the laws and the Table 5 benefits to workflows whose external effects are fully reflected in the state, stating plainly that effect ordering is abstracted away.

The paper says, at §3.6.2, Definition (+V), Proposition 3

The review did not quote this passage.

Pith says: Objection 3 of 3 · major

The +V guarantee that every branch arm is reachable — 'some valid input s in S_in(F) makes p(s)=true and some other makes it false' — is said to be discharged by 'ordinary satisfiability queries in the same decidable typed-predicate class used by if conditions,' but the paper never defines that class.

more of objection 3

For unrestricted typed predicates over the state (for instance nonlinear arithmetic over numeric fields), the satisfiability problem is undecidable in general, so as written the reachability conjunct of +V has no well-defined decision procedure and Proposition 3 silently depends on an unspecified hypothesis about the predicate language. The authors should name the decidable theory used (for example, quantifier-free linear arithmetic over the declared types) and state that +V's satisfiability obligations are expressed in it, or make the decidability assumption an explicit condition of Proposition 3.

5 minor objections

The paper says, at §3.6.1, interrupt fusion

Pith says: minor objection 1 of 5

The paper claims that fusing m interrupts with pairwise disjoint query keys into one compound interrupt is a +O rewrite with 'no change to the workflow's logical outcome,' but the interrupt primitive iota has no denotation in the semantics of §3.5 and no fusion law is derived from L1-L5; the claim should be labeled informal until iota is given a formal semantics.

The paper says, at §3.7, Definition 8

Pith says: minor objection 2 of 5

The Level 0 claim that 'no model is invoked anywhere' is decided by effect labels alone; a leaf labeled op_tool can wrap a tool that internally invokes a model or is otherwise non-deterministic, so the classifier should carry the same truthful-declaration caveat stated for the other propositions (b156).

show 3 more

The paper says, at §8, conclusion

Pith says: minor objection 3 of 5

The sentence 'in our own deployment we observed new-agent development fall from weeks to hours' is an empirical claim and none of its data is reported; it stands in tension with §5 and b420, which state that the evaluation is intentionally deferred. Either provide the measurement or remove the statement.

The paper says, at §3.3 and Convention 2

Pith says: minor objection 4 of 5

FNF-3 is described as removing the recursion anomaly, but call-graph acyclicity is a standing design constraint of Convention 2 (cycles are forbidden) rather than a property entailed by factoring; the text should say clearly that acyclic call graphs are enforced by the registry by convention, independent of the architect policy Pi_comp.

The paper says, at §4 and Abstract

Pith says: minor objection 5 of 5

The abstract says the theory is 'implemented in SkillBase,' while §5 and b420 say the compiler, registry, executor, and SkillBase are 'described but not yet reported'; a sentence in §4 clarifying whether these components currently exist as working code or as designs would prevent the abstract's 'implement' from being misread.

What would settle it

Run a distributional equivalence test on real op_LLM leaves: take a workflow containing two FNF-2-independent LLM leaves with the same declared S_in, execute it N times in the original sequential order and N times under the L3-parallelized schedule with fixed inputs and temperature, and compare the distributions of downstream S_out using a statistical test such as a permutation test on output records. If the distributions differ significantly, A2 fails for current models and L3 is not meaning-preserving outside the assumption; if they match on a diverse corpus, the concern is empirically settled in the paper's favor.

from the skeptic's reading

How the review went

4 readings by deepseek-v4-flash · 16 Oct 2026

  1. Reader holds up, with conditions confidence moderate
  2. Skeptic agrees 1 min 0 s · 37,732 tokens read, 6,506 written
  3. Editor wrote the verdict above 1 min 4 s · 38,733 tokens read, 7,170 written
  4. Referee major revision: 3 major objections, 5 minor 3 min 5 s · 38,201 tokens read, 21,907 written

Not run on this paper: the simulated authors' defence.

Pith did not check this review's objections against the paper.

The review in full

The review in brief, machine-written

Two things to know up front. The formal core is coherent and the theorems check out under the conditions the paper states — I went through Propositions 1-4 and Theorem 1 line by line. And the authors are unusually honest about their conditions: b156 says everything holds relative to truthful declarations, and b241 states A2 as an assumption. The problems are in the frame, not the proofs.

What's actually new: the individual laws are classical — function composition, Bernstein's independence test, branch distribution. But the packaging is a real contribution. Four progressive normal forms aimed at specific library-level anomalies, compile-time scope monotonicity in two dimensions, the (k, E, λ) signature as a governance interface, and the 0-3 architectural classifier are all genuinely useful and absent from the Agentics 2.0, λA, and GraSP lines, which the paper positions correctly as identity/associativity-only or runtime-repair. The worked financial example in Appendix A is thorough and does real work showing each pass. The relational-normalization analogy is apt, not just decoration.

Soft spots, in order of size. First, L3 auto-parallelization depends on A2, "outcomes follow the leaf": an LLM call's result belongs to the leaf, not its position in the run. That is precisely what fails for context- and concurrency-sensitive models, and nothing in the compiler checks it — the paper's claim that the honesty conditions "each just restate a rule the normal forms already enforce" is false for A2 specifically, since FNF-2 checks declared schemas, not model behavior. The authors deserve credit for stating the condition, but the abstract's "compile-time concerns, not runtime hopes" is not established for the most commercially valuable rewrite. Second, an internal inconsistency: the abstract says "We implement the theory in SkillBase," while Section 7 says the tooling and evaluation are "described but not yet reported," and the conclusion's "in our own deployment... weeks to hours" is an unsupported anecdote sitting next to that same sentence. Both need fixing. Minor: FNF-1 certifies declarations, not code, and FNF-3 delegates to an architect policy left as a parameter — acknowledged in the text, and fine for a framework paper.

Who it's for: people building governed agent infrastructure in regulated industries, and PL researchers working on agent-workflow verification. It deserves a serious referee. I'd send it out, expecting revision: tighten the abstract and conclusion to match the body, and ideally ship the promised corpus evaluation.

The strongest objection

The abstract's headline claim that optimization and parallelization are compile-time concerns depends on Theorem 1, and Theorem 1 is conditional on A1-A3. The load-bearing assumption for the parallelization law L3 is A2, 'outcomes follow the leaf': the result of a nondeterministic effect such as an LLM call is a single draw belonging to the leaf's identity, not to its position in the execution order. L3 is the rewrite seq(a,b) = seq(b,a) = par(a,b) for FNF-2-independent steps, and it is the advertised basis for +O auto-parallelization (Table 5, row 4). The normal-form passes check declared schemas, effect labels, and scopes; none of them checks A2, because A2 is a semantic property of the external model, not a property of the workflow text. A1 only says a leaf never reads an undeclared field, but the compiler cannot verify from S_in that a real model call is insensitive to prompt context, hidden state, or concurrency timing. The paper itself acknowledges this class of condition: b156 says propositions hold relative to truthful declarations, and b241 states A2 as an assumption rather than a checkable invariant. So the theorem is sound as a conditional statement, and the authors deserve credit for stating the condition; the unresolved risk is that the unconditional 'compile-time concerns, not runtime hopes' claim is not established for parallelization. If A2 fails in practice, independent LLM leaves do not commute, and a compiler-applied L3 rewrite can change the downstream state and the workflow's meaning. This is a correctness risk in the strongest claimed benefit, not merely a missing evaluation.

The paper's formal core is internally consistent: the normal forms, the algebraic laws, and the proofs are stated cleanly, and Theorem 1 is explicitly conditional on A1-A3. The reader's weakest assumption is exactly the one I would select: A2 is the point where the soundness of the headline parallelization rewrite depends on a property of nondeterministic model calls that no compiler pass verifies. The implementation inconsistency between the abstract and Section 7 is real but secondary, because the paper's central contribution is a formal theory whose correctness does not depend on SkillBase being shipped yet. The A2 issue is more load-bearing because it touches the meaning-preservation claim for a headline benefit. Since the authors state A2 as a condition rather than claiming it is checked, this is a conditional-soundness gap, not an internal contradiction, and it does not warrant rejecting the paper. It does warrant keeping the CONDITIONAL verdict and asking for either a way to enforce or validate A2, or a weakened statement of what is guaranteed at compile time. My read therefore does not change the reader's verdict.

The referee's report

If the results hold, FAOP provides a genuinely useful organizing discipline for skill libraries: a vocabulary-and-schema layer with four checkable normal forms, a small equational algebra with a clean denotational semantics, and a level-0-3 AI classifier. The paper's strengths are real: the laws L1-L5 are parameter-free derivations directly from the semantics, the honesty conditions A1-A3 are stated in full rather than hidden, the proof obligations match the statements, the decision procedures come with complexity bounds, and the worked example is detailed enough to serve as a specification of the pipeline. Credit is also due for explicitly conditioning the propositions on truthful declarations (b156) and for candidly disclosing that the toolchain and empirical study are not yet reported (b420, b421). The contribution is bounded in ways the authors partly disclose: the guarantees are conditional on unverified declarations, the implementation and evaluation are deferred, and the headline 'compile-time concerns' claims are stronger than what A1-A3 can establish once real nondeterministic effects are admitted.

Pith's reading of the paper (a machine's summary, not the authors')

The paper's target is the operational skill library: the multi-step procedures, called Agent Operating Procedures (AOPs), that banks, insurers, and hospitals hand to AI agents, and that today are stored as coarse prose files which drift, escalate privileges, and break silently. FAOP recasts each workflow as a typed function over scoped state and pushes the whole library through four progressive normal forms — FNF-1 atomic steps, FNF-2 typed data flow, FNF-3 canonical shared procedures, FNF-4 least-privilege tool scopes — mirroring the relational normal forms that disciplined flat files. A five-law algebra (identity, associativity, commutativity of independent steps, branch distribution, fold/unfold) is proved sound against a denotational semantics, turning refactoring, extraction, and parallelization into compiler rewrites. If the theory holds, typing, isolation, termination, resource bounds, and even whether the workflow needs a language model at all can be checked before any code runs, with the honesty conditions behind the proofs stated openly.

What carries the argument. The load-bearing object is a FAOP body as a typed state transformer $[\![f]\!] : S \to S$ over a right-biased record merge $\uplus$ with per-FAOP function-call scoping, because that denotational semantics is what every algebraic law is checked against and what the scope-isolation guarantees rest on. The four normal forms are the progressive invariants the compiler enforces, each named for the anomaly it removes (compound steps, missing fields, duplicated procedures and recursion cycles, privilege escalation). A third mechanism is the data-dependence graph built from the FNF-2 schemas, which makes independence decidable pairwise and turns scheduling and parallelization into graph reachability questions. The soundness theorem sits on three honesty conditions, of which A2, 'outcomes follow the leaf', is the hinge: it fixes each nondeterministic effect as a single draw belonging to the leaf's identity rather than to its position in the execution order, which is exactly what lets L3 reorder and parallelize without changing meaning.

Core claim. On the paper's own account, every workflow is a typed state transformer over a threaded record, and each FAOP runs in its own function-call scope so only its declared outputs cross a boundary. The four normal forms are progressive invariants: FNF-1 splits multi-effect leaves into atomic, effect-labeled steps; FNF-2 checks every read against the fields produced so far on each path; FNF-3 gives each shared sub-procedure a single canonical registered identity and forbids cycles in the call graph; FNF-4 makes tool permissions shrink and guardrails grow along every parent-child edge. The algebra's five laws are semantics-preserving rewrites, and L3 asserts that independent steps — decided from FNF-2 schemas via a data-dependence graph — can be swapped or run in parallel without changing the output state; Theorem 1 proves L1–L5 preserve both the denotation and FNF-2 under assumptions A1–A3 (honest footprints, outcomes that follow the leaf, pure predicates). The paper's central consequence is that integrity, isolation, typing, termination, cost, and optimization become compile-time concerns, summarized per workflow in a signature $(k, E, \lambda)$ that a deployment policy can check.

The premise it rests on. The algebra's rewrites, especially reordering and parallelizing steps, preserve meaning only if a nondeterministic step such as a language-model call yields one fixed outcome that belongs to the step itself rather than to its position in the execution order — the paper's 'outcomes follow the leaf' condition (A2), which is stated as a soundness premise rather than something the compiler verifies.

If the paper is right (Pith's inferences, not the authors')

Refactoring a skill library becomes compiler-checked: extract and inline are the two directions of one fold/unfold law, and regrouping a sub-sequence is associativity, so canonical shared procedures can be created and updated without silent drift.

Independent steps run in parallel automatically: the compiler reads independence off the FNF-2 schemas, so a proof of soundness replaces a runtime hope that concurrent sibling effects will not interfere.

Termination and resource bounds become declared, checkable properties: every loop carries a mandatory maximum iteration count (+V), every action leaf declares latency and cost caps (+B), and worst-case bounds are computed bottom-up before deployment.

Scope confinement becomes static: FNF-4 rejects any workflow in which a descendant could reach a tool its ancestors never granted, so a prompt-injected step is capped at its own declared tools.

Whether a workflow needs AI at all becomes a computed classification (Levels 0–3) over effect labels and predicates, letting organizations reserve model-risk governance for the workflows that genuinely plan or generate.

A testable extension the paper leaves implicit: because the soundness of parallelization rests on assumption A2, one could empirically measure outcome invariance per leaf — if a model leaf's output distribution shifts with surrounding context or concurrency timing, L3 should be restricted to deterministic leaves and the +O catalog adjusted accordingly.

The same four normal forms could be applied to the human Standard Operating Procedures from which these workflows are lifted, turning a documentation standard into an audit artifact for regulated processes even without an agent in the loop.

The signature $(k, E, \lambda)$ is a natural machine-readable compliance summary: a regulator or model-risk committee could ingest the library-wide maturity card directly, a governance surface the paper describes but does not develop.

Check this review

Pith stored no record of this review's passes and took no fingerprint of it. Reviews made by code from 13 Nov 2026 on carry both.

How often reviews like this one are right

Reviews like this one: written by deepseek-v4-flash, where what was read was not recorded.

How often objections from reviews like this one are right: not yet measured

Every value above, in the review's public record (JSON)

Reviews by people

This review was written by a machine. No person has reviewed this paper on Pith yet. A scientist listed on Pith can review it for a fee, and their review is published here whatever it concludes.

Request a human review

How Pith checks papers · The full audit of this paper

The paper

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, as regulated sectors require. 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 sub-workflow a single canonical definition so a change propagates instead of drifting, and Scoped (FNF-4) checks that each FAOP lists resources used by its own actions and the FAOPs it calls, while guardrails declared by it and by FAOPs that call it remain attached to their sources. A FAOP algebra of provably sound equalities turns refactoring and parallelization into compiler rewrites; orthogonal extensions add optimization (+O), bounded completion with time and cost limits (+B), and reachability checks (+R); and an architectural-level classifier (0-3) determines whether a workflow needs AI at all. Together, these make integrity, isolation, typing, stopping limits, 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), and a separate executor that loads FAOPs from SkillBase and enforces these guarantees at run time. A worked financial workflow illustrates the approach end to end.

The paper's own sentences, arranged, kept beside the review and separate from it. Each label is drawn from a closed vocabulary; the number beside it is the probability the classifier gave that label. No sentence in this record was written by a model.

abstract compiled · 2026-10-16

The authors' main claim, as the classifier picked it out 0.95

“Together, these make integrity, isolation, typing, termination, cost, and optimization compile-time concerns across the whole library, not runtime hopes.”

How the main claim is stated: asserted 1.00

What the abstract itself states, as probabilities: claims first 0.09 · states limitation 0.10 · human participants 0.04 · controlled comparison 0.03 · randomized assignment 0.01 · states quantitative result 0.09 · compares with prior results 0.24 · mentions code or data availability 0.18

The abstract, sentence by sentence

This table labels the abstract only (arXiv listing abstract v1). The number is the probability the classifier gave the label.

SentenceRoleThe authors' own workStates the main conclusionStrength
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. background 1.00 0.06 0.04 asserted 1.00
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. background 0.53 0.07 0.02 asserted 0.97
We present Functional Agent Operating Procedures (FAOP), a formal theory that brings database-grade discipline to AI agent workflows. contribution 1.00 0.89 0.15 asserted 1.00
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. contribution 0.50 0.90 0.21 asserted 1.00
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. contribution 0.30 0.63 0.18 asserted 1.00
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. contribution 0.80 0.89 0.21 asserted 1.00
Together, these make integrity, isolation, typing, termination, cost, and optimization compile-time concerns across the whole library, not runtime hopes. interpretation 0.87 0.71 0.43 asserted 1.00
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. contribution 0.75 0.95 0.11 asserted 1.00
A worked financial workflow illustrates the approach end to end. contribution 0.57 0.84 0.03 asserted 0.95

What kind of paper the classifier reports this is: method or tool 0.97 · evidence from proof or derivation 0.69

What was examined, and what was not

Sources read

  • arXiv listing abstract v1

Not examined

  • full text
  • figures and tables
  • references and citing sentences
  • relations to other papers

Levels run

  • P abstract

Not run

  • S sections
  • T body sentences
  • C citations
  • R cross-paper relations

How the labels were made

Compiled by classifier-1.13.0 via TypeSafe API, question bank abstract-p1-20260923, 2026-10-16: 1 request, 7,268 input tokens.

Every quoted sentence on this record is the authors'. Every label is from Pith's closed vocabulary, with the probability shown beside it. This record as JSON

Figures (2)
Figure 1 of the paper
Figure 1. The AOP executor pattern. A single generic
Figure 2 of the paper
Figure 2. The FAOP toolchain. A Skill Architect, human or AI agent, authors the source artifact and makes the

Figures are the authors', reproduced from the paper.

Challenges and discussion

Disagree with the review, or know something it missed? Leave a comment, or challenge this review formally: a challenge becomes a permanent entry in this paper's record, and its decision is published here.

No comments yet.

Sign in to comment