All articles
    asset-management
    query-planner
    runtime-contracts
    mission-runtime
    context-runtime
    governance
    tax-aware
    compliance
    physical-data-independence
    agentic-workflows
    quantify
    reference-implementation

    Why Agentic Asset-Management Workflows Need a Query-Planner Architecture

    September 3, 2026redevops.io
    Why Agentic Asset-Management Workflows Need a Query-Planner Architecture

    An asset-management workflow is a changing execution plan over data, evidence, models, tools, policy and actions.

    A portfolio workflow may begin with a market event, move through data retrieval and evidence construction, ask several agents to analyze different parts of the problem, reconcile their findings, and identify the affected portfolios and accounts. Only then does it cross portfolio, client, IPS, tax, regulatory, compliance, liquidity and authority boundaries, before an action is even viable. It may then require human approval, execute or simulate the action, ingest the resulting state, and preserve enough evidence and history to explain exactly what happened later.

    Here is the part worth saying first, because it is the whole point. The differentiated job of this system is turning a research signal into a portfolio-specific, tax-aware, compliant, authorized and explainable action, where the same conclusion about the same security becomes REDUCE for one account, HOLD for another and REPLACE for a third, or is refused outright, and where every one of those outcomes can be reconstructed months later with the evidence it stood on.

    The visible workflow looks like an investment terminal. Underneath, it looks increasingly like a database execution engine.

    An investment terminal on the surface; underneath, a query-execution engine: a mission compiled to a logical plan, then optimized across market data, retrievers, models, tools and agents into governed evidence and decisions.
    Scroll the diagram sideways to read itFull size
    Market / portfolio event
              │
              ▼
           Mission
              │
              ▼
         Logical Plan
              │
              ▼
           Optimizer
              │
       ┌──────┼───────────┬──────────┬──────────┐
       ▼      ▼           ▼          ▼          ▼
     market  filings    retrievers  models     tools
     data    / news      / stores    / agents   / APIs
       └──────┬───────────┴──────────┴──────────┘
              ▼
       Evidence + Decisions
              │
              ▼
     Authority / Verification
              │
              ▼
      Outcome / Replay / Audit
    

    That resemblance is the reason a planner-style runtime is the natural architecture for the job, and the reason the Asset Manager demo on Quantify.club is a demanding reference workload.

    Why this is more than an agent workflow

    In a real asset-management system, the same logical objective can be executed in many different ways.

    A research step might use structured market data, a filing, a news source, an internal research store, semantic retrieval, graph closure or an external model. A reasoning step might use a small local model for classification and a larger model only when interpretation is genuinely hard. A proposed portfolio action might be simulated, refused by policy, escalated for approval or passed to an execution system.

    Those are physical execution choices. The Mission should stay stable while the machinery underneath it changes: the same separation that makes a database query planner useful.

    What a planner structurally requires

    Three properties turn "a workflow with some agents in it" into something a planner can actually optimize.

    Physical independence. The logical Mission cannot depend on a particular database, retriever, model, agent framework or cloud service. "Assess this event and determine whether the portfolio requires action" has to mean the same thing tomorrow, after a market-data provider, a research source, a model vendor or an execution venue has been swapped underneath it, because for an asset manager, all of those will change independently.

    Substitutable operators. A planner chooses among capabilities without being coupled to their implementations, so retrievers, stores, models, tools and agents need neutral seams. The optimizer can then reason about the questions that matter (is the available context complete? which representation exposes the required dependency? is a small model sufficient, or does this step need a specialized one? is the proposed tool action authorized? should execution proceed, abstain or require approval? can an already-completed step be reused safely?) about the capability and its constraints, with the concrete class behind it left out.

    Portable, verifiable values. Asset-management decisions do not disappear when an agent process exits: a recommendation must refer to the same evidence when it is reviewed later, a replay must know which actions already happened, an auditor must be able to reconstruct why an action was admitted or refused. That requires stable value semantics in place of transient framework objects, and it is enough of a load-bearing idea to return to below.

    The contract is the planner boundary

    Those three properties need one thing in common: a boundary that fixes meaning while letting implementations vary. In ReDevOps that boundary is runtime-contracts.

    Mission · Evidence · Handle · Plan
    Authority · Decision · Outcome
                     │
             runtime-contracts
                     │
     canonical identity + operator seams
                     │
     ┌────────┬────────┬────────┬────────┬────────┐
     ▼        ▼        ▼        ▼        ▼        ▼
    stores retrievers models   tools   agents  runtimes
    

    With the shapes, seams and identities fixed, the Context Runtime can treat a retrieval engine, a graph traversal, a market-data adapter or a framework-native retriever as interchangeable capabilities; the Mission Runtime can preserve the identity and state of the complete investment workflow; Governance can reason about authority independently of whichever agent proposed an action; and Replay can reconstruct execution without repeating committed side effects. The pieces evolve without redefining the Mission.

    The interesting claim here is that some such boundary is structurally required, and most of the obvious alternatives fall short of it. A shared implementation library couples the optimizer to concrete implementations. Point-to-point integrations make every runtime learn every other component's API. A single storage abstraction ties logical semantics to one physical layer. Framework-native interfaces make the architecture depend on the framework. Transport schemas standardize messages but not identity and value semantics. Each is useful; none alone creates the physical-independence boundary a complete agentic workflow needs to be optimized.

    Why asset management is the sharpest case

    Asset management is an unusually strong fit for a planner-style runtime because the workflow is heterogeneous and bounded at every stage by changing portfolio, account, tax, regulatory, compliance, liquidity and human-authority constraints. The useful abstraction is a gauntlet in place of research → recommendation:

    A research signal enters and most candidate actions are filtered out as it passes constraint gates (portfolio, IPS, tax, wash-sale, concentration, liquidity, compliance and authority), leaving only the few actions that are actually viable.
    Scroll the diagram sideways to read itFull size
    market / research evidence
            ↓
    what changed?  →  which holdings / accounts are affected?
            ↓
    what actions are candidates?
            ↓
    portfolio + IPS + tax + regulatory + compliance
    + liquidity + authority boundaries
            ↓
    which actions are actually viable?
            ↓
    human approval  →  execution handoff  →  resulting state  →  monitoring
    

    Each stage is where a stable logical Mission earns its keep while the planner chooses the physical machinery to resolve it.

    Heterogeneous evidence. Market data, point-in-time fundamentals, filings, earnings, estimates, research factors, news, corporate actions, portfolio state, tax lots, client restrictions and internal research all have different structures, identities, freshness and access methods. The runtime should choose among SQL, semantic retrieval, graph/closure traversal and APIs without changing the logical objective.

    Portfolio and account boundaries. A research conclusion is not yet an actionable recommendation. The same finding implies different actions for different portfolios, because holdings, concentration, benchmark exposure, mandate, household state and client objectives differ.

    same research conclusion
            │
       ┌────┼──────────────┐
       ▼    ▼              ▼
    Fund A  Taxable HNW   Restricted account
    REDUCE  HOLD          REPLACE
    

    The planner has to carry portfolio state into the decision before an agent produces an answer.

    Tax boundaries. A candidate trade can be economically attractive and still be the wrong action for a particular account because of tax-lot state, realized gain/loss, holding period or wash-sale constraints. Tax-loss harvesting is therefore part of the execution plan: loss detected → harvest candidate → replacement search → wash-sale / lot / account checks → portfolio-impact check → viable proposal or abstain. The AI may interpret and rank alternatives; authoritative tax calculations and hard eligibility boundaries stay deterministic.

    Regulatory, compliance and mandate boundaries. Actions are also constrained by regulatory rules, firm policy, IPS mandates, restricted securities, concentration limits, liquidity requirements, ESG restrictions, employer-stock rules, lockups and account eligibility. This changes the role of the agent: the agent proposes; the runtime determines whether the proposal is admissible. A fluent model answer cannot override a deterministic hard boundary.

    Human-authority boundaries. A system can have enough evidence to recommend an action without having the authority to execute it. Research authority, recommendation authority, approval authority and execution authority are different things, and that distinction has to survive delegation across agents and tools, so the runtime carries authority as part of Mission semantics, independent of whichever framework happens to invoke the next tool.

    Changing context. A new filing, price, corporate action, portfolio change, client restriction or policy update can invalidate only part of an earlier conclusion. A planner-style runtime identifies the affected dependency closure, recomputes the relevant portion, and preserves unaffected work inside the existing conversation.

    Expensive, irreversible side effects. An order, an approval, an external notification or a state-changing API call cannot be repeated because a worker restarted. Durable Mission identity, idempotency, verification and replay are execution requirements here, separate from observability features.

    Point-in-time correctness. Investment decisions are temporal: the system must reconstruct what evidence and portfolio state were known at the time of the decision, not accidentally use future information during replay or audit. The institutional record has to preserve the full lineage from source evidence through point-in-time metrics, conclusion, affected account, constraints, alternatives, proposal, approval, execution and subsequent outcome.

    One more boundary is really the same physical-independence point wearing operational clothes: the runtime should not become the custodian, accounting system or OMS. Authoritative state stays in CRM, portfolio, compliance, custody and execution systems; adapters normalize them into canonical portfolio, client, security, restriction and execution objects, so the investment workflow does not have to be rewritten because the firm swaps an incumbent system underneath it.

    Plans and evidence outlive the process

    A sealed, content-addressed record persisting on durable ground while worker processes spin up and exit above it: the same Mission planned in one language, executed, audited and replayed in others, its meaning unchanged.
    Scroll the diagram sideways to read itFull size

    This is where contracts stop looking like API hygiene and become part of the execution architecture. A Mission may be planned in one language now and executed, resumed, audited or replayed in another later:

    Python planner
          │
          ▼
     canonical Mission / Plan / Evidence
          │
     ┌────┼─────────┐
     ▼    ▼         ▼
    Go   JVM      Python
    exec audit    replay
    

    The implementation can change. The value cannot silently change meaning. That is exactly what canonical serialization, content-addressed identity and explicit compatibility rules buy: a workflow that stays portable, comparable and verifiable across the process that happened to create it.

    The database analogy is structural

    A database query planner is valuable because it can change physical execution while preserving the logical query. An agentic runtime needs the same property. For asset management, that means the workflow can evolve across new data providers, retrieval methods, models, agent frameworks, tools, clouds and implementation languages without rebuilding the semantics of the investment process around every change. The same stable Mission keeps expressing portfolio state, tax and compliance constraints, authority, evidence and intended outcome even as the physical operators used to satisfy them change.

    The contract fixes the shapes, operator seams and identities. The planner decides how to execute. The runtimes preserve context, Mission state, authority, verification and replay. And the application remains the application.

    The contract is the physical-data-independence boundary that makes the planner possible at all.


    See it running: Quantify.club → Asset Manager

    The reference demo puts the investment workflow on one side and the runtime underneath it on the other: evidence arriving, agents working, context being assembled, decisions admitted or refused, Mission state advancing, and execution staying replayable and governed. Open the Asset Manager demo →


    #AgenticAI #AssetManagement #WealthTech #FinTech #QueryPlanner #MissionRuntime #ContextRuntime #AIGovernance #TaxAware #Compliance #AgenticWorkflows #AIInfrastructure #LLMOps #PhysicalDataIndependence #AIEngineering #GenAI

    Want ReDevOps in your Google Top Stories & AI results?Follow ReDevOps on Google