arxiv: 2604.14401 · v1 · submitted 2026-04-15 · 💻 cs.AI · cs.DB

Recognition: unknown

Credo: Declarative Control of LLM Pipelines via Beliefs and Policies

Andrew Crotty, Duo Lu, U\u{g}ur \c{C}etintemel

Authors on Pith no claims yet

Pith reviewed 2026-05-10 13:03 UTC · model grok-4.3

classification 💻 cs.AI cs.DB

keywords Credodeclarative policiesbeliefsLLM pipelinesagentic AIsemantic control planeadaptive execution

0 comments

The pith

Credo represents LLM semantic state as beliefs and regulates behavior with declarative policies over them

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The paper introduces Credo to handle long-lived, stateful decision-making in agentic AI systems where conditions evolve continuously. Existing approaches use imperative control loops, ephemeral memory, and prompt logic that make behavior opaque and hard to adapt or verify. Credo instead captures semantic state explicitly as beliefs and lets declarative policies defined over those beliefs determine actions such as model selection, data retrieval, or corrective re-execution. A database provides the backing store for this semantic control plane, so changes in evidence update beliefs and policies trigger appropriate responses without any modification to the core pipeline code.

Core claim

Credo represents semantic state as beliefs and regulates behavior using declarative policies defined over these beliefs. This design supports adaptive, auditable, and composable execution through a database-backed semantic control plane. In a decision-control scenario, beliefs and policies declaratively guide critical execution choices such as model selection, retrieval, and corrective re-execution, enabling dynamic behavior without requiring any changes to the underlying pipeline code.

What carries the argument

Beliefs as explicit semantic state representations together with declarative policies defined over them inside a database-backed semantic control plane

If this is right

Critical execution choices such as model selection, retrieval, and corrective re-execution can be guided declaratively.
Dynamic adaptation occurs as new evidence updates beliefs and policies respond automatically.
Behavior becomes auditable because policies and the beliefs they act on are explicit and stored.
Execution is composable because policies can be added or combined without altering pipeline code.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

Persisting beliefs in a database could simplify state management for agents that run over long periods.
Explicit policies might support external review or compliance checks on how decisions are reached.
The belief-policy separation could be applied to other stateful systems that need to adapt without recoding core logic.

Load-bearing premise

That declarative policies defined over beliefs can effectively guide critical execution choices such as model selection and corrective re-execution in evolving conditions without any changes to the underlying pipeline code.

What would settle it

A scenario in which new evidence is added to the belief store yet the policy fails to trigger the expected execution change, such as switching models or initiating re-execution.

Figures

Figures reproduced from arXiv: 2604.14401 by Andrew Crotty, Duo Lu, U\u{g}ur \c{C}etintemel.

