5D Library › One-Person Enterprise Automation, Avatar Livestream Funnels and Task-Exposure Arbitrage · 中文

Chapter 2. Agent Chains and the Founder’s Queue

Errors compound along a chain

A “silicon team” is usually a chain: one agent researches, another drafts, a third formats, a fourth sends. If each step is right with probability pp and errors are independent, the whole job is right with probability pkp^k. Checks change this at a price. Below, a check catches a wrong result with probability 0.9 and costs a fifth of a step.

Calculation

# Chapter 2. p03: Reliability of a chain of AI agent steps. A job passes
# through k steps; each step is right with probability p and errors are
# independent. Without checks the job is right with probability p**k.
# A check after a step catches a wrong result with probability 0.9 and
# sends the step back to be redone (costing one more step); a check costs
# 0.2 of a step. Compared: no checks, one check at the end (catching any
# error with probability 0.9, then the whole job is redone at most once),
# and a check after every step. Exact expectations, no simulation.

def no_check(p, k):
    return p ** k, float(k)

def end_check(p, k, d=0.9):
    ok = p ** k
    caught = (1 - ok) * d
    right = ok + caught * ok           # one full redo after a catch
    cost = k + 0.2 + caught * (k + 0.2)
    return right, cost

def step_checks(p, k, d=0.9):
    # per step: geometric redo until right or an error slips through
    q = 1 - (1 - p) * d                # step ends (right or slipped)
    right_step = p / q
    tries = 1 / q
    return right_step ** k, k * tries * 1.2

if __name__ == "__main__":
    print("    p     k   no check        end check       every step")
    for p in (0.95, 0.98, 0.99):
        for k in (5, 10, 20):
            a, b, c = no_check(p, k), end_check(p, k), step_checks(p, k)
            print("   {:.2f}  {:2d}   {:.3f} ({:4.1f})   {:.3f} ({:4.1f})"
                  "   {:.3f} ({:4.1f})".format(p, k, a[0], a[1], b[0],
                                               b[1], c[0], c[1]))
    print("   (share of jobs delivered right; expected steps of work,")
    print("    checks included)")
#     p     k   no check        end check       every step
#    0.95   5   0.774 ( 5.0)   0.931 ( 6.3)   0.974 ( 6.3)
#    0.95  10   0.599 (10.0)   0.815 (13.9)   0.949 (12.6)
#    0.95  20   0.358 (20.0)   0.565 (31.9)   0.900 (25.1)
#    0.98   5   0.904 ( 5.0)   0.982 ( 5.6)   0.990 ( 6.1)
#    0.98  10   0.817 (10.0)   0.952 (11.9)   0.980 (12.2)
#    0.98  20   0.668 (20.0)   0.867 (26.2)   0.960 (24.4)
#    0.99   5   0.951 ( 5.0)   0.993 ( 5.4)   0.995 ( 6.1)
#    0.99  10   0.904 (10.0)   0.982 (11.1)   0.990 (12.1)
#    0.99  20   0.818 (20.0)   0.952 (23.5)   0.980 (24.2)
#    (share of jobs delivered right; expected steps of work,
#     checks included)

With steps that are right 0.95 of the time, a 10-step chain without checks delivers a right result only 0.599 of the time, and a 20-step chain 0.358. One check at the end, with a redo when it catches something, raises the 10-step chain to 0.815 at an expected 13.9 steps of work; a check after every step raises it to 0.949 at 12.6 steps, cheaper because errors are caught before later steps build on them. Even at 0.99 a step, 20 unchecked steps deliver only 0.818. The practical rule: short chains, checks where errors are cheap to fix, and no long unchecked pipelines in front of customers.

The founder is the last server

Whatever the agents cannot settle is escalated to the founder. Escalations arrive at random, and the founder answers one at a time, so the founder is a single-server queue (Kleinrock 1975). Take 6 answers an hour over 6 working hours a day and an escalation share ee.

Calculation

# Chapter 2. p04: The founder as the last server. AI agents handle the
# customer conversations; a share e of them is escalated to the founder,
# who answers 6 an hour (10 minutes each) during 6 working hours a day.
# Escalations arrive at random, so the founder is an M/M/1 queue with
# arrival rate lam = e * N / 6 per hour: utilisation rho = lam / 6, mean
# time from escalation to answer W = 1 / (6 - lam) hours, and the chance
# of waiting over 1 hour before the founder starts is rho * exp(-(6 -
# lam)). The queue is stable only while N stays below 36 / e a day.
import math

