Research question
How can developers use a cheaper execution window while retaining control over decisions an agent makes in their absence?
Method
The study examines an archived prototype and two de-identified engineering traces, using 34 targeted offline regression checks, a queue replay and deterministic pricing scenarios. The prototype connects a planning brief and scoped delegation to a canvas of decisions and module versions.
Key findings
- Targeted offline checks
- 34
- De-identified engineering traces
- 2
- Estimated reduction in one completed trace
- 16.5%
- In one completed trace, halving execution rates reduced the two-phase cost estimate by 16.5%, with token usage and peak-priced planning held fixed.
- The queue replay showed how a flexible high-priority task can consume the only affordable slot for a later task. An earlier placement can accommodate both at a higher forecast cost.
Limitations
Cost results are conditional estimates from archived usage and assumed prices. They do not measure provider bills, user outcomes or production scheduling performance.
Full manuscript
Web reading edition of the submitted manuscript, including text, original figures, tables and references.
Abstract
Time-based model prices create a choice for developers who delegate work to coding agents. A cheaper execution window can occur when the task owner is unavailable to resolve ambiguity. This design-science study examines how a desktop prototype connects inference prices, scoped delegation and a persistent canvas of decisions and module versions. Evidence consists of two de-identified engineering traces, inspection of the archived implementation, 34 targeted offline regression checks, a queue replay and deterministic cost scenarios. In one completed trace, halving execution rates while keeping usage and peak-priced planning fixed reduces the two-phase estimate by 16.5%. A boundary scenario identifies error from using a single rate for mixed-tariff usage. In the queue replay a flexible high-priority task claims the only affordable slot for a later task, even though an earlier placement can accommodate both at a higher total forecast cost. The artifact links cost assumptions, delegated decisions and reviewable versions. The paper specifies testable propositions for verifying handoff, authorisation and revision outcomes with users. The estimates are conditional repricings and no provider invoices or participant outcomes are analysed.
Keywords Token pricing, coding agents, asynchronous delegation, design science, version provenance
Introduction
A developer who wants a coding agent to work at a lower inference rate faces a timing problem. They can explain the task and decide how much to spend while they are at the computer. The discounted window may open after they leave. During execution the agent may encounter a design choice, an unmet dependency or a change that needs permission. A written brief helps the agent proceed, but it cannot settle every question in advance. Waiting for the developer preserves control and can consume the discount window. Proceeding on an assumption can produce work the developer later has to revise.
The case is a desktop coding-agent prototype developed around this tension. Its documented workflow allows the user to discuss requirements, generate a development brief and review model, budget and timing estimates before execution. It also represents work on a canvas where users can return to saved outputs, request a new branch and choose module versions for combination. A demonstration canvas offers a way to learn the workflow without an API credential or paid inference. The design brief prioritises a simple entry point and a record of the work that a user can inspect after returning to the computer. These objectives motivate a later evaluation of onboarding and review. The present study examines archived mechanisms and their accounting consequences.
This paper asks how a coding-agent information system can reduce exposure to time-varying token prices while preserving the task owner's ability to direct and revise the work. It contributes an accounting model for the planning and execution phases, a mechanism that ties delegated decisions to saved work, and an artificial evaluation of tariff attribution, stop thresholds and the scheduling consequences of a shared execution slot. The unit of analysis is a coding task and the decisions and versions associated with it. The analysis concerns metered model inference, with token categories and rates specific to a provider and model.
Related Work
Inference Costs and Units of Work
FrugalGPT studies how choosing among models and using cascades can reduce the cost of answering requests subject to a performance objective (Chen et al., 2024). RouteLLM likewise evaluates routing requests between stronger and weaker models (Ong et al., 2025). These studies motivate model choice as an economic decision. A coding task has an additional unit-of-analysis problem. It often contains several requests, tool interactions and verification steps. A model that is inexpensive per token can incur more work if it repeatedly misses acceptance criteria or requires rework. Selecting a model for this setting therefore requires a cost estimate and evidence of its suitability for the type of task.
Provider accounting gives some inputs for that decision. DeepSeek documents different prices for cache-hit input, cache-miss input and output and distinguishes peak and off-peak prices in its published rate card (DeepSeek, n.d.-b). Its cache documentation describes reuse of overlapping prompt prefixes (DeepSeek, n.d.-a). Cache reuse depends on the request and provider implementation. A planning model can expose assumptions about reuse, but a forecasted cache hit remains uncertain until usage is returned. The FinOps Foundation (n.d.) describes the progression from infrastructure quantities to outcome-based unit economics. Here the practical denominator is a verified task or module outcome. A completion label, by itself, supplies a weaker denominator because it can coexist with incomplete acceptance evidence.
Delegation and Traceability
Parasuraman et al. (2000) distinguish stages of automation such as information analysis, decision selection and action implementation. That distinction matters for unattended development. The system may identify an ambiguity, offer options and pause for authorisation, even when it can technically implement one of the options. Lee and See (2004) relate reliance on automation to the context and the information available about its operation. For the prototype, a later reviewer needs to know whether a decision followed an explicit answer, a bounded discretion rule or a newly approved request. A list of completed steps supplies activity information. The links between a decision, its grounds and the resulting artifact supply the context needed to review that activity.
The W3C provenance model distinguishes entities, activities and agents, allowing a record to describe how an artifact was produced or derived (Moreau & Missier, 2013). This paper uses that distinction as an analytical vocabulary. A module version is an artifact, a coding or verification step is an activity, and the agent or user is an actor in the decision. Recording these relations matters once a user combines versions from different branches. A timestamp can tell the user when changes were recorded. A dependency record and verification result tell the user whether those changes can be used together.
Time-Shifted Delegation as an Information Systems Problem
Baird and Maruping (2021) place delegation to and from agentic artifacts at the centre of how information systems are used. Their perspective is relevant to a coding agent that both receives a task and returns unresolved choices to the person who assigned it. When a human and agent work concurrently, the human can supervise by answering successive questions. A price-sensitive scheduler can move the agent's work beyond that shared time. The same technical ability to return a question then has a different organisational consequence. A person who is unavailable until the next morning cannot provide input before the tariff changes, even if they can answer it easily once they return. The delegation record makes this availability gap explicit by identifying what the user has delegated before departure, what the agent referred back, and which effects can be corrected afterwards.
Doolin et al. (2025) show that automation and augmentation can change roles as an implementation proceeds through different stages. A corresponding distinction applies at the scale of one development task. Preparing a brief augments the user's specification work. Processing already authorised edits automates part of implementation. Returning an unresolved choice or presenting versions for combination restores direct human decision-making. These stages can recur within one task. The canvas matters here as a shared record across changes in participation. In its absence, the user may need to infer from a stream of messages which of their prior instructions actually governed a module and whether a later reply altered the original plan.
Bandara et al. (2025) describe process autonomisation as an organisational design question involving decisions based on changing conditions. A coding system may have more than one place to exercise that capability. The scheduler chooses a time from prices, deadlines and reservations. An execution agent may select a reversible implementation option. A later integration procedure may determine whether two versions can be combined automatically. Authority to choose a start time does not determine authority at either of the other two stages. Explicit records of who authorised a scope, whether a question was escalated and which versions were integrated connect the runtime mechanisms to familiar IS concerns about accountability and adaptation. This division also makes the design testable through separate evidence for scheduling, delegation and post-run intervention.
An information system operated by a solo developer has one person who generally sets objectives, owns the budget and reviews the output. In a team these roles can be distributed. A product owner might accept a revised behaviour while an engineer approves an integration and a different budget owner accepts a more expensive model. The current prototype evidence concerns the single-task-owner setting. Its design vocabulary can describe a multi-role handoff, but access controls, delegation of organisational authority and integration into a team review procedure would need further design. The distinction sets an application boundary for interpreting the findings and avoids treating technical scheduling permission as organisational decision authority.
Mixed Initiative Across a Period of Absence
Mixed-initiative interaction asks when initiative should pass between a person and an automated service and how the person can direct the service's subsequent behaviour. Horvitz (1999) relates the choice to act or ask to the costs of uncertainty, interruption and an incorrect action. Amershi et al. (2019) identify correction and control as recurring concerns over the lifetime of an AI interaction. In an asynchronous coding run, the opportunity to ask is itself time-dependent. The request may be generated at 02:00, when a prompt shown on the desktop cannot receive a timely answer, and the useful correction may arrive at 09:00, when the execution price or deadline has changed. The relevant interface extends from the conversation before the run to the artifacts available afterwards.
The design treats three acts as distinct. A person can express a preference, authorise execution under specified conditions and accept a resulting artifact. The preference informs the brief. Authorisation permits a defined action under a budget and version of the requirements. Acceptance is a judgement about the output and its evidence. A developer who says that a familiar library is preferred has supplied a preference. The same developer can authorise the use of a particular version under a recorded policy. Later acceptance still depends on whether the code behaves as specified. Treating each act as a durable record makes the distinction actionable when the developer was absent for most of the run. It also prevents the economic decision to wait for a cheaper rate from silently changing who can approve work.
Timing changes the value of a decision interface. At planning time, the interface can elicit decisions that are expensive to reverse, such as a data contract, and defer details that can be changed locally. During execution, the useful question is whether the encountered condition is covered by a confirmed answer or requires fresh authority. After the run, the useful question is what changed, under which instruction and with what effect on dependent work. These questions concern the same task state. Connecting the three moments makes it possible to analyse when the system exercised discretion and how much effort the user subsequently spent reviewing or revising it.
Kery and Myers (2018) investigated how to retrieve and compare the version histories of code and outputs in exploratory notebooks. That work supports treating the selection and retrieval of relevant history as an interaction problem in its own right. For overnight agent work, the record is heterogeneous in a further respect. It combines developer instructions, agent decisions, file snapshots, approval events, test observations and price estimates. A useful history makes these relations explicit at review time. A changed file may be easy to locate while the basis for changing it is still unclear. Conversely, a clear decision summary gives the user limited control if the corresponding files or affected versions cannot be recovered.
Evaluation Strategy
Design science in information systems connects an artifact to a consequential problem and evaluates the artifact against its proposed purpose (Hevner et al., 2004). Venable et al. (2016) distinguish artificial evaluation from evaluation in a natural setting. The study uses an artificial evaluation for the accounting and scheduling questions, accompanied by a bounded inspection of existing prototype records. This permits exact counterfactual calculations. User effort, uptake and the consequences of different delegation policies require evidence from natural use.
Artifact and Design Requirements
From Forecast to Editable Output
The first design requirement is that the user can form and revise a plan before committing to unattended work. The proposed workflow begins with a short brief, a simulated discussion of likely implementation questions and a development document. The discussion can identify preferred libraries, acceptable design alternatives and test expectations while the user is available. The approval step makes the objective, work boundaries and budget inspectable before dispatch. At dispatch the proposed workflow sends the confirmed development document and scoped answers as the initial execution brief. It can send subsequent tool requests or clarification responses during the run. Planning can incur model charges at peak prices. Those charges belong in the task account even if the task is cancelled before implementation begins.
The second requirement is a recommendation the user can inspect. For each supported model the estimate should show forecast input, assumed cache-hit share, forecast output, a priced execution window and the assumed deadline. Model suitability should be assessed against relevant acceptance criteria and prior benchmark evidence where available. A comparison can show a price difference without inferring that the models produce equally usable code. Where expected token use is unknown, the interface can expose a low and high scenario, state their assumptions and ask the user to confirm a budget for the execution phase.
The prototype’s inspected scheduler uses a single worker. It sorts queued tasks by priority, deadline and creation time and evaluates starts at the initial feasible time and subsequent quarter-hour boundaries. It accounts for reserved intervals and a configured execution window. The cost-oriented strategy chooses among affordable candidates using estimated API and local electricity cost. The early-start strategy prioritises an affordable start. The API cost is the subject of this paper. The local power term is an estimate from a power setting and electricity tariff, which has a different evidence basis from a provider invoice.

