People who put things off feel today's effort in full and shrink tomorrow's. Tools that help them follow through, such as splitting a project into small steps or assigning household chores fairly, almost always assume that the effort of a group of tasks is the sum of the effort of each task. Real tasks do not work that way. Getting out the cleaning supplies costs you once no matter how many rooms you clean. Stopping halfway means paying that setup again later. The fifth chore of the evening feels heavier than the first. This note argues that such non-additive costs matter far more for someone who procrastinates than for an idealized planner, because non-additivity changes when effort is paid, and a present-biased agent weighs effort almost entirely by when it arrives. Setup costs arrive up front, where they loom largest. Fatigue arrives at the end, where it is underestimated until too late.
We propose a model, algorithms, and an empirical test of this interaction in two linked settings. The first is splitting one project into chunks for a single procrastinating agent. The second is dividing a set of chores between two people who will actually carry them out over time. The concrete prediction is that the standard advice ("start with small, easy steps"; "group related chores to save effort"; "an allocation that is fair on paper is fair") can fail in ways that are predictable and computable once costs are modeled as set functions and execution is modeled as a sequence of choices by a present-biased agent.
Core Claim
Two literatures sit next to each other without touching.
The first is time-inconsistent planning. Here a present-biased agent perceives the immediate step's cost at face value and discounts all remaining cost by a factor $\beta<1$. As a result it procrastinates or abandons projects midway (Time-Inconsistent Planning: A Computational Problem in Behavioral Economics; Computational Issues in Time-Inconsistent Planning). The closest design result is Chunking Tasks for Present-Biased Agents. It proves that splitting a task of cost $x$ into chunks $x_1,\dots,x_k$ with $\sum_i x_i = x$ should follow an Easy-to-Hard order, and that doing so reduces the cost ratio from exponential to a constant. The constraint $\sum_i x_i = x$ is exactly the additive assumption. Splitting is free in that model.
The second literature is fair division under non-additive costs. Fair Chore Division under Binary Supermodular Costs and Almost Envy-Freeness with General Valuations handle set-function costs. Both treat allocation as a one-shot event with no execution over time. The deployed chore app Kajibuntan is additive and static by construction, and its authors flag both limitations.
Our claim is that once chunking and allocation are posed over set-function costs with execution by a present-biased agent, three results that hold additively break in specific ways.
The first break concerns chunking. When each resumption re-incurs a setup cost, the optimal number of chunks becomes finite. The Easy-to-Hard rule survives only for the variable part of the work, because the first chunk carries an irreducible setup floor that no amount of chunking can shrink.
The second break concerns grouping. Grouping tasks that share a setup lowers true total cost, but it concentrates perceived cost at the start. Below a computable bias threshold $\beta^*$, the cheaper grouped plan is completed less often than a split plan.
The third break concerns fairness. Convex fatigue is back-loaded and therefore underweighted, which makes a naive agent accept bundles it later abandons. An allocation that is envy-free up to one chore on true costs can then leave one partner with an uncompleted bundle, so its realized fairness is not its nominal fairness.
Model
A project or chore set is a ground set $M$ with a cost set function $c(S)$ giving the true effort of having completed the tasks in $S$. The agent works in episodes. At each decision point, having completed $S$, it considers doing next a chunk or task $e$ (possibly nothing). It then evaluates
$$ \text{perceived}(e \mid S) \;=\; \big[c(S\cup\{e\}) - c(S)\big] \;+\; \beta\, d(S\cup\{e\}) \;-\; \beta R , $$
where $d(\cdot)$ is the cost-to-go of the agent's currently planned completion, $R$ is the completion reward, and $\beta\in(0,1)$ is present bias. The agent acts if the perceived value is favorable and otherwise defers or quits, following the naive and sophisticated conventions of Planning Problems for Sophisticated Agents with Present Bias.
We study two structured cost classes that are rich enough to matter and small enough to analyze.
Setup costs. Here $c(S)=\sum_{e\in S} w_e + \sum_{g} s_g\cdot \mathbb{1}[S \text{ touches group } g] + \rho\cdot(\text{number of episode restarts})$. The group term is subadditive, because tasks in group $g$ share setup $s_g$. The restart term charges overhead $\rho$ each time the agent pauses and resumes.
Fatigue costs. Here $c(S)=\sum_{e\in S} w_e + \phi(|S \cap \text{episode}|)$ with $\phi$ convex, which makes $c$ supermodular.
The binary supermodular case of Fair Chore Division under Binary Supermodular Costs, where $|S|-c(S)$ is a matroid rank function, serves as a third, combinatorially clean class.
The key point is that the marginal cost in the bracket above now depends on the history $S$ and not only on the item. A designer who controls chunk sizes, grouping, order, or the allocation between agents is therefore also controlling when non-additive costs land relative to the agent's bias.
Research Program
Theory of chunking with overhead. We first extend the Halpern–Saraf single-edge problem to setup and restart costs. We will characterize the optimal chunk count $k^*(\beta,\rho,s)$. The tradeoff is that finer chunking lowers the perceived barrier at each step but adds $\rho$ per restart, so $k^*$ should be finite whenever $\rho>0$. We will also prove or refute that Easy-to-Hard remains optimal for the variable part once the setup floor is placed.
We then extend their DAG dynamic program to setup costs indexed by group. The program's state must now record which groups have been opened. This makes it exponential in the number of groups in general and polynomial when groups are bounded or laminar.
Hardness is expected in general. Computational Issues in Time-Inconsistent Planning already shows that motivating-subgraph and reward-placement design are NP-hard. Present-Biased Optimization shows that inefficiency in combinatorial problems stems from deviating from earlier plans. That result constrains us: we look for polynomial algorithms only in the structured classes above, and for approximation elsewhere.
Grouping threshold. For shared-setup groups we will derive the bias level $\beta^*$ below which splitting a group across separate commitments yields higher completion than grouping, and the corresponding cost ratio. Existing combinatorial results give a reference point. Present-Biased Optimization bounds the cost ratio by $\beta$ or $1/\beta$ for additive combinatorial objectives, and we will show how setup structure changes this bound.
Execution-aware chore allocation. For two agents, we will define completion-constrained EF1. This is an allocation together with a recommended schedule such that each agent's predicted execution under its own $\beta_i$ completes its bundle, and such that the allocation is EF1 on realized true costs. We will give an algorithm for the setup and binary-supermodular classes. It builds on the matroid-union machinery of Fair Chore Division under Binary Supermodular Costs, adding a completion check per agent. We will also characterize when completion and EF1 are incompatible. Their EFX-versus-Pareto-optimality impossibility result warns that such incompatibilities are likely, and we expect to find some.
Bias need not be known. Following the pessimism result of Planning Problems for Sophisticated Agents with Present Bias, we will test whether designing for a slightly overestimated bias preserves the guarantees.
Baselines
Naive reference points. The first naive reference is to split nothing: the whole project is one chunk, and chores are allocated by minimizing total true cost with no fairness or completion constraint. The second is Kajibuntan-style allocation. This means additive disutility ($t$, $2t$, $3t$ multipliers) with discrete adjusted-winner transfers to EF1 (Kajibuntan), evaluated afterward on non-additive true costs with simulated present-biased execution. The only reported Kajibuntan figure on Lacuna is a usability result (60% of 131 surveyed users found it useful for discussion). No reported result was found on Lacuna for its fairness or completion under non-additive costs, so we will establish that reference ourselves.
Strongest chunking competitor. The Halpern–Saraf Easy-to-Hard dynamic program (Chunking Tasks for Present-Biased Agents) will be run in two forms. The first is as published, with chunks designed additively and then executed under true non-additive costs. The second is a patched version that adds a constant overhead $\rho$ to every chunk. The patched version is the strongest competitor on this question, and it serves as the ablation isolating our key ingredient: history-dependent marginal costs rather than a flat surcharge. Both versions receive the same instances, the same $\beta$, and the same compute. We beat it if our method attains strictly higher completion rate or lower cost ratio on instances with shared group setups or convex fatigue. It must also match the patched version, within simulation noise, on instances with only constant restart overhead. There it should tie, and if it does not we have a bug. No reported result was found on Lacuna for the numerical cost ratios of this method on benchmark instances.
Strongest allocation competitor. For allocation, the competitors are the EF1+PO and MMS+PO algorithms for binary supermodular costs from Fair Chore Division under Binary Supermodular Costs, and, at scale, the SCHED heuristic of Algorithms for Max-Min Share Fair Allocation of Indivisible Chores. SCHED is reported to stay within 1.64% of the MMS optimum for 8 agents, with a worst-case gap of around 11–12% at larger agent counts. Both are strong because they already handle non-additive or large instances. What they lack is any model of execution.
We will run them unchanged on identical instances and score all methods on the same realized-execution metrics. We beat them if completion-constrained EF1 raises the fraction of bundles completed and lowers realized envy, while giving up no more than a stated small margin in total true cost. For SCHED, that means a larger MMS gap than its reported figures would count against us.
Why not just…?
Why not just add a fixed switching cost to the existing chunking algorithm? For pure restart overhead this may be nearly enough, and we treat it as the ablation above, not a straw man. It fails in structure where cost depends on which tasks were already done: a shared setup that is paid once per group and is free afterward, or fatigue that grows with how much was done in the current episode. A flat surcharge per chunk cannot express either. The grouping-threshold experiment is designed to show exactly where the patched algorithm makes the wrong grouping decision. If it never does on realistic instances, that is a real negative result and we will report it.
Why not just learn a schedule with reinforcement learning that allows non-exponential discounting? Beyond the Bellman Recursion handles non-exponential discounting with Pontryagin-guided policy optimization. It is reported to beat PPO, physics-informed networks, and Deep BSVIE by orders of magnitude in $L_1$ error on continuous control. Its method, however, depends on differentiable simulators and smooth dynamics. Our design variables are discrete (chunk boundaries, group assignments, who does which chore), and the agent's quit decision is a discontinuity. A generic RL scheduler also gives no fairness certificate. We will nonetheless include a PPO-style search over schedules as a black-box check that our algorithms are not leaving easy gains on the table.
Why not just ignore present bias and use the best non-additive fair allocation? If agents complete everything they are assigned, this is the right answer, and the fair-division results already solve it. Our simulations sweep $\beta$ from 1 downward. At $\beta=1$ our method should reduce exactly to these allocations. The claim stands or falls on whether the gap in completion and realized envy opens at plausible bias levels. Behavioral work motivating present bias (Schultheis et al.; Gershman et al.) suggests it will, but the real-effort study below is what settles it.
Why not just model non-additivity as a bundle discount? Is the whole the sum of its parts? finds sub-additive bundle valuation, best fit by divisive normalization. That is evidence that non-additivity is real, but it is a static valuation effect, measured on consumer goods rather than on effort over time. A timeless discount cannot produce the front-loading asymmetry our model predicts. We will fit both a timeless-discount model and our timed-setup model to the behavioral data and compare them.
Proposed Experiments
Simulation benchmark. We start from the synthetic generator of Algorithms for Max-Min Share Fair Allocation of Indivisible Chores. It draws chore costs from $U(0,100)$ with $N\in\{2,\dots,128\}$ agents and up to 3,200 chores. On top of these costs we add random group structure with setups $s_g$, restart overhead $\rho$, and convex fatigue $\phi$. We also assign per-agent $\beta_i$ drawn from a range. For single-agent chunking, we will use Akerlof-structure graphs from Computational Issues in Time-Inconsistent Planning as adversarial instances.
The metrics are completion rate, cost ratio against the time-consistent optimum, realized envy, fraction of instances where nominal-EF1 allocations are not EF1 after execution, and runtime.
The decisive checks are three. First, at $\beta=1$ all methods coincide, which is a sanity check. Second, the measured $k^*$ and $\beta^*$ must match the theory. Third, the gap between our method and the patched chunking baseline must be near zero when there is only restart overhead and positive under group setups. If that gap is zero everywhere, the core claim is wrong.
Real-effort study. We will run a preregistered online study with paired real-effort tasks. The work is transcription batches in which one condition requires a costly setup step (loading and configuring a tool) that is shared within a group. Participants choose, over several days, when to do each part. Conditions cross grouped versus split presentation with Easy-to-Hard versus uniform chunking. We will estimate each participant's $\beta$ from a standard intertemporal-choice elicitation and test the model's central behavioral prediction: grouped setup-heavy plans are started later and abandoned more often than split plans among high-bias participants, despite lower total effort.
For allocation, we will run a two-person household variant using the Kajibuntan elicitation format, extended with a single question about shared setup. Reported completion over two weeks will be compared between the additive allocation and ours.
A null result here, meaning grouping never hurts completion even for the most present-biased tercile, would indicate that the timing asymmetry is too weak in practice to justify the added modeling. That outcome would be informative in itself.
References
- Time-Inconsistent Planning: A Computational Problem in Behavioral Economics
- Computational Issues in Time-Inconsistent Planning
- Chunking Tasks for Present-Biased Agents
- Fair Chore Division under Binary Supermodular Costs
- Almost Envy-Freeness with General Valuations
- Kajibuntan: A House Chore Division App
- Planning Problems for Sophisticated Agents with Present Bias
- Present-Biased Optimization
- Algorithms for Max-Min Share Fair Allocation of Indivisible Chores
- Beyond the Bellman Recursion: A Pontryagin-Guided Framework for Non-Exponential Discounting
- Reinforcement Learning with Non-Exponential Discounting
- Estimating Scale-Invariant Future in Continuous Time
- Is the Whole the Sum of its Parts? Neural Computation of Consumer Bundle Valuation in Humans