**Figure 2.** Figure 2: Users declare a logical pipeline, belief, and policy set through Credo APIs; the execution engine then adaptively [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗

**Figure 3.** Figure 3: Example beliefs and policies for FinanceBench. [PITH_FULL_IMAGE:figures/full_fig_p003_3.png] view at source ↗

**Figure 4.** Figure 4: The Credo Web Interface. The UI visualizes the live execution trace and adaptive behavior of the system. 1. Controls & DB View: Select benchmark questions and toggle the database view to inspect persistent semantic state. 2. Compiled Plan: Displays the initial physical plan and parameters resolved before execution. 3. Execution History: Tracks the step-by-step evolution of the plan, highlighting corrective… view at source ↗

read the original abstract

Agentic AI systems are becoming commonplace in domains that require long-lived, stateful decision-making in continuously evolving conditions. As such, correctness depends not only on the output of individual model calls, but also on how to best adapt when incorporating new evidence or revising prior conclusions. However, existing frameworks rely on imperative control loops, ephemeral memory, and prompt-embedded logic, making agent behavior opaque, brittle, and difficult to verify. This paper introduces Credo, which represents semantic state as beliefs and regulates behavior using declarative policies defined over these beliefs. This design supports adaptive, auditable, and composable execution through a database-backed semantic control plane. We showcase these concepts in a decision-control scenario, where beliefs and policies declaratively guide critical execution choices (e.g., model selection, retrieval, corrective re-execution), enabling dynamic behavior without requiring any changes to the underlying pipeline code.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit. Tearing a paper down is the easy half of reading it; the pith above is the substance, this is the friction.

Desk Editor's Note private letter to a colleague

Credo sketches a declarative beliefs-and-policies layer over a database for LLM pipelines but supplies no mechanism or evidence that it actually decouples control from pipeline code.

read the letter

The paper's main contribution is a proposal to treat semantic state as beliefs and to drive LLM pipeline decisions through declarative policies stored and queried via a database control plane. This is positioned as a way to get adaptive, auditable behavior without rewriting the underlying agent code for each new condition. The abstract correctly flags the opacity and brittleness of today's imperative loops and prompt-embedded logic, and the database-backed separation is a reasonable direction to explore for composability and audit trails. That framing is the part worth noting for anyone building long-running agents. The rest of the paper stays at the level of architecture description and a high-level showcase scenario. No policy syntax appears, no integration points with actual LLM calls are shown, and there are no measurements of whether the control plane can intercept or redirect execution at the needed granularity. The central claim that critical choices like model selection or corrective re-execution can be handled declaratively without any pipeline changes therefore remains untested. If the showcase still requires instrumentation inside the pipeline, the decoupling benefit does not materialize. The work is early-stage and conceptual. It is aimed at researchers thinking about agent architectures rather than practitioners who need a working system or reproducible results. A reader already familiar with database rule systems or declarative programming will see the idea as a straightforward transfer rather than a deep technical advance. The paper deserves a serious referee only if a revision adds a concrete policy language, a prototype implementation, and at least a small evaluation that checks whether the no-code-change property actually holds. Without those pieces it is better treated as an idea note than a finished submission.

Referee Report

2 major / 0 minor

Summary. The paper introduces Credo, a framework for controlling LLM pipelines declaratively. Semantic state is modeled as beliefs stored in a database, and behavior is governed by policies expressed declaratively over those beliefs. The design is claimed to yield adaptive, auditable, and composable execution via a database-backed semantic control plane. In a decision-control showcase, beliefs and policies are said to guide choices such as model selection, retrieval, and corrective re-execution, achieving dynamic adaptation without any modifications to the underlying pipeline code.

Significance. If the architecture can be realized with the claimed properties, it would offer a principled alternative to imperative control loops and prompt-embedded logic in agentic systems, potentially improving transparency and maintainability in long-lived, stateful applications. The separation of semantic state and control logic into a persistent, queryable plane is a conceptually clean approach that could aid auditing and composition.

major comments (2)

[Abstract] Abstract: The central claim that declarative policies over beliefs enable critical execution decisions (model selection, retrieval, corrective re-execution) in evolving conditions without requiring changes to the underlying pipeline code is asserted but unsupported by any description of integration mechanisms, interception points, policy syntax, or control-plane hooks. This decoupling property is load-bearing for the stated benefits.
[Abstract] Abstract / Showcase scenario: No implementation details, policy language definition, integration architecture, evaluation metrics, or empirical results are supplied to demonstrate that the claimed adaptivity and auditability are achieved. The soundness assessment rests entirely on the high-level design description.

Simulated Author's Rebuttal

2 responses · 0 unresolved

We thank the referee for their constructive review and for recognizing the potential of the Credo architecture. We address each major comment below with clarifications drawn from the manuscript and indicate planned revisions to strengthen the presentation.

read point-by-point responses

Referee: [Abstract] Abstract: The central claim that declarative policies over beliefs enable critical execution decisions (model selection, retrieval, corrective re-execution) in evolving conditions without requiring changes to the underlying pipeline code is asserted but unsupported by any description of integration mechanisms, interception points, policy syntax, or control-plane hooks. This decoupling property is load-bearing for the stated benefits.

Authors: We agree the abstract is high-level and could better signpost the supporting mechanisms. The full manuscript describes the database-backed control plane as the integration layer: the pipeline issues queries to the belief store at defined interception points (e.g., prior to model invocation or after retrieval), policies are evaluated declaratively against current beliefs to select actions such as model choice or re-execution, and behavior changes occur solely by updating stored policies without altering pipeline code. We will revise the abstract to include a concise reference to these hooks and the policy-evaluation process, and we will add an explicit example of policy syntax in the main text. revision: yes
Referee: [Abstract] Abstract / Showcase scenario: No implementation details, policy language definition, integration architecture, evaluation metrics, or empirical results are supplied to demonstrate that the claimed adaptivity and auditability are achieved. The soundness assessment rests entirely on the high-level design description.

Authors: The manuscript presents Credo as a conceptual framework illustrated by a decision-control showcase. We acknowledge that additional concrete details would improve substantiation. In revision we will expand the showcase section with (i) a definition and concrete examples of the declarative policy language, (ii) an architecture diagram showing integration points and data flow, and (iii) an explanation of auditability via persistent, queryable logs of belief updates and policy evaluations. Because the work is primarily architectural, we do not include large-scale quantitative benchmarks; we will add a qualitative analysis of the showcase together with a discussion of planned empirical evaluation. revision: partial

Circularity Check

0 steps flagged

No circularity: new abstractions proposed without derivation or self-referential reduction

full rationale

The paper is a systems design proposal introducing Credo as a new architecture with beliefs for semantic state and declarative policies over a database-backed control plane. No equations, fitted parameters, predictions, or first-principles derivations appear in the abstract or described content. Claims about adaptivity, auditability, and no pipeline code changes are properties asserted of the proposed design itself, not results derived from prior inputs or self-citations. The showcase scenario is presented as illustration rather than a statistical or mathematical reduction. This matches the default case of a non-circular architectural paper; the skeptic concerns address evidence strength, not circularity in any derivation chain.

Axiom & Free-Parameter Ledger

0 free parameters · 1 axioms · 2 invented entities

The framework rests on the assumption that semantic state can be usefully captured as beliefs and that declarative policies over them suffice for dynamic control; no free parameters or invented physical entities are introduced.

axioms (1)

domain assumption LLM outputs and intermediate results can be reliably interpreted and stored as semantic beliefs about world state
Invoked to enable the semantic control plane described in the abstract.

invented entities (2)

Beliefs no independent evidence
purpose: Represent semantic state for LLM pipeline control
Core new abstraction for state management in the proposed system.
Policies no independent evidence
purpose: Declarative rules to regulate execution choices based on beliefs
Central mechanism for adaptive behavior without code changes.

pith-pipeline@v0.9.0 · 5453 in / 1388 out tokens · 39200 ms · 2026-05-10T13:03:12.914415+00:00 · methodology

discussion (0)

Reference graph

Works this paper leans on

12 extracted references · 9 canonical work pages · 5 internal anchors

[1]

LangChain

2025. LangChain. https://www.langchain.com/

2025
[2]

Çetintemel et al

U. Çetintemel et al. 2026. Making Prompts First-Class Citizens for Adaptive LLM Pipelines. InCIDR. https://www.vldb.org/cidrdb/2026/making-prompts-first- class-citizens-for-adaptive-llm-pipelines.html

2026
[3]

Chain-of-

S. Dhuliawala et al. 2023. Chain-of-Verification Reduces Hallucination in Large Language Models. arXiv:2309.11495 [cs.CL] https://arxiv.org/abs/2309.11495

work page arXiv 2023
[4]

Financebench: A new benchmark for financial question answering.arXiv preprint arXiv:2311.11944, 2023

P. Islam et al. 2023. FinanceBench: A New Benchmark for Financial Question Answering. arXiv:2311.11944 [cs.CL]

work page arXiv 2023
[5]

Khattab et al

O. Khattab et al. 2024. DSPy: Compiling Declarative Language Model Calls into State-of-the-Art Pipelines. InICLR. OpenReview.net. https://openreview.net/ forum?id=sY5N0zY5Od

2024
[6]

Self-Refine: Iterative Refinement with Self-Feedback

A. Madaan et al . 2023. Self-Refine: Iterative Refinement with Self-Feedback. arXiv:2303.17651 [cs.CL] https://arxiv.org/abs/2303.17651

work page internal anchor Pith review arXiv 2023
[7]

RouteLLM: Learning to Route LLMs with Preference Data

I. Ong et al. 2025. RouteLLM: Learning to Route LLMs with Preference Data. arXiv:2406.18665 [cs.LG] https://arxiv.org/abs/2406.18665

work page internal anchor Pith review arXiv 2025
[8]

Patel et al

L. Patel et al. 2025. Semantic Operators and Their Optimization: Enabling LLM- Based Data Processing with Accuracy Guarantees in LOTUS.Proc. VLDB Endow. 18, 11 (2025), 4171–4184. doi:10.14778/3749646.3749685

work page doi:10.14778/3749646.3749685 2025
[9]

Shankar et al

S. Shankar et al. 2025. DocETL: Agentic Query Rewriting and Evaluation for Complex Document Processing.PVLDB18, 9 (2025), 3035–3048. doi:10.14778/ 3746405.3746426

work page arXiv 2025
[10]

AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation

Q. Wu et al. 2023. AutoGen: Enabling Next-Gen LLM Applications via Multi- Agent Conversation. arXiv:2308.08155 [cs.AI] https://arxiv.org/abs/2308.08155

work page internal anchor Pith review Pith/arXiv arXiv 2023
[11]

Corrective Retrieval Augmented Generation

S.-Q. Yan et al . 2024. Corrective Retrieval Augmented Generation. arXiv:2401.15884 [cs.CL] https://arxiv.org/abs/2401.15884

work page internal anchor Pith review arXiv 2024
[12]

ReAct: Synergizing Reasoning and Acting in Language Models

S. Yao et al. 2023. ReAct: Synergizing Reasoning and Acting in Language Models. arXiv:2210.03629 [cs.CL] https://arxiv.org/abs/2210.03629

work page internal anchor Pith review Pith/arXiv arXiv 2023