Figure 1. Proposed workflow linking time-based inference prices to delegated execution and review of saved module versions.
Figure 1 links the approved brief and forecast with unattended execution and later review.
Planning Decisions and Dispatch Records
The archived preview represents the initial request and generated plan as separate nodes. Each generated module has a title, brief, acceptance criteria and references to earlier modules on which it depends. The validator permits one to eight initial modules, requires unique module keys and rejects a dependency on an undefined or later module. Ordering references in this way ensures that the initial plan can be traversed without a cycle. It leaves a separate question for the user's plan review. A syntactically valid dependency graph can still omit a domain dependency or assign the same concern to two modules. The development document gives the user a place to review that decomposition before the first execution charge.
The archived preview estimates input and output from the count of initial modules plus one integration run. The default scenario allocates 30,000 input and 6,000 output tokens to each unit, with no cache-hit credit in the forecast. The app permits the user to adjust the total forecast. A three-module plan therefore starts from 120,000 input and 24,000 output tokens before adjustment. The initial execution budget is divided evenly among the modules and the integration run. This allocation has the virtue of predictability, but one module may require several tests while another modifies only a style sheet. A useful extension would let the user allocate more budget to a module with greater uncertainty or a higher downstream cost, while retaining the original total and recording any later changes. Comparing even and workload-sensitive allocations is an empirical question. An evaluation would count both unused authorisation and tasks halted for insufficient allocation.
The dispatch representation makes a module executable within the developer's project brief and task constraints. In the archived canvas, the agent receives the project objective and the current module instruction. The planned task also carries module acceptance criteria and an instruction to reuse completed dependencies. The inputs can include a snapshot constructed from the module's prerequisites. A planned extension would make the approved task package explicitly inspectable as a versioned unit containing a brief revision, permitted actions, a deadline, a model and a forecast. When a requirement changes before a module starts, the revised instruction can then be compared with the authorised package. Where a change expands scope, alters a protected interface or requires additional spend, the system can surface the revised package for approval. This proposal goes beyond the current practice of recording the module brief and execution options.
One boundary condition is a conflict between a new instruction and an existing acceptance criterion. The archived prompt instructs the agent to follow the new module instruction when it conflicts with the old criterion and to record the reason. That behaviour is convenient during exploration, but it creates a distinction between editing a brief and approving a change to the testable commitment. A proposed versioning rule would retain both criteria, mark the older one as superseded for the new version and link the change to a user action. The review can then distinguish a deliberate revision from an output that failed to satisfy an unchanged criterion. This is especially relevant when selecting versions whose tests were written under different requirements.
Delegated Replies and Pauses
The archived service exposes a narrow mechanism for answering clarification requests. It compares the trimmed wording of each question with the stored user-confirmed wording. Every question in a request must have a match before the request receives an automatic answer. A question marked as secret blocks the automatic path. Confirmed question-answer pairs are task-service records. The canvas preserves messages and offers an explicit path for applying a suggestion to the work. Reusing an answer or granting permission requires a separate user action.
This rule is conservative about paraphrase. The same intended clarification written with different wording may pause a run. In a period of absence, that can defer the affected module until the owner returns. A less restrictive system could associate an answer with a validated decision identifier and an explicit context, such as a module family and version of the brief. The identifier would establish what question the answer is intended to cover. Its context would limit where it can be reused. A semantic match from the model could suggest a rule to the user during planning, while the authority to apply the rule during execution would come from the confirmed record. This alternative is a design proposal. The archived implementation uses text matching.
The proposed rule record includes the affected module, the question or decision class, the allowed response, the version of the instruction under which the rule was approved, and its expiry condition. For example, a developer may authorise the system to choose a label from a short list for a local display module. That authorisation would expire on revision of the display specification. A change to the meaning of a value passed to another module would require its own authorisation. The execution record would show the encountered question, the matching rule, the selected value and the resulting node. If two rules appear to apply but yield different answers, the record should present the conflict for resolution before using either answer.
A clarification differs from a permission request. A clarification resolves uncertainty about the intended output. A permission request concerns whether an action may be taken. At task level the archived service has separate paths for recognised approval requests and confirmed question answers. A clear suggestion for a new package, a change to the budget or an external publication action is still a request. In the proposed design, the interface could expose a decision status of confirmed answer, recorded discretion or waiting for authority. A recorded discretion entry describes a local implementation choice that was within the approved brief. It can be inspected and revised later. An authority-dependent action remains pending until the relevant person decides. That distinction supplies a basis for analysing unauthorised execution separately from user dissatisfaction with an authorised, reversible choice.
The scheduler in the preview uses a local worker and can hold its current task in a waiting state. In this case one unanswered question can occupy the only execution slot, even if another module has no logical dependency on the answer. The potential benefit of continuing independent work is therefore architectural as well as visual. One proposed extension is to checkpoint the waiting module, release its worker and leave the next independent module eligible within its confirmed scope. Resumption would check that the input snapshot and approval context are still current. If its dependencies changed while it waited, the paused module would need a revised input or explicit confirmation of the older version. Any assessment of throughput should distinguish the current single-worker behaviour from this proposed extension.
Reviewing Milestones, Versions and Evidence
The preview stores chronological canvas events along with graph relationships among nodes. The timeline is an index to events such as the start of a plan, saving an artifact, creating a branch and producing a combination. The graph shows relations that time alone cannot supply. In particular, a version derived from an earlier node and a composition using several selected versions express different relationships. When a user selects a timeline event, its attached version can act as an entry point into the relevant part of the graph. Displaying the entire graph by default could make a large history harder to scan. An economical default view can present the most recent saved artifact, the first unresolved decision and work that has completed since the last visit, with dependencies and earlier alternatives available on demand.
The backend captures source and working files as content-addressed snapshots. A completed or interrupted node can retain a snapshot of the work available at that point. For an interrupted node, the files preserve partial progress and the interface continues to show the interruption. The archive separates status, review and verification fields. A node can be completed and awaiting review, with verification recorded as unrun. The review action can mark the version as retained without changing its snapshot. A proposed summary of readiness would preserve all three dimensions in plain language, for example by showing that a version was saved, that selected checks passed, and that acceptance is still pending. Keeping those observations distinct avoids interpreting a finished process as a finished feature.
The module result format in the archive includes a summary, implementation decisions with reasons, unresolved questions and declared test commands. A verification status can be derived from observed command records associated with those declared commands. A failed command and an unavailable command record provide different evidence. Success applies to the observed checks and their conditions. In the guided example the integration check confirms file presence only, and the implementation labels it as a structural check. A useful extension would attach each declared acceptance criterion to the check or review that addresses it. The user could then distinguish direct evidence from an unverified assertion in the agent's prose.
A finished module can be branched from its saved files. In the inspected canvas the branch receives a new version within the same module family, points to its source and inherits dependency references. The earlier snapshot remains selectable. The preview also supports amending the brief for a module that has yet to begin and saving conversation messages scoped to a selected node. During execution these mechanisms allow a user to express a new requirement and route it to a pending module or a subsequent branch. These controls apply at module boundaries. In the proposed control design a running node presents the safe points at which an instruction can be applied, with the affected work and potential re-verification visible before confirmation.
A composition selects at most one version per module family. The backend resolves the required dependencies and applies the changes from the selected snapshots relative to their baselines. It records conflicting files when a conservative merge cannot resolve their edits. Two edits to different files can both apply and still violate an interface contract. A user can therefore encounter a conflict in the file assembly stage or a failure in the resulting behaviour. The combination is saved as a distinct node with its selected inputs and verification outcome. By retaining the composition record alongside the source versions, the workspace allows users to repeat a successful selection or revise one module without losing the earlier outcome.
Illustrative Walkthrough of Return and Revision
The following constructed scenario illustrates the design and is distinct from the observed engineering traces. A developer plans a local task list with three modules. The first defines the task representation, the second presents the list and input form, and the third stores tasks across restarts. The display and storage modules depend on the representation. The developer requests local storage, specifies that task identifiers remain stable after reopening the application and asks for a check that adds an item, closes the app and reopens it. During planning, the developer approves an existing naming preference for the display while requiring approval for a change to the data format. The chosen schedule places initial execution in a cheaper window and commits a budget for those three modules and their initial integration.
Suppose the storage module discovers that old records lack identifiers. A new migration could modify data beyond the agreed task. The proposed system records the question, links it to the storage version and explains why no approved decision covers it. In the current single-worker architecture a pause may also hold the queue. With a checkpoint-and-release design, work on the display can continue once its required representation version has completed. The display's choices, outputs and checks can be saved while the persistence criterion remains open. The morning view would show a blocked storage version, a saved display version and the untested end-to-end criterion. This outcome leaves the completed display available for review at the deadline.
On return the developer adds an idea for a compact display and wants to preserve the earlier layout as a fallback. The developer opens the display checkpoint, confirms a branch and budgets the changes separately. If the new display still uses the same representation contract, it can be selected alongside the earlier representation and a later storage version once the migration question has been answered. The composition must then run the reopen check under the chosen set of versions. If that check fails, the failed combination is kept with its result. The developer can inspect the evidence, reuse the earlier layout or authorise further work. The design gives each revision a place in both the version record and the cost account, so the economic comparison can include extra inference attributable to unresolved or revised decisions.