MU, HOURS = 6.0, 6.0

def queue(n, e):
    lam = e * n / HOURS
    rho = lam / MU
    if rho >= 1:
        return rho, None, None
    return rho, 60 / (MU - lam), rho * math.exp(-(MU - lam))

if __name__ == "__main__":
    for e in (0.02, 0.01):
        print("   escalation share {:.2f}: stable below {:,.0f} a day"
              .format(e, MU * HOURS / e))
        for n in (600, 1200, 1500, 1700, 1750, 3000):
            rho, w, p = queue(n, e)
            if w is None:
                print("     {:5,d} a day: rho {:.2f}, queue grows without"
                      " limit".format(n, rho))
            else:
                print("     {:5,d} a day: rho {:.2f}, answer in {:6.1f} "
                      "min, P(wait > 1 h) {:.3f}".format(n, rho, w, p))
#    escalation share 0.02: stable below 1,800 a day
#        600 a day: rho 0.33, answer in   15.0 min, P(wait > 1 h) 0.006
#      1,200 a day: rho 0.67, answer in   30.0 min, P(wait > 1 h) 0.090
#      1,500 a day: rho 0.83, answer in   60.0 min, P(wait > 1 h) 0.307
#      1,700 a day: rho 0.94, answer in  180.0 min, P(wait > 1 h) 0.677
#      1,750 a day: rho 0.97, answer in  360.0 min, P(wait > 1 h) 0.823
#      3,000 a day: rho 1.67, queue grows without limit
#    escalation share 0.01: stable below 3,600 a day
#        600 a day: rho 0.17, answer in   12.0 min, P(wait > 1 h) 0.001
#      1,200 a day: rho 0.33, answer in   15.0 min, P(wait > 1 h) 0.006
#      1,500 a day: rho 0.42, answer in   17.1 min, P(wait > 1 h) 0.013
#      1,700 a day: rho 0.47, answer in   18.9 min, P(wait > 1 h) 0.020
#      1,750 a day: rho 0.49, answer in   19.5 min, P(wait > 1 h) 0.022
#      3,000 a day: rho 0.83, answer in   60.0 min, P(wait > 1 h) 0.307

With 2% of conversations escalated, the queue is stable only below 1,800 conversations a day. At 600 a day the founder is busy a third of the time and answers in 15.0 minutes on average; at 1,500 a day the mean answer time is 60.0 minutes and 0.307 of escalations wait over an hour before the founder even starts; at 1,750, 360.0 minutes. The answer time rises like 1/(1−ρ)1/(1-\rho), not in proportion to volume. Halving the escalation share to 1% doubles the stable volume to 3,600 a day and brings the answer time at 1,500 conversations down to 17.1 minutes. In a one-person firm the scarce resource is the founder’s attention, and the lever is the escalation share.

Mean time from escalation to answer against daily conversations, for escalation shares of 2% and 1% (p04).

Note

Queues at high utilisation. The single-server formulas assume random (Poisson) arrivals and exponential answer times. Real escalations bunch around launches and evening peaks, which makes waiting worse than the formulas show at the same average load.

Summary

Errors compound along a chain of agents: ten steps right 0.95 of the time each deliver 0.599. Checks after each step cost little and catch most of it. The founder answering escalations is a queue whose waiting time grows like 1/(1−ρ)1/(1-\rho); the escalation share, more than any other number, sets how many conversations one person can carry.

References

Kleinrock, Leonard. 1975. Queueing Systems, Volume 1: Theory. Wiley.

Fan, Y. (2026). One-Person Enterprise Automation, Avatar Livestream Funnels and Task-Exposure Arbitrage: Coasean Transaction-Cost Collapse, Cyclic Script Retention and High-Margin Solopreneur Portfolios [一人公司自动化架构、数字人直播漏斗与任务级人工智能套利] (Version 1.0.0). 5D Library. https://doi.org/10.5281/zenodo.24090235 · Licensed under Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International (CC BY-NC-ND 4.0).