Figure 2. Illustrative module lineage and selection after a deferred run. R1 supplies the task representation, D2 and S2 are later display and storage versions, and C1 records the selected combination and its planned integration check.
Figure 2 shows the version alternatives and the links required to recover the selected combination. This example also shows how a review design can make delays legible. The system can explain that a confirmed local choice was made automatically, a migration choice was left pending and the display revision was introduced after the developer returned. Each event has a different origin. If the developer ultimately spends more time reviewing this task than a comparable interactive run, that additional effort belongs in the assessment of deferral. A graph with many saved artifacts offers opportunity for reuse and may also increase selection effort. The test is whether a user can locate and act on the relevant evidence in the time available.
Method
Sources and Scope
The analysis inspected the desktop prototype’s preview instructions, the archived scheduler, rate parser and service code, a local validation database and the frozen DeepSeek price snapshot stored with the prototype. The code archive and preview documentation are separate sources. Features described in documentation are identified as documented behaviour, and exact accounting and approval statements are based on inspected code paths. The study did not run a new agent session against an external API. The examined validation database contains three task records. Two contain usable input, cached-input and output totals for planning and execution. The third is a failed record with no comparable phase counts and is retained in the case inventory without imputation.
The two usable records are assigned neutral identifiers A and B. A is interrupted and B is completed according to the task state. Both records name the same model and select the earliest-start strategy. The records establish engineering usage observations and do not establish independent end-user behaviour. The analysis extracts counts and states only. The research dataset includes de-identified phase totals, run states and counts of approval transitions. It excludes prompts, code changes, original task identifiers, machine identifiers and personal information. The rate snapshot was refreshed on 19 October 2026 at 16:44 China Standard Time. It is a retained engineering rate card for repricing. Any live rate or timing rule should be checked for the particular billing account and date.
Accounting Model
For model m and tariff window w, let I be total input tokens, H cached-input tokens with 0 ≤ H ≤ I, and O output tokens. Let pU, pH and pO be the rates per million uncached input, cached input and output tokens. The charge estimate for a usage increment is
C(m,w) = [(I − H) × pU(m,w) + H × pH(m,w) + O × pO(m,w)] / 1,000,000.
The formula counts cached input once at its designated rate. It does not add reasoning tokens a second time when the provider's output total already includes them. The rate model is appropriate for the three categories in this snapshot. Other providers can expose additional categories such as cache writes or separately priced tools. An implementation needs an explicit mapping between provider counters and billing categories.
The estimated cost of a task is the sum of its planning and execution increments, plus any additional phases included in the boundary of the analysis. A subsequent metered request to revise a saved module creates another cost-bearing phase. Under a shared peak-to-valley discount factor d and unchanged execution usage, the fraction of total initial spend avoided by shifting only execution is (1 − d)E/(P + E), where P is planning spend and E is the peak-priced execution spend. This expression explains why a 50% rate discount may have a much smaller effect on the complete task. It also keeps a decision to wait separate from a decision to change models.
For cost-oriented scheduling, a candidate is feasible when it fits the deadline, worker availability and configured time window, and its estimated API cost is within budget. The archive’s earliest-start strategy uses worker availability, deadline and earliest-start constraints and does not impose the cost-oriented window. Among feasible starts, the user can prefer the earliest start or the lowest estimated cost. A useful extension is a delay valuation. If the deferred start is Δ hours later and estimated inference savings are S, the break-even value of one hour of delay is S/Δ. This calculation becomes relevant when code changes block a daytime review or when a pending question is likely to prevent overnight completion.
Counterfactuals and Stop Behaviour
Trace counterfactuals hold token counts and model fixed. The baseline prices both phases at the archived peak rate. The deferred scenario retains peak-priced planning and reprices the execution phase at the archived valley rate. These counterfactuals isolate the price effect. Cache behaviour, total work and model output may change with time or execution conditions in a deployed system.
A separate synthetic workload isolates attribution at a rate boundary. It uses 100,000 input tokens, 50,000 cached-input tokens and 10,000 output tokens, distributed equally across two halves in the mixed case. The worked example compares peak-only, half-peak/half-valley and valley-only accounting, and tests what happens if all tokens are assigned the rate in force at task start. A second analytical example compares a reactive stop threshold with pre-authorisation of a bounded increment. These scenarios are deterministic and can be reproduced with Appendix A.
Evidence Classes and Coding Procedure
The sources answer different questions about the artifact. A feature description establishes its intended user-facing behaviour. A source path establishes the rule implemented in the inspected archive. A stored task establishes that the application retained particular counters and states. A repeatable fixture test establishes that a specific input and assertion succeed in the inspected archive and test environment. An analytical scenario establishes what follows from stipulated quantities. These evidentiary levels are kept distinct because they have different implications for claims about feasibility and value. In particular, a successful scheduling test cannot establish an accounting outcome on a provider statement, and a locally stored completion state cannot establish independent acceptance of the code.
The case inventory uses the task as the inclusion unit. A trace qualifies for the quantitative phase comparison when a recognisable planning and execution phase is present, all three required token counters are available for each phase and the cache count lies within total input. A task with planning-only evidence would qualify for a study of planning cost but would not enter a paired phase comparison. An interrupted task can qualify when usage has been preserved, provided that its outcome remains visible. The failed record is described separately. Treating its unrecorded usage as zero would combine missing evidence with an observed zero and artificially lower any aggregate. The study uses enumeration and case-specific comparisons because the three records do not support a meaningful estimate of variation across tasks, users or providers.
For each included phase, cached input is subtracted from total input before repricing. The resulting three components are multiplied by fixed prices, and their unrounded sum is retained until reported. The planning observation may reflect multiple exchanges associated with a brief. The execution observation represents the retained aggregate for the recorded task state. These are retrospective quantities. They differ from forecast quantities available at planning and from any charge that might appear later on a provider statement. The paper reports rates and calculations at enough precision for independent checks and rounds only displayed monetary results. No conversion into a second currency is performed.
The available tasks share a model and original scheduling strategy. That commonality removes a between-model difference from the historical comparison, but it does not supply experimental control. Planning and execution had different purposes and could have different context, output length or reuse. Comparing phase shares is informative about the observed distribution of measured work. Differences in those shares across A and B are compatible with differences in task requirements, stopping behaviour or prompt reuse. Those differences cannot be isolated with the available records.
The source inspection followed a task from plan generation through confirmation, queue selection and usage updates to its terminal report. For each step, the analysis identified the source of the quantities used in the next decision. Forecasting spreads an estimated count over the reserved interval. A live budget check uses the latest cumulative counters available to the task. A completion report uses the pricing selected for the run, including a start-time lookup for the inspected provider path. This mapping identifies where disagreement can arise even with a correctly implemented arithmetic formula. It also distinguishes a stop request issued by the application from cessation of metered inference at the provider.
Offline Regression Checks
To complement code reading, the study reran nine targeted scheduling checks from the archive in a local Python environment. The checks use a frozen price fixture, temporary state or service fixtures, and do not contact a model endpoint. They cover three groups of behaviours. The calculation checks verify that per-task usage and cache assumptions affect the estimate and that a forecast spanning two rates combines them. The admission checks verify a later affordable start, absence of a start when the budget is insufficient, and handling of an invalid estimate or unavailable rate. The state checks exercise a non-mutating preview, confirmation after a change in rates, a due task that loses its quote, and transitions for queued and running tasks. All nine checks passed in this rerun.
One fixture starts at 11:30 in the scheduler's fixture time zone, reserves an hour and crosses the fixture's 12:00 tariff change. The forecast is CNY 0.21, the average of the fixture's whole-run peak estimate of CNY 0.28 and valley estimate of CNY 0.14. This result establishes that the scheduler weights the two intervals as designed for a uniform forecast. It is separate from the CNY 0.1365 example below, which uses a different cache assumption and a different purpose. The fixture checks a forecast. The analytical example quantifies what happens when a subsequent charge estimate ignores part of the usage distribution.
A second fixture illustrates why budget and tariff source belong in the same admission decision. With all hours available and a CNY 0.15 budget, the queue can select 12:00 at an API estimate of CNY 0.14. At CNY 0.01, no candidate in the scenario is affordable and no start is returned. Another fixture removes the previously available quote before a due task starts and observes that the task remains queued. These checks document implementation behaviour under repeatable inputs. They provide no evidence about live quote availability or the time that users would agree to wait.
The study also reran 19 targeted tests for canvas state, snapshots, review and estimation, and six tests for discussion behaviour. These tests use isolated state, mocked external model calls where applicable and demo fixtures. Three packaging tests are outside the present analytical scope. All 25 targeted checks passed. The checks exercised persisted node positions and selections, version branching and composition, conflict handling, saved decisions, dependency validation, pause and restart, and read-only discussion with separately accounted usage. Examples of evidence include rejection of a cycle, retention of source versions after a composition, and suppression of automatic restart. Their scope is conformance to the tested fixture and assertion. In particular, the scripted demo does not provide evidence for model code quality or the review time saved by a user.
Outcome and Cost Boundaries
Three nested boundaries are useful in reporting an asynchronous task. The inference boundary includes recorded planning, execution and any metered follow-up. The task boundary adds timing and verification, since a task completed after the required review window or missing its acceptance tests has a different outcome from an accepted task. The organisational boundary can include electricity, developer attention, opportunity cost, and use of shared infrastructure. This study computes the first boundary with the archived tariff and describes the other boundaries as part of the future evaluation. Mixing them in a single currency estimate without measured inputs would obscure the quantity supported by the available evidence.
For a task with recorded planning cost P, execution estimate E(w) and subsequent revision cost R(w), the inference total is P + E(w) + R(w), using the applicable tariffs for each phase. R(w) is zero only when no such phase takes place. If R(w) is unknown, results can compare the original two phases and show a threshold at which extra work would exhaust the calculated savings. The result is a sensitivity boundary. It does not assign a probability of rework. The distinction is material for a developer who wants to compare an unattended run with a supervised workflow.
Results
The Cost of Planning
Table 1 reports the phase counters and costs under the same peak rate. The archived Flash prices are CNY 2.00 for uncached input, 0.04 for cached input and 8.00 for output per million tokens. The corresponding valley prices are CNY 1.00, 0.02 and 4.00. The archived calendar defines peak as 09:00–12:00 and 14:00–18:00 China Standard Time on weekdays other than designated public holidays. This calendar is used only for the archive and its fixtures. The archived Pro rates are CNY 9.00, 0.30 and 27.00 at peak and CNY 4.50, 0.15 and 13.50 at valley in the same order. These rates are used only for the documented counterfactuals.
Table 1. Observed token counts and counterfactual peak costs by phase.
| Trace | Phase | Total input | Cached input | Output | Peak cost (CNY) |
|---|---|---|---|---|---|
| A | Planning | 37,107 | 36,864 | 1,859 | 0.01683 |
| A | Execution | 115,678 | 107,136 | 750 | 0.02737 |
| B | Planning | 107,205 | 98,944 | 2,631 | 0.04153 |
| B | Execution | 194,524 | 191,872 | 943 | 0.02052 |
For trace B, planning contains approximately 36% of all tokens but accounts for 66.9% of the peak-priced two-phase estimate. Its planning cache-hit share is 92.29%, compared with 98.64% during execution. Planning also accounts for 2,631 of the 3,574 output tokens. Both differences matter because uncached input and output carry higher rates. The peak estimate for its two phases is CNY 0.06205. Repricing execution at valley reduces this to CNY 0.05179, a reduction of CNY 0.01026 or 16.5%. For interrupted trace A, the corresponding totals are CNY 0.04420 and CNY 0.03052, a 31.0% reduction on the recorded partial work. Its cost cannot be interpreted as a cost per completed task.

Figure 3. Estimated two-phase cost under peak and valley execution rates. Planning is priced at peak in all four scenarios. Trace A was interrupted and trace B completed.
Figure 3 reports the simulated pricing change in the two traces. It makes the significance of the phase boundary visible. The completed task's peak-priced execution is the smaller component. A scheduling recommendation based only on the percentage reduction in the execution rate would conceal this fact. Conversely, the larger execution share in the interrupted trace makes its recorded cost more sensitive to that rate. The two cases support a mechanism explanation and are too few to estimate how often either pattern occurs.
Approval Events in the Engineering Traces
The archival event sequence adds context to the phase totals. For each task, events were ordered by the stored sequence number. Each entry into the waiting-for-approval state was classified by the active phase before the transition. The study cross-checked these event counts against the approval records and reported only the count, phase, request type and recorded outcome. The archived timestamps, action text and project paths were excluded. These records identify a point at which application execution depended on resolution of an approval. They do not measure a person’s active attention.
The interrupted trace A entered the approval state six times during execution. All six were command requests. Five were accepted and one expired. The completed trace B entered the approval state three times during planning and five times during execution. Seven requests concerned commands and one concerned a file change. The archive records all eight as accepted. The third record, which lacked comparable phase totals, contains one declined command request during planning. No automatic clarification reply is recorded for these cases. These counts distinguish the mechanism that the archive supports from the actions seen in the engineering records.
Both included traces used the earliest-start setting. Their approval events therefore show that technical authority can be consequential within an agent task, regardless of whether the schedule targets valley rates. The evidence supplies no comparison of interruption rates between price windows. It also cannot show what would have happened had the task owner been absent. A future evaluation can use the archived categories to distinguish cases that would still require action from those that could proceed using prior authorisation. A decline or expiry should remain visible as a distinct outcome. Counting it simply as elapsed delay would conceal a difference between a decision the person made and one the system could not obtain.
Cross Window Attribution
The synthetic Flash workload costs CNY 0.182 when priced entirely at peak and CNY 0.091 when priced entirely at valley. When half of each usage category is attributable to each tariff, the result is CNY 0.1365. Applying the peak start rate to every token overstates the example by CNY 0.0455, or 33.3% relative to the mixed result. Applying the valley rate to an otherwise identical mixed run understates it by the same amount. These are accounting errors relative to the stipulated usage and tariffs, without any assertion about how an invoice assigns real request times.
The inspected implementation estimates cross-window use by spreading expected consumption uniformly over the forecast duration. During execution, the budget check can value cumulative usage at the rate queried when a usage update arrives. The completion report can value usage at the run's start rate. In a crossing run these conventions can yield different estimates even with the same observed counters. A design implication is to retain chargeable usage increments with their timestamps and source rate version. If the event stream supplies cumulative counters, differencing adjacent snapshots helps, but sparse events may still leave the tariff attribution of some tokens unknown. That uncertainty should remain visible until reconciliation.
Model Choice and Delay
For the same synthetic workload, the archived Pro tariff yields CNY 0.735 at peak and CNY 0.3675 at valley. At an execution budget of CNY 0.10, valley Flash is the only affordable combination in this scenario. At CNY 0.40, Flash is affordable at either rate and Pro is affordable at valley. These results identify feasible price choices conditional on the fixed usage profile. They cannot rank coding quality or show that one model would consume the same quantity of tokens as another in actual use.
Suppose the valley window begins four hours later and every other condition is equal. The synthetic Flash workload saves CNY 0.091, which implies a break-even delay value of CNY 0.02275 per hour. A person blocked on the result may value earlier delivery more highly. A task already intended for overnight execution can have a much lower delay cost. In either case the recommendation should expose the absolute expected savings, expected completion time and assumptions behind each estimate. If pending decisions are likely, the available work before the next decision can be scheduled independently where the task graph permits.
Reactive Budget Thresholds
Assume a budget of CNY 0.10 and a last observed cumulative cost of CNY 0.09. A request incurs CNY 0.03 before the next usage update. At the first observation that exceeds the threshold, CNY 0.12 is already spent. Cancelling at that point can limit additional work while leaving an overrun of CNY 0.02. The values illustrate the behaviour of an after-the-fact threshold and are not a measured prototype overrun.
A policy that reserves a defensible upper bound before admitting a request could decline the CNY 0.03 action when only CNY 0.01 remains. The guarantee depends on the validity of the bound, the inclusion of in-flight requests and the provider's price semantics. Where the system cannot establish these conditions, it can present the configured budget as a threshold for requesting a stop. The prototype instructions already describe this distinction and warn of delayed usage reporting. The illustrative example shows why the user-facing wording has accounting consequences.
Offline Replay of Scheduling and Queue Interactions
A second artificial evaluation asked whether making the cheapest individual placement can prevent a feasible second task from running. This is a property of the inspected scheduler, so the evaluation calls that scheduler with a controlled queue instead of comparing traces from different times. The experiment uses a fixed simulated Monday in the Asia/Shanghai time zone and a copy of the archive's local rate fixture. The modeled request comprises 100,000 uncached input tokens and 10,000 output tokens per task. At the fixture rates the forecast is CNY 0.28 at peak and CNY 0.14 in the valley. Setting the local power term to zero isolates the API price effect. The configured window permits the whole day, and both tasks have a 13:00 deadline. One 60-minute task, F, has higher priority, is available from 10:00, and initially has an API budget of CNY 0.30. A second 60-minute task, T, has lower priority, cannot start before 12:00, and has a budget of CNY 0.15. The feasible start for T is exactly 12:00.
Table 2. Offline replay of task placement and forecast API cost.
| Scenario | Start F | Start T | Scheduled cost (CNY) |
|---|---|---|---|
| Both cost-oriented | 12:00 | No slot | 0.14 |
| F prefers earliest start | 10:00 | 12:00 | 0.42 |
| F prefers earliest, CNY 0.15 budget | 12:00 | No slot | 0.14 |
| T alone | Absent | 12:00 | 0.14 |
| F alone, CNY 0.10 budget | Over budget | Absent | No run |
With both tasks set to prefer the lower-price slot, the scheduler processes F first and reserves 12:00–13:00. It returns no start for T. T by itself is scheduled at 12:00. When F instead uses the earliest-start policy, it starts at 10:00 for CNY 0.28 and leaves 12:00 available for T at CNY 0.14. Both starts are then scheduled for an aggregate estimate of CNY 0.42. These results answer a queue-level question that an individual quote cannot resolve. Completing the two-task schedule costs more than scheduling only F. The outcomes therefore differ in the quantity of scheduled work and are not a like-for-like saving comparison. The replay supplies no assurance that either coding task would meet its technical acceptance criteria.
Reducing F's budget to CNY 0.15 makes the peak option unaffordable. Even under earliest-start, F takes 12:00, because a partially peak run ending after noon is still above budget at all earlier quarter-hour candidates. For example, a start at 11:45 puts 15 minutes at peak and 45 at valley for an estimated CNY 0.175. Reducing F's budget further to CNY 0.10 and removing T isolates a distinct outcome. The scheduler finds candidate times but rejects all of them on price and returns the cheapest estimate of CNY 0.14 with no scheduled start. In the first scenario T has no worker slot and no cost estimate. In the last scenario F has a feasible time but no affordable quote. Displaying the same generic waiting label in both cases would hide a consequential difference. A user can resolve the former by changing queue order or relaxing a deadline and the latter by reducing expected consumption, changing the task scope or explicitly authorising a higher budget.
The example establishes a limitation of the current priority rule. Greedy placement is straightforward to reproduce and preserves a simple interpretation of priority, but a high-priority flexible task can take the only feasible slot for a task with a tighter window. A multi-task planner could expose a second candidate schedule in which the user authorises a higher price to keep both deadlines. If tasks belong to different people or budgets, changing an individual's schedule to improve throughput requires the consent of the relevant owners. The data needed for that choice include each task's earliest start, deadline, price range, dependency requirements and who may approve a change. This is a separate problem from finding the lowest tariff for one task.
Quarter-hour probing and the archive’s bounded search horizon also limit the feasible set searched. A run that only fits after a non-grid end of another reservation can be missed when that time is neither the first probe nor a subsequent boundary. A queue display therefore benefits from describing a result as the best feasible candidate found under the scheduler's assumptions. If estimates change after a task begins, reservation and deadline predictions can change as well. A test of repeated rescheduling would need event sequences with varying actual durations and arrivals. The present replay has fixed inputs and makes no workload-level claim about wait time or utilisation.
Sensitivity to Cache, Delay and Follow-Up Work
The rate card assigns much lower prices to cached input than to other token categories. For the synthetic workload of 100,000 total input and 10,000 output tokens, let h be the cache-hit share of input. With Flash peak prices, the execution estimate is CNY 0.280 − 0.196h. With valley prices, it is CNY 0.140 − 0.098h. At peak, cache shares of zero, one half and one yield CNY 0.280, 0.182 and 0.084. At valley they yield CNY 0.140, 0.091 and 0.042. These calculations hold output fixed. They isolate the accounting effect of cache coverage and make no assumptions about the provider's future cache behaviour.
Under the same assumptions, a CNY 0.20 peak execution budget requires a cache-hit share of at least 40.82%. Valley execution fits within CNY 0.20 even at zero cache reuse. Conversely, a CNY 0.10 valley budget also requires approximately 40.82% cache reuse. A recommendation to wait may therefore depend on the conservatism of the forecast as well as the nominal discount. If cache coverage is uncertain and a later window fits even under a low-reuse scenario, the user can distinguish that case from a later window that fits only if the earlier planning context is successfully reused. The denominator matters here. These thresholds use an execution budget. A budget for planning plus execution must first account for already incurred planning spend.
For a run with the same phase counts as trace B, let q be the fraction of every execution token category charged at valley. The counterfactual initial cost is CNY 0.04152776 + 0.02052288(1 − q/2). At q equal to zero, one quarter, one half, three quarters and one, the totals are CNY 0.06205, 0.05949, 0.05692, 0.05435 and 0.05179, respectively. Relative savings are 0%, 4.1%, 8.3%, 12.4% and 16.5%. The curve is linear because the same discount factor applies to each category and the fraction q is shared. A provider that varies discount by category requires separate fractions or attributable counters. The duration of a discounted interval equals q only under a uniform usage rate for every category.

Figure 4. Sensitivity of cost estimates to cache reuse and valley-priced execution. Panel A prices a synthetic Flash workload with 100,000 input and 10,000 output tokens and marks the cache share required to satisfy a CNY 0.20 peak execution budget. Panel B holds trace B’s token counts and planning tariff fixed and varies the fraction of each execution token category priced at valley.
Figure 4 visualises the cache-dependent quote and the effect of moving more of trace B’s execution into the valley window. The trace B peak-to-valley difference of CNY 0.01026144 is also the maximum additional inference spend the deferred workflow could absorb before its initial cost advantage disappeared, assuming no such incremental work in the peak workflow. If the extra work is valued at the same valley rate and has the same mixture of token categories as the original execution, it could add up to one original execution's worth of tokens before exhausting that difference. If the follow-up is priced at peak, the corresponding threshold is half of the original execution profile. This example does not assume that a follow-up resembles the original run. It translates a small monetary margin into a quantity interpretable under two explicit pricing conditions.
Waiting can consume the margin without any additional inference. For trace B, a four-hour shift saves CNY 0.01026144 in the full-valley counterfactual. The implied break-even value is about CNY 0.00257 per hour. The separate synthetic workload has a larger break-even value because it spends more on execution. The decision will differ for a long unattended task whose completion is useful in the morning and a short task whose result is needed immediately. The rational comparison uses the difference in expected completion times, with queue delay and waiting for decisions included where known. The difference in scheduled start times is an approximation when the durations and interruptions are otherwise equal.
A related outcome sensitivity arises when a user accepts fewer unattended outputs. Suppose, purely for a policy calculation, that repeatable tasks incur the same estimated initial cost on every attempt and that failed attempts are comparable across policies. Let aP and aV be the probabilities of a verified result per attempt at the peak and valley schedules. Expected inference cost per verified result is lower for valley when aV/aP exceeds the ratio of the initial costs. Under the trace B estimates that ratio is approximately 0.835. This is a break-even relation under an explicitly stylised repetition model. The two traces cannot estimate either probability. In practice, failed attempts may be stopped early and later attempts may reuse their outputs. A field analysis should therefore compute verified outcomes and all attempts' accumulated cost directly before fitting any success model.
Discussion
Savings and Control Are Joint Outcomes
The price comparison explains whether a delay is worth considering. It does not determine whether the intended work can be completed during that delay. A task with settled acceptance criteria can tolerate a longer period of unattended execution. A task with unresolved design decisions may benefit more from a short initial planning session, followed by execution of modules that can proceed independently. The system therefore needs a representation of which choices can be made without the user, as well as a tariff and calendar.
This pairing of money and control is the principal information-systems contribution. Cost transparency lets the user understand the financial consequences of the schedule. The record of decisions and versions lets the user understand how the schedule affected the work they received. When modules can be changed without restarting a whole project, the decision to defer becomes more reversible. Whether this lowers review or rework costs needs direct evidence from users. The current artifact provides a way to log the inputs to that evaluation.
Implications for Interface Design
The interface should help a first-time user recognise the execution scope, schedule, estimated spend and conditions that would pause work. A demonstration can teach these concepts without consuming paid tokens. The main screen can use one estimate with visible assumptions and a comparison of feasible start times. Detailed token categories remain available for reconciliation. This keeps the price review intelligible while preserving the evidence a more experienced user may need.
During execution the useful unit of progress is a change the user can inspect. A checkpoint can carry a short summary, a diff or snapshot, a decision status and verification evidence. On return, the user can open a node, inspect its parent and acceptance criteria, revise the instruction and create a new version. A compatibility check should precede combination. The costs of regeneration and validation can then be attributed to the resulting module or combination, making it possible to compare rework across tasks of similar scope.
Propositions for Subsequent Evaluation
P1 concerns traceability during handoff. Given equivalent artifact versions, equivalent decisions and the same available evidence, a review interface that links a decision to the resulting version and to its approval basis should reduce the time needed to identify the first unresolved decision relative to a chronological transcript. A meaningful test would hold the underlying information constant and vary whether the relation is presented at the version. Completion time and the correctness of the identified blocker should be measured together. Fast selection of the wrong blocker would count as an error. The expected benefit should shrink for a single-module run with few decisions and a short transcript.
P2 concerns bounded delegation. For a set of ambiguous decisions labelled in advance by task owners, a context-bound reply policy should allow more authorised progress before the owner's return than mandatory escalation, while preserving the same rate of respect for decisions explicitly reserved for the owner. The comparison needs at least two denominators. Eligible clarification requests reveal what fraction the policy can resolve. Reserved requests reveal whether the policy crosses an authority boundary. Recording whether a task encountered a question helps isolate the effect of a policy that actually took effect. An exact-match baseline helps measure whether more flexible matching trades greater coverage for unauthorised answers.
P3 concerns revision locality. For a change limited to one module with a stable dependency contract, the ability to branch a saved version and select it for recombination should reduce regeneration work relative to rerunning the entire task. The measure can include regenerated tokens and the number of previously accepted components altered by the revision. Time to verify the combined result and the rate of passed integration checks should be measured alongside regeneration. If revisions frequently change shared interfaces, the advantage should shrink and may reverse because dependency checks and recombination create work. In that case the paper's design hypothesis concerns the granularity and stability of modules, beyond the availability of a branching button.
P4 concerns cost attribution in recommendations. Showing the planning and execution estimates, the price window and any deadline assumptions should improve a person's ability to identify the least expensive feasible schedule for a specified task, compared with showing the execution discount alone. An experiment can provide scenarios with known input counters and a stipulated value of timely delivery. Participants can explain their choices and estimate total charges before seeing outcomes. Accuracy on both the cost comparison and the deadline decision matters. A decision to run immediately can be economically correct when the cost of delay exceeds the inference savings. The participant's explanation can reveal which assumptions drove the schedule choice.
These propositions specify where the artifact could add value and where evidence could contradict the design rationale. They also distinguish two causal questions for study. A scheduling comparison can isolate changes in token charges with the execution task held fixed. An interaction comparison can isolate the effect of how decisions and artifacts are represented, with access to the same prices and task evidence. A combined field evaluation can subsequently test whether the two features interact, such as when a richer handoff changes willingness to choose a cheaper but unattended window.
Limitations and Field Evaluation
The prototype inspection does not estimate adoption, savings in production, coding quality or user satisfaction. The two engineering traces are neither independent user trials nor a comparison of deployed peak and valley sessions. Their price comparison fixes consumption and does not model changes in cache availability, provider performance, model routing or rework. The synthetic scenarios expose behaviour under known assumptions. They supply no estimate of the prevalence of tariff-crossing or overspending in actual use.
Implications for Teams and Product Evaluation
Cost and review measures serve different decision makers. A person deciding whether to start a task wants the expected difference between now and the next suitable window. A person reviewing an overnight result wants to know which changes remain available, which decisions still need input, and whether the selected modules pass the same checks when combined. A person responsible for a shared budget wants to compare tasks on like terms. The system can support these views from one linked record while showing each person only the details needed for their decision. For example, an overall charge attributed to a task can be reconciled without revealing full prompts in the budget view, while a module reviewer can see a decision summary, applicable scope and verification result without receiving unrelated billing details.
The cost object changes across phases. Before the user confirms, the system has a forecast and an assumption set. During the run it has observed usage and a provisional monetary estimate. After reconciliation it may have a provider charge that differs from the estimate. During review there can also be human effort or later model work attributable to revision. A system that overwrites the estimate with a final number loses the ability to distinguish forecast error from consumption after a change of scope. Keeping estimate, observation and reconciliation as separate fields lets a team ask whether large errors came from an incorrect cache assumption, a long wait before verification, or a user-approved revision. A cancelled task retains the incurred planning cost even if it produces no verified module. An integration pass can be tracked as additional work with its own outcome and budget.
There is a similar distinction between returning a result and returning control. A result package can include a patch, test output and an explanation. Control is restored when the user can tell where an earlier decision came from and can revise its consequences without accepting unrelated changes. That criterion has limits. A working branch preserves past file versions but cannot recall an email, retract a remote operation or reverse an external charge. For that reason the proposed delegation policy distinguishes local reversible edits from actions with effects outside the workspace. The synthetic data and offline regression checks do not demonstrate the safety of external operations. A field evaluation of the canvas can use local sandboxed tasks and observe whether participants can retrieve, correct and recombine versions under the approved scope.
Protocol for Evaluation in Use
The proposed field study uses comparable maintenance tasks with predetermined acceptance checks in separate project copies. It should recruit participants who have prior experience reviewing changes in an editor or code repository, with recruitment, participant information and project-data handling reviewed before collection. Each task would have a reference brief specifying the expected behaviour and verification commands. The task set should cover work that can proceed directly, work with a reversible ambiguity, and work with an ambiguity that should trigger explicit authorisation. Having these cases in advance makes it possible to observe whether a question was surfaced at the appropriate point rather than treating all pauses as failure.
A controlled first stage could cross two scheduling policies with two review interfaces. The first factor compares earliest feasible execution and price-aware execution. The second compares a chronological transcript with a canvas that provides the same underlying change and test evidence through saved nodes. Assign tasks and condition order across participants, using different tasks of similar difficulty to limit carryover. Hold the model, tool permissions, project starting state and acceptance tests constant when identifying the effect of schedule or interface. Give both interfaces access to equivalent information and record differences in ease of retrieval. If a lower price schedule also changes the model, that comparison answers a different question about the total policy and should be analysed separately.
Price-aware execution is meaningful only if a discount actually applies or if the use case explicitly stipulates a simulated discount. A controlled session may replay comparable outcomes from recorded or scripted agent actions so that the review interface can be assessed without uncontrolled generation differences. A real scheduling comparison should use verified price windows and record the actual billing basis. The replay can establish an interface effect under known information. The deployed comparison can capture changes in waiting time, provider response, completion and costs that a replay holds fixed. Running the stages in that order makes it possible to diagnose an interaction failure before conflating it with changes in provider conditions.
To model the user's absence without assigning one group an easier task, the controlled evaluation can set an agreed time at which participants become unavailable to answer requests. A task receives the same initial permissions in each condition. A scripted question can be designated as covered by a prior answer, a reversible default or a required fresh decision. The preassigned correct handling is part of the verification rubric. After the review phase, the study can ask the participant to identify the decision that led to a specific change and revise one output without modifying an unrelated module. Observable outcomes include successful identification of the basis for the decision, time to locate the relevant artifact and whether the revised module integrates with its selected dependencies.
The main monetary outcome would be inference spend per independently verified task. Count all metered attempts in the numerator, including planning, stopped runs and follow-up work within a predeclared horizon. Use the number of accepted tasks as the denominator, report verified and attempted task counts separately, and report total spend alongside the ratio so that a small denominator remains visible. A task with no verified outcome remains in the spend numerator. Cost estimates may be evaluated against a provider statement only if the account and reporting granularity support that comparison. Provider totals containing other tasks should not be attributed to the study run. If allocation cannot be verified, report separately what can be inferred from application metering.
A main control outcome would be the time required to locate and correctly resolve the first actionable blocker after the user returns. The time origin is the first opening of the relevant session, and the endpoint is either resolution under the rubric or the end of a fixed review period. Record the latter as unresolved. Report the number of unresolved cases and describe how the analysis treats the observation limit. Also report cases with no blocker separately. Other outcomes include completion before the review window, changes outside authorised scope, user-initiated branch creation, verified integration after version selection, and the number of minutes spent on review or rework. Branch activity can indicate exploration as well as repair. The study should classify the reason for each observed branch before interpreting its count.
A minimum quantitative record would include a research task identifier, condition, model, price snapshot and forecast assumptions, timestamps for approval and execution, metered usage by phase and tariff, and the task's adjudicated outcome. A separate interaction record would document user responses, pauses, decision categories, module versions reviewed and revisions. Linking them by research identifiers allows a cost change to be examined alongside any additional review burden. Text of user prompts and local source code is not necessary for the primary metrics. If detailed diagnostics are collected for adjudication, use project copies that the research team can lawfully access and retain the smallest necessary excerpts under a stated access and retention plan.
Before analysis, specify the minimum meaningful difference in review time and the allowable change in verified outcomes and authorisation errors. A small pilot can establish instrument reliability and likely variance, then inform sample size rather than supplying evidence of effectiveness. For a repeated-task design, account for participant and task differences when estimating effects. Report interval estimates and condition-level outcome counts. Record reasons for missing data, pauses and technical failures because excluding disrupted runs could bias evaluation in favour of an unattended workflow. A prespecified sensitivity analysis can compare estimate-only observations with the subset that can be reconciled to billing evidence.
The evaluation should also report potential mismatches between measures. A participant can complete a task review quickly while missing a material side effect. A run can meet a forecast budget but deliver too late for use. A revised module can pass local tests and fail integration. These are reasons to report the monetary, timing and verification outcomes together. The current study provides deterministic cases and a record structure to design that evaluation. It contains no participant results.
Conclusion
An overnight coding run can be less expensive while leaving the user with more work to understand and revise. The prototype provides a way to specify these effects as separate, observable properties of one workflow. In the completed engineering trace, moving execution to the valley tariff reduced the two-phase estimate by 16.5% even though the execution rates halved. The tariff-boundary example showed that a precise-looking total can also depend on when the system prices accumulated usage. A practical design therefore links the forecast and observed usage to a record of the choices, saved module versions and verification results that the user receives.
Data Availability and Research Materials
Appendix A contains the de-identified token counts or their in-text locations, archived rates and calculation instructions needed to reproduce the numerical comparisons. The accompanying dataset contains phase counts, task states, approval aggregates and the frozen tariff schedule. The underlying prototype database contains project and operational metadata and is not shared. No participant data were collected for this study. Appendix B discloses the use of generative AI in the analysis and writing.
References
Amershi, S., Weld, D., Vorvoreanu, M., Fourney, A., Nushi, B., Collisson, P., Suh, J., Iqbal, S., Bennett, P. N., Inkpen, K., Teevan, J., Kikin-Gil, R., & Horvitz, E. (2019). Guidelines for human-AI interaction. In Proceedings of the 2019 CHI Conference on Human Factors in Computing Systems (pp. 1–13). Association for Computing Machinery. https://doi.org/10.1145/3290605.3300233
Baird, A., & Maruping, L. M. (2021). The next generation of research on IS use: A theoretical framework of delegation to and from agentic IS artifacts. MIS Quarterly, 45(1), 315–341. https://doi.org/10.25300/MISQ/2021/15882
Bandara, W., Leyer, M., & Rosemann, M. (2025). From automation to autonomisation: How to capitalise on empowered processes. Australasian Journal of Information Systems, 29. https://doi.org/10.3127/ajis.v29.6059
Chen, L., Zaharia, M., & Zou, J. (2024). FrugalGPT: How to use large language models while reducing cost and improving performance. Transactions on Machine Learning Research. https://openreview.net/forum?id=cSimKw5p6R
DeepSeek. (n.d.-a). Context caching. DeepSeek API Docs. Retrieved November 13, 2026, from https://api-docs.deepseek.com/guides/kv_cache/
DeepSeek. (n.d.-b). Models & pricing. DeepSeek API Docs. Retrieved November 13, 2026, from https://api-docs.deepseek.com/quick_start/pricing/
Doolin, B., Techatassanasoontorn, A. A., Waizenegger, L., & Wallace-Carter, E. (2025). Theorising robotic process automation as socio-technical change: A process study. Australasian Journal of Information Systems, 29. https://doi.org/10.3127/ajis.v29.5451
FinOps Foundation. (n.d.). Unit economics. Retrieved November 13, 2026, from https://www.finops.org/framework/capabilities/unit-economics/
Hevner, A. R., March, S. T., Park, J., & Ram, S. (2004). Design science in information systems research. MIS Quarterly, 28(1), 75–105. https://doi.org/10.2307/25148625
Horvitz, E. (1999). Principles of mixed-initiative user interfaces. In Proceedings of the SIGCHI Conference on Human Factors in Computing Systems (pp. 159–166). Association for Computing Machinery. https://doi.org/10.1145/302979.303030
Kery, M. B., & Myers, B. A. (2018). Interactions for untangling messy history in a computational notebook. In 2018 IEEE Symposium on Visual Languages and Human-Centric Computing (VL/HCC) (pp. 147–155). IEEE. https://doi.org/10.1109/VLHCC.2018.8506576
Lee, J. D., & See, K. A. (2004). Trust in automation: Designing for appropriate reliance. Human Factors, 46(1), 50–80. https://doi.org/10.1518/hfes.46.1.50_30392
Moreau, L., & Missier, P. (Eds.). (2013, April 30). PROV-DM: The PROV data model. World Wide Web Consortium. https://www.w3.org/TR/prov-dm/
Ong, I., Almahairi, A., Wu, V., Chiang, W.-L., Wu, T., Gonzalez, J. E., Kadous, M. W., & Stoica, I. (2025). RouteLLM: Learning to route LLMs from preference data. International Conference on Learning Representations. https://openreview.net/forum?id=8sSqNntaMr
Parasuraman, R., Sheridan, T. B., & Wickens, C. D. (2000). A model for types and levels of human interaction with automation. IEEE Transactions on Systems, Man, and Cybernetics—Part A: Systems and Humans, 30(3), 286–297. https://doi.org/10.1109/3468.844354
Venable, J., Pries-Heje, J., & Baskerville, R. (2016). FEDS: A framework for evaluation in design science research. European Journal of Information Systems, 25(1), 77–89. https://doi.org/10.1057/ejis.2014.36
Appendix A Reproduction
Use Table 1 as the full phase-count input and the rates in Results as the fixed rate card. For the price comparisons, first subtract cached input from total input. Multiply each token category by its rate and divide the sum by one million. For each trace, add the peak planning cost to peak execution for the baseline. For deferred execution, add the same planning cost to the valley-priced execution. Divide their difference by the baseline to recover the percentage derived from Figure 3. Retain full precision until reporting.
For the boundary example, apply the rates to (100,000, 50,000, 10,000) in the order of total input, cached input and output. For a half-peak workload use (50,000, 25,000, 5,000) for each half. The stop-threshold example follows from adding the CNY 0.03 next increment to the last observed CNY 0.09. All reported costs exclude local electricity, human review, tax and fees outside the archived token rate card. These choices define the accounting boundary for this study.
The queue replay uses two one-hour tasks and the CNY 0.28 peak and CNY 0.14 valley forecasts described above. Define the candidate starts as the later of the observation time and the task’s earliest start, followed by each quarter-hour boundary through its deadline less one hour. Discard a candidate if it overlaps a reservation or its forecast exceeds the task’s budget. Sort tasks by descending priority, then deadline, then creation time. The cost-oriented policy reserves the candidate with the lowest forecast, using earliest start to break ties. The earliest-start policy reserves the first affordable candidate. Use each reservation when processing the next task. This sequence reconstructs the documented replay from the inputs and makes clear why F’s strategy changes the result for T. The source-level test rerun uses Python 3.12 and the archived fixtures. It contains no calls to a live model or billing endpoint.
The replay holds release times, task estimates and the archive’s rate fixture constant. It uses 10:00 as the observation time and noon as the rate boundary. F becomes eligible at 10:00 and T at noon. Both deadlines are 13:00. A start at 11:30 produces an estimated CNY 0.21 for either task with the fixed usage profile. F at noon is cheaper still at CNY 0.14, but this consumes the slot required by T. Table 2 also includes a separate price-only failure in which the minimum forecast is shown even though the corresponding candidate is not admitted.
Appendix B Generative AI Disclosure
OpenAI Codex was used for initial and expanded English drafting, structural revision, source discovery, archive inspection, construction and execution of the deterministic calculations and offline replay, and preparation of the figures. Codex generated original prose for the Abstract, Introduction, Related Work, Artifact and Design Requirements, Method, Results, Discussion, Conclusion and appendices. It helped formulate the research question, identify implications of the recorded counters and propose the follow-on study. It also generated the constructed scenarios. Those inputs are labelled as synthetic and do not represent records of participant activity or external invoices.
The human contribution supplied the prototype and its source materials, the interaction design rationale, and the account of the problem that motivates the paper. In particular, the underlying design brief specified advance planning during peak prices, scheduled execution at valley prices, answers bounded by prior authorisation, and return to an editable canvas with automatically saved nodes, branches and module combinations. The trace data are pre-existing engineering records. Codex used these materials in developing the exposition and case analysis.
Representative author prompts included asking for a paper about token economics using the author’s existing prototype, and asking to address the fact that coding is cheaper during valley rates while the user still needs to follow progress and change requirements. A further prompt requested a professional and detailed 20–30-page manuscript. In response, Codex was directed to expand the analysis of scoped delegation, validate archive-based scheduling and canvas claims, and show sensitivity to cache reuse, delay and follow-up work. Monetary comparisons can be checked against the stated rates and counters. The prototype and identifiable sources are masked in this review version.