Paperclip with Python: run a company of AI agents from a scriptPaperclip กับ Python: บริหารบริษัทของเอเจนต์ AI ด้วยสคริปต์用 Python 操作 Paperclip：用脚本经营一家由 AI 智能体组成的公司

1 Start Paperclipเปิด Paperclip启动 Paperclip

TERMINAL 1 · START PAPERCLIP, AND LEAVE IT RUNNING

npx paperclipai@2026.1005.0 onboard --yes --no-install-service --data-dir paperclip-data

IT PRINTS · OUR DATA FOLDER WAS C:\pclab\data

Mode             embedded-postgres  |  static-ui
Deploy           local_trusted (private)
Bind             loopback (127.0.0.1)
Auth             ready
Server           3100
API              http://127.0.0.1:3100/api (health: http://127.0.0.1:3100/api/health)
UI               http://127.0.0.1:3100
Database         C:\pclab\data\instances\default\db (pg:54329)
Agent JWT        set
Heartbeat        enabled (30000ms)
Config           C:\pclab\data\instances\default\config.json

python -m venv venv
venv\Scripts\python -m pip install requests

python3 -m venv venv
venv/bin/python -m pip install requests

2 hello.py: one requesthello.py: คำขอหนึ่งครั้งhello.py：一次请求

RUN IT

venv\Scripts\python hello.py

NEW FILE · hello.py

"""hello.py - ask Paperclip whether it is running.

    python hello.py
"""
import requests

API = "http://127.0.0.1:3100/api"


def main():
    health = requests.get(API + "/health").json()
    print("Paperclip says:", health["status"])
    print("Version:", health["version"])
    print("Mode:", health["deploymentMode"])


if __name__ == "__main__":
    main()

IT PRINTS

Paperclip says: ok
Version: 2026.1005.0
Mode: local_trusted

3 company.py: open the companycompany.py: เปิดบริษัทcompany.py：开一家公司

RUN IT

venv\Scripts\python company.py

NEW FILE · company.py

"""company.py - open a company in Paperclip, and give it a goal.

    python company.py

Run it twice and the second run changes nothing: it finds the company again.
"""
import requests

API = "http://127.0.0.1:3100/api"
NAME = "Three Geckos Noodles"
ABOUT = "A noodle shop in Chiang Mai. Its staff are programs."
GOAL = "Give every table a correct bill"


def send(method, path, data=None):
    """One request to Paperclip. Returns what it answered, as Python data."""
    reply = requests.request(method, API + path, json=data)
    reply.raise_for_status()                 # stop here if Paperclip said no
    return reply.json()


def find(things, key, value):
    """The first thing in a list whose key has this value, or None."""
    for thing in things:
        if thing[key] == value:
            return thing
    return None


def main():
    company = find(send("GET", "/companies"), "name", NAME)
    if company is None:
        company = send("POST", "/companies", {"name": NAME, "description": ABOUT})
        print("Opened a new company.")
    goals_path = "/companies/" + company["id"] + "/goals"
    goal = find(send("GET", goals_path), "title", GOAL)
    if goal is None:
        goal = send("POST", goals_path,
                    {"title": GOAL, "level": "company", "status": "active"})
        print("Gave it a goal.")
    print("Company:", company["name"])
    print("Status:", company["status"])
    print("Its tasks will be numbered", company["issuePrefix"] + "-1,",
          company["issuePrefix"] + "-2, ...")
    print("Goal:", goal["title"])


if __name__ == "__main__":
    main()

IT PRINTS

Opened a new company.
Gave it a goal.
Company: Three Geckos Noodles
Status: active
Its tasks will be numbered THR-1, THR-2, ...
Goal: Give every table a correct bill

4 cashier.py: the employee is a Python filecashier.py: พนักงานคือไฟล์ Pythoncashier.py：员工就是一个 Python 文件

TRY THE SUM ALONE

venv\Scripts\python cashier.py "2 khao soi, 1 thai iced tea"

IT PRINTS

- 2 x khao soi = 120 baht
- 1 x thai iced tea = 30 baht
- Total: 150 baht

AND WITH NOTHING AFTER ITS NAME

Give me an order to add up, or let Paperclip start me.

NEW FILE · cashier.py

"""cashier.py - an employee of the company. It is a Python file, and it adds up bills.

Paperclip starts this file each time the cashier has work to do. To try the
sum by itself, with no Paperclip, hand it an order:

    python cashier.py "2 khao soi, 1 thai iced tea"
"""
import os
import sys

import requests

PRICES = {"khao soi": 60, "nam ngiao": 50, "pad thai": 60, "pad see ew": 55,
          "thai iced tea": 30, "longan juice": 25, "water": 10}


def bill(order):
    """Read an order such as "2 khao soi, 1 water".

    Returns two things: True and the bill, or False and what went wrong.
    """
    lines = []
    total = 0
    for part in order.lower().split(","):
        words = part.split()
        if len(words) < 2 or not words[0].isdigit():
            return False, "I cannot read this part of the order: " + part.strip()
        count = int(words[0])
        dish = " ".join(words[1:])
        if dish not in PRICES:
            return False, "I do not know the price of " + dish + "."
        cost = count * PRICES[dish]
        lines.append(f"- {count} x {dish} = {cost} baht")
        total = total + cost
    lines.append(f"- Total: {total} baht")
    return True, "\n".join(lines)


def order_of(task, comments):
    """The order to add up: the newest comment a person wrote, or else the task itself."""
    for comment in comments:                 # Paperclip lists the newest comment first
        if comment["authorType"] == "user":
            return comment["body"]
    return task["description"] or ""


def ask(method, url, headers, data=None):
    """One request to Paperclip, made as this agent. Returns the answer as Python data."""
    reply = requests.request(method, url, headers=headers, json=data)
    reply.raise_for_status()                 # stop here if Paperclip said no
    return reply.json()


def work():
    """Do every task that Paperclip has given to this agent."""
    api = os.environ["PAPERCLIP_API_URL"] + "/api"
    agent = os.environ["PAPERCLIP_AGENT_ID"]
    company = os.environ["PAPERCLIP_COMPANY_ID"]
    # The key says who is asking. The run id ties each change to this run.
    headers = {"Authorization": "Bearer " + os.environ["PAPERCLIP_API_KEY"],
               "X-Paperclip-Run-Id": os.environ["PAPERCLIP_RUN_ID"]}

    mine = (f"{api}/companies/{company}/issues"
            f"?assigneeAgentId={agent}&status=todo,in_progress")
    for task in ask("GET", mine, headers):
        task_url = f"{api}/issues/{task['id']}"
        # No ask() here: a 409 is an answer we expect, and we carry on after it.
        claim = requests.post(task_url + "/checkout", headers=headers,
                              json={"agentId": agent,
                                    "expectedStatuses": ["todo", "in_progress"]})
        if claim.status_code == 409:         # another agent already has this task
            print(task["identifier"], "is taken")
            continue
        claim.raise_for_status()
        comments = ask("GET", task_url + "/comments", headers)
        added_up, text = bill(order_of(task, comments))
        if added_up:
            result = {"status": "done", "comment": text}
        else:
            # Paperclip refuses "blocked" unless it is told who acts next, and how.
            waiting = {"owner": {"agentId": agent},
                       "action": "Read the corrected order in the next comment."}
            result = {"status": "blocked", "comment": text,
                      "unblockDescriptor": waiting}
        ask("PATCH", task_url, headers, result)
        print(task["identifier"], result["status"])


def main():
    if len(sys.argv) > 1:                    # an order was given: just add it up
        added_up, text = bill(sys.argv[1])
        print(text)
    elif "PAPERCLIP_API_KEY" in os.environ:  # Paperclip started this file
        work()
    else:
        print("Give me an order to add up, or let Paperclip start me.")


if __name__ == "__main__":
    main()

5 hire.py: hire it, and draw the org charthire.py: จ้างมัน แล้ววาดผังองค์กรhire.py：雇用它，并画出组织架构图

RUN IT

venv\Scripts\python hire.py

NEW FILE · hire.py

"""hire.py - hire two agents into the company, and print the org chart.

    python hire.py

Noi is the boss. The cashier is cashier.py, which must be in this folder.
"""
import sys
from pathlib import Path

import requests

API = "http://127.0.0.1:3100/api"
NAME = "Three Geckos Noodles"


def send(method, path, data=None):
    """One request to Paperclip. Returns what it answered, as Python data."""
    reply = requests.request(method, API + path, json=data)
    reply.raise_for_status()                 # stop here if Paperclip said no
    return reply.json()


def find(things, key, value):
    """The first thing in a list whose key has this value, or None."""
    for thing in things:
        if thing[key] == value:
            return thing
    return None


def hire(company, name, more):
    """The agent with this name. It is hired first if the company lacks it."""
    agents_path = "/companies/" + company["id"] + "/agents"
    agent = find(send("GET", agents_path), "name", name)
    if agent is None:
        details = {"name": name, "adapterType": "process"}
        details.update(more)
        agent = send("POST", agents_path, details)
        print("Hired", name + ".")
    return agent


def show(people, depth):
    """Print a list of agents, and under each one the agents who report to it."""
    for person in people:
        print("    " * depth + person["name"], "(" + person["role"] + ")")
        show(person["reports"], depth + 1)


def main():
    company = find(send("GET", "/companies"), "name", NAME)
    if company is None:
        print("There is no company yet. Run company.py first.")
        return
    noi = hire(company, "Noi", {"role": "ceo", "title": "Owner"})
    # "process" means: to wake this agent, start a program. This is the program.
    script = Path(__file__).resolve().parent / "cashier.py"
    start = {"command": sys.executable, "args": [str(script)]}
    hire(company, "Cashier", {"role": "general", "title": "Cashier",
                              "reportsTo": noi["id"], "adapterConfig": start})
    print("The org chart:")
    show(send("GET", "/companies/" + company["id"] + "/org"), 1)


if __name__ == "__main__":
    main()

IT PRINTS

Hired Noi.
Hired Cashier.
The org chart:
    Noi (ceo)
        Cashier (general)

6 order.py: a task wakes the agentorder.py: งานปลุกเอเจนต์order.py：任务把智能体叫醒

RUN IT

venv\Scripts\python order.py "2 khao soi, 1 thai iced tea"

NEW FILE · order.py

"""order.py - give the cashier a task, wait, and print what came back.

    python order.py "2 khao soi, 1 thai iced tea"
"""
import sys
import time

import requests

API = "http://127.0.0.1:3100/api"
NAME = "Three Geckos Noodles"


def send(method, path, data=None):
    """One request to Paperclip. Returns what it answered, as Python data."""
    reply = requests.request(method, API + path, json=data)
    reply.raise_for_status()                 # stop here if Paperclip said no
    return reply.json()


def find(things, key, value):
    """The first thing in a list whose key has this value, or None."""
    for thing in things:
        if thing[key] == value:
            return thing
    return None


def main():
    order = sys.argv[1]
    company = find(send("GET", "/companies"), "name", NAME)
    agents = send("GET", "/companies/" + company["id"] + "/agents")
    cashier = find(agents, "name", "Cashier")

    # A task is called an issue. Giving it to an agent is what wakes the agent.
    task = send("POST", "/companies/" + company["id"] + "/issues",
                {"title": "Bill: " + order, "description": order,
                 "status": "todo", "assigneeAgentId": cashier["id"]})
    print("Created", task["identifier"] + ":", task["title"])

    began = time.time()
    while task["status"] in ("todo", "in_progress"):
        if time.time() - began > 60:
            print("Nobody finished it in 60 seconds.")
            break
        time.sleep(0.5)
        task = send("GET", "/issues/" + task["id"])
    print("Status:", task["status"], f"(after {time.time() - began:.1f} seconds)")
    comments = send("GET", "/issues/" + task["id"] + "/comments")
    if comments:
        newest = comments[0]                 # Paperclip lists the newest comment first
        print("A comment, written by the " + newest["authorType"] + ":")
        print(newest["body"])


if __name__ == "__main__":
    main()

IT PRINTS

Created THR-1: Bill: 2 khao soi, 1 thai iced tea
Status: done (after 1.1 seconds)
A comment, written by the agent:
- 2 x khao soi = 120 baht
- 1 x thai iced tea = 30 baht
- Total: 150 baht

7 correct.py: a task the agent cannot docorrect.py: งานที่เอเจนต์ทำไม่ได้correct.py：智能体做不了的任务

RUN IT · AN ORDER WITH A DISH THE SHOP DOES NOT SELL

venv\Scripts\python order.py "1 pad thai, 2 pizza"

IT PRINTS

Created THR-2: Bill: 1 pad thai, 2 pizza
Status: blocked (after 1.1 seconds)
A comment, written by the agent:
I do not know the price of pizza.

THEN CORRECT IT

venv\Scripts\python correct.py THR-2 "1 pad thai, 2 water"

NEW FILE · correct.py

"""correct.py - write a comment on a task, wait, and print what came back.

    python correct.py THR-2 "1 pad thai, 2 water"

The comment is the corrected order. A comment from a person wakes the agent
that has the task.
"""
import sys
import time

import requests

API = "http://127.0.0.1:3100/api"


def send(method, path, data=None):
    """One request to Paperclip. Returns what it answered, as Python data."""
    reply = requests.request(method, API + path, json=data)
    reply.raise_for_status()                 # stop here if Paperclip said no
    return reply.json()


def main():
    number = sys.argv[1]                     # the task's short name, such as THR-2
    order = sys.argv[2]
    task = send("GET", "/issues/" + number)
    print(task["identifier"], "is", task["status"] + ".")
    send("POST", "/issues/" + task["id"] + "/comments", {"body": order})
    print("You wrote:", order)

    began = time.time()
    while task["status"] != "done":
        if time.time() - began > 30:
            print("Nobody finished it in 30 seconds.")
            break
        time.sleep(0.5)
        task = send("GET", "/issues/" + task["id"])
    print("Status:", task["status"], f"(after {time.time() - began:.1f} seconds)")
    comments = send("GET", "/issues/" + task["id"] + "/comments")
    newest = comments[0]                     # Paperclip lists the newest comment first
    print("A comment, written by the " + newest["authorType"] + ":")
    print(newest["body"])


if __name__ == "__main__":
    main()

IT PRINTS

THR-2 is blocked.
You wrote: 1 pad thai, 2 water
Status: done (after 1.1 seconds)
A comment, written by the agent:
- 1 x pad thai = 60 baht
- 2 x water = 20 baht
- Total: 80 baht

8 runs.py: what the agent printedruns.py: เอเจนต์พิมพ์อะไรออกมาruns.py：智能体打印了什么

RUN IT

venv\Scripts\python runs.py

NEW FILE · runs.py

"""runs.py - list the times Paperclip started the cashier, and what the last one printed.

    python runs.py
"""
import requests

API = "http://127.0.0.1:3100/api"
NAME = "Three Geckos Noodles"


def send(method, path, data=None):
    """One request to Paperclip. Returns what it answered, as Python data."""
    reply = requests.request(method, API + path, json=data)
    reply.raise_for_status()                 # stop here if Paperclip said no
    return reply.json()


def find(things, key, value):
    """The first thing in a list whose key has this value, or None."""
    for thing in things:
        if thing[key] == value:
            return thing
    return None


def main():
    company = find(send("GET", "/companies"), "name", NAME)
    agents = send("GET", "/companies/" + company["id"] + "/agents")
    cashier = find(agents, "name", "Cashier")
    runs = send("GET", "/companies/" + company["id"] + "/heartbeat-runs"
                + "?agentId=" + cashier["id"])
    print(len(runs), "runs, the newest first:")
    for run in runs:
        # invocationSource is why Paperclip started the agent.
        print("   ", run["status"], "- started by:", run["invocationSource"],
              "- exit code:", run["exitCode"])
    for run in runs:
        if run["status"] == "succeeded":     # a run that is still going has no output yet
            finished = send("GET", "/heartbeat-runs/" + run["id"])
            print("The newest finished run printed:")
            print(finished["resultJson"]["stdout"].strip())
            break


if __name__ == "__main__":
    main()

IT PRINTS

3 runs, the newest first:
    succeeded - started by: automation - exit code: 0
    succeeded - started by: assignment - exit code: 0
    succeeded - started by: assignment - exit code: 0
The newest finished run printed:
THR-2 done

9 race.py: two agents, one taskrace.py: เอเจนต์สองตัว งานหนึ่งงานrace.py：两个智能体，一个任务

RUN IT

venv\Scripts\python race.py "3 nam ngiao"

NEW FILE · race.py

"""race.py - two cashiers reach for the same task. Only one of them gets it.

    python race.py "3 nam ngiao"
"""
import sys
import time
from pathlib import Path

import requests

API = "http://127.0.0.1:3100/api"
NAME = "Three Geckos Noodles"


def send(method, path, data=None):
    """One request to Paperclip. Returns what it answered, as Python data."""
    reply = requests.request(method, API + path, json=data)
    reply.raise_for_status()                 # stop here if Paperclip said no
    return reply.json()


def find(things, key, value):
    """The first thing in a list whose key has this value, or None."""
    for thing in things:
        if thing[key] == value:
            return thing
    return None


def main():
    order = sys.argv[1]
    company = find(send("GET", "/companies"), "name", NAME)
    agents_path = "/companies/" + company["id"] + "/agents"
    first = find(send("GET", agents_path), "name", "Cashier")
    second = find(send("GET", agents_path), "name", "Cashier 2")
    if second is None:                       # the same file, hired a second time
        script = Path(__file__).resolve().parent / "cashier.py"
        start = {"command": sys.executable, "args": [str(script)]}
        second = send("POST", agents_path,
                      {"name": "Cashier 2", "role": "general", "title": "Cashier",
                       "adapterType": "process", "adapterConfig": start,
                       "reportsTo": first["reportsTo"]})
        print("Hired Cashier 2.")

    # A task that belongs to nobody. Nobody is woken, so it waits.
    task = send("POST", "/companies/" + company["id"] + "/issues",
                {"title": "Bill: " + order, "description": order, "status": "todo"})
    print("Created", task["identifier"] + ", and gave it to nobody.")

    for cashier in (first, second):
        # No send() here: this time we want to see the answer when it is a no.
        claim = requests.post(API + "/issues/" + task["id"] + "/checkout",
                              json={"agentId": cashier["id"],
                                    "expectedStatuses": ["todo"]})
        print(cashier["name"], "asks for it. Paperclip answers", claim.status_code)
        if claim.status_code == 409:
            print("   ", claim.json()["error"])

    time.sleep(3)                            # the winner is woken, and does the work
    task = send("GET", "/issues/" + task["id"])
    winner = find(send("GET", agents_path), "id", task["assigneeAgentId"])
    print(task["identifier"], "is", task["status"] + ". It was done by",
          winner["name"] + ".")


if __name__ == "__main__":
    main()

IT PRINTS

Hired Cashier 2.
Created THR-3, and gave it to nobody.
Cashier asks for it. Paperclip answers 200
Cashier 2 asks for it. Paperclip answers 409
    Issue checkout conflict
THR-3 is done. It was done by Cashier.

THE HARDER TEST · checks/race_many.py

Round 1: 20 requests at once. Answers: {200: 1, 409: 19}
Round 2: 20 requests at once. Answers: {200: 1, 409: 19}
Round 3: 20 requests at once. Answers: {200: 1, 409: 19}
Round 4: 20 requests at once. Answers: {200: 1, 409: 19}
Round 5: 20 requests at once. Answers: {200: 1, 409: 19}
(could not delete Check race: 500; archived it instead)

checks/same_title.py PRINTS

Same title, same agent, the first still open: the same task came back
Same title, another agent: the same task came back
Same title, given to nobody: the same task came back
Another title, same agent: a new task was made
Same title, same agent, after the first was cancelled: a new task was made
(could not delete Check same title: 500; archived it instead)

10 budget.py and spend.py: a budget that stops an agentbudget.py และ spend.py: งบประมาณที่หยุดเอเจนต์ได้budget.py 和 spend.py：能让智能体停下来的预算

RUN IT

venv\Scripts\python budget.py 100

NEW FILE · budget.py

"""budget.py - say how much the cashier may spend in a month.

    python budget.py 100

The number is in cents, so 100 is one dollar.
"""
import sys
import time

import requests

API = "http://127.0.0.1:3100/api"
NAME = "Three Geckos Noodles"


def send(method, path, data=None):
    """One request to Paperclip. Returns what it answered, as Python data."""
    reply = requests.request(method, API + path, json=data)
    reply.raise_for_status()                 # stop here if Paperclip said no
    return reply.json()


def find(things, key, value):
    """The first thing in a list whose key has this value, or None."""
    for thing in things:
        if thing[key] == value:
            return thing
    return None


def main():
    cents = int(sys.argv[1])
    company = find(send("GET", "/companies"), "name", NAME)
    agents = send("GET", "/companies/" + company["id"] + "/agents")
    cashier = find(agents, "name", "Cashier")
    send("PATCH", "/agents/" + cashier["id"] + "/budgets",
         {"budgetMonthlyCents": cents})
    time.sleep(1)                            # give Paperclip a moment to act on it
    cashier = send("GET", "/agents/" + cashier["id"])
    print("The cashier may spend", cashier["budgetMonthlyCents"], "cents a month.")
    print("Spent so far this month:", cashier["spentMonthlyCents"], "cents.")
    print("The cashier is", cashier["status"] + ".")


if __name__ == "__main__":
    main()

IT PRINTS

The cashier may spend 100 cents a month.
Spent so far this month: 0 cents.
The cashier is idle.

THEN SPEND, THREE TIMES

venv\Scripts\python spend.py
venv\Scripts\python spend.py
venv\Scripts\python spend.py

NEW FILE · spend.py

"""spend.py - tell Paperclip that the cashier has just cost 40 cents.

    python spend.py

The cashier costs nothing to run. An agent that calls a paid AI model does,
and after each run Paperclip is told what the run cost. This file sends one
such report by hand, so that you can see what a budget does.
"""
import time

import requests

API = "http://127.0.0.1:3100/api"
NAME = "Three Geckos Noodles"
COST = 40                                    # in cents


def send(method, path, data=None):
    """One request to Paperclip. Returns what it answered, as Python data."""
    reply = requests.request(method, API + path, json=data)
    reply.raise_for_status()                 # stop here if Paperclip said no
    return reply.json()


def find(things, key, value):
    """The first thing in a list whose key has this value, or None."""
    for thing in things:
        if thing[key] == value:
            return thing
    return None


def main():
    company = find(send("GET", "/companies"), "name", NAME)
    agents = send("GET", "/companies/" + company["id"] + "/agents")
    cashier = find(agents, "name", "Cashier")
    # The time now, in the form Paperclip asks for: 2026-10-09T14:43:20Z
    # The Z says it is UTC, the clock that is the same in every country.
    now = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
    send("POST", "/companies/" + company["id"] + "/cost-events",
         {"agentId": cashier["id"], "provider": "pretend", "model": "pretend",
          "inputTokens": 1000, "outputTokens": 200, "costCents": COST,
          "occurredAt": now})
    print("Reported a cost of", COST, "cents.")
    time.sleep(1)                            # give Paperclip a moment to act on it
    cashier = send("GET", "/agents/" + cashier["id"])
    print("Spent this month:", cashier["spentMonthlyCents"], "of",
          cashier["budgetMonthlyCents"], "cents.")
    print("The cashier is", cashier["status"] + ".")
    if cashier["pauseReason"]:
        print("Reason:", cashier["pauseReason"])


if __name__ == "__main__":
    main()

THE FIRST TIME IT PRINTS

Reported a cost of 40 cents.
Spent this month: 40 of 100 cents.
The cashier is idle.

THE SECOND TIME

Reported a cost of 40 cents.
Spent this month: 80 of 100 cents.
The cashier is idle.

THE THIRD TIME

Reported a cost of 40 cents.
Spent this month: 120 of 100 cents.
The cashier is paused.
Reason: budget

AN ORDER FOR A PAUSED CASHIER

venv\Scripts\python order.py "2 water"

IT PRINTS

Created THR-4: Bill: 2 water
Status: blocked (after 8.0 seconds)
A comment, written by the system:
Paperclip cannot safely continue automatic recovery because the original assignee is not invokable. The source assignment is unchanged and the board must choose the next action.

RAISE THE BUDGET, THEN ANSWER THE TASK

venv\Scripts\python budget.py 1000
venv\Scripts\python correct.py THR-4 "2 water"

budget.py PRINTS

The cashier may spend 1000 cents a month.
Spent so far this month: 120 cents.
The cashier is idle.

correct.py PRINTS

THR-4 is blocked.
You wrote: 2 water
Status: done (after 1.7 seconds)
A comment, written by the agent:
- 2 x water = 20 baht
- Total: 20 baht

checks/two_budgets.py PRINTS

PATCH /agents/{id}: budget 100, spent 120, status idle, pause reason None
PATCH /agents/{id}/budgets: budget 100, spent 120, status paused, pause reason budget
(could not delete Check two budgets: 500; archived it instead)

11 report.py: everything is written downreport.py: ทุกอย่างถูกจดไว้report.py：每件事都记了下来

RUN IT

venv\Scripts\python report.py

NEW FILE · report.py

"""report.py - the state of the company, and the last things that happened in it.

    python report.py
"""
import requests

API = "http://127.0.0.1:3100/api"
NAME = "Three Geckos Noodles"


def send(method, path, data=None):
    """One request to Paperclip. Returns what it answered, as Python data."""
    reply = requests.request(method, API + path, json=data)
    reply.raise_for_status()                 # stop here if Paperclip said no
    return reply.json()


def find(things, key, value):
    """The first thing in a list whose key has this value, or None."""
    for thing in things:
        if thing[key] == value:
            return thing
    return None


def main():
    company = find(send("GET", "/companies"), "name", NAME)
    board = send("GET", "/companies/" + company["id"] + "/dashboard")
    print("Agents:", board["agents"])
    print("Tasks:", board["tasks"])
    print("Spent this month:", board["costs"]["monthSpendCents"], "cents")

    events = send("GET", "/companies/" + company["id"] + "/activity")
    print(len(events), "things are in the activity log. The newest ten:")
    for event in events[:10]:
        clock = event["createdAt"][11:19]    # the time of day, taken out of the date
        what = event["details"].get("identifier", "")
        print("   ", clock, event["actorType"], event["action"], what)


if __name__ == "__main__":
    main()

IT PRINTS

Agents: {'active': 3, 'running': 0, 'paused': 0, 'error': 0}
Tasks: {'open': 0, 'inProgress': 0, 'blocked': 0, 'done': 4}
Spent this month: 120 cents
50 things are in the activity log. The newest ten:
    14:49:51 agent environment.lease_released 
    14:49:51 agent issue.comment_added THR-4
    14:49:51 agent issue.updated THR-4
    14:49:51 agent issue.checked_out 
    14:49:50 agent environment.lease_acquired 
    14:49:49 user issue.recovery_action_resolved THR-4
    14:49:49 user issue.comment_added THR-4
    14:49:49 user issue.updated THR-4
    14:49:48 user budget.policy_upserted 
    14:49:48 user agent.budget_updated 

12 A model and a web searchโมเดลหนึ่งตัว กับการค้นเว็บ一个模型，和一次网络搜索

TERMINAL 2 · WINDOWS · on a Mac, write venv/bin/python (not run by us) · บน Mac ให้เขียน venv/bin/python (เราไม่ได้รันเอง) · 在 Mac 上写 venv/bin/python（我们没有运行过）

ollama pull qwen2.5:3b
venv\Scripts\python -m pip install ddgs

13 paper_agent.py: four employees in one filepaper_agent.py: พนักงานสี่คนในไฟล์เดียวpaper_agent.py：一个文件里的四个员工

NEW FILE · paper_agent.py

"""paper_agent.py - four employees in one file. The word after the file name says which.

Paperclip starts this file each time one of them has work to do:

    python paper_agent.py reviewer     gives the paper a quality score from 1 to 100
    python paper_agent.py researcher   searches the web for facts the paper lacks
    python paper_agent.py writer       writes the paper again
    python paper_agent.py overseer     sends the paper round until the score is high enough

The reviewer, the researcher and the writer think with a model on your own
computer, through Ollama. The overseer has no model in it: it is a loop.
"""
import json
import os
import sys
import time

import requests
from ddgs import DDGS
from ddgs.exceptions import DDGSException

# What the reviewer is told. The score is its judgment of the whole paper.
REVIEW = """You review research papers for a software company. The people who read
them decide what the engineers build next. Give this paper a quality score from
1 to 100. A paper earns a high score when it asks one clear question, answers it
with evidence, says where each fact comes from, says what the change would cost,
answers the strongest objection, and ends with one thing to do next."""


def pack(job):
    """A job as one text: each part under a line with its name, like "=== paper ==="."""
    text = ""
    for name, value in job.items():
        text = text + f"=== {name} ===\n{value}\n"
    return text


def unpack(text):
    """The other way round: the text of a task, back into a job."""
    job = {}
    for part in ("\n" + text).split("\n=== ")[1:]:
        name, value = part.split(" ===\n", 1)
        job[name] = value.strip()
    return job


class PaperAgent:
    def __init__(self, kind):
        self.kind = kind                     # work() reads this to choose the job
        self.api = os.environ["PAPERCLIP_API_URL"] + "/api"
        self.me = os.environ["PAPERCLIP_AGENT_ID"]
        self.company = os.environ["PAPERCLIP_COMPANY_ID"]
        # The key says who is asking. The run id ties each change to this run.
        self.headers = {"Authorization": "Bearer " + os.environ["PAPERCLIP_API_KEY"],
                        "X-Paperclip-Run-Id": os.environ["PAPERCLIP_RUN_ID"]}

    def ask(self, method, path, data=None):
        """One request to Paperclip, made as this agent. Returns Python data."""
        reply = requests.request(method, self.api + path, headers=self.headers, json=data)
        reply.raise_for_status()             # stop here if Paperclip said no
        return reply.json()

    def think(self, job, instructions, text, as_json=False):
        """One question to the model. Returns what it wrote."""
        question = {"model": job["model"], "stream": False,
                    "messages": [{"role": "system", "content": instructions},
                                 {"role": "user", "content": text}],
                    # temperature 0: the same question gets the same answer.
                    # num_ctx: room for the paper, the notes and the template together.
                    "options": {"temperature": 0, "num_ctx": 8192}}
        if as_json:
            question["format"] = "json"      # the model must answer in JSON
        reply = requests.post(job["ollama"] + "/api/chat", json=question, timeout=1800)
        reply.raise_for_status()
        return reply.json()["message"]["content"].strip()

    def review(self, job):
        """The reviewer's job. Returns "Score: 72" and, under it, what to fix."""
        instructions = REVIEW
        if job["template"]:
            instructions += ("\n\nThis paper got a high score before. "
                             "Use it as your picture of a 90:\n\n" + job["template"])
        instructions += ('\n\nAnswer in JSON with two keys. "score": a whole number '
                         'from 1 to 100. "fixes": a list of three sentences. Each one '
                         "names a thing in this paper to fix.")
        answer = json.loads(self.think(job, instructions, job["paper"], as_json=True))
        lines = ["Score: " + str(int(answer["score"]))]
        for point in answer["fixes"]:
            lines.append("- " + str(point))
        return "\n".join(lines)

    def research(self, job):
        """The researcher's job. Returns notes from the web, each with its address."""
        instructions = ("A reviewer scored this paper. Write two web searches that would "
                        "find the facts the paper lacks. Answer in JSON with one key. "
                        '"searches": a list of two short web searches.')
        text = "THE PAPER\n" + job["paper"] + "\n\nTHE REVIEWER\n" + job["review"]
        answer = json.loads(self.think(job, instructions, text, as_json=True))
        notes = []
        for search in answer["searches"][:2]:
            try:
                hits = DDGS().text(str(search), max_results=3)
            except DDGSException:            # the search found nothing, or was refused
                hits = []
            for hit in hits:
                notes.append("- " + hit["body"] + " (" + hit["href"] + ")")
        if not notes:
            notes.append("- The searches found nothing. Add no new facts.")
        return "\n".join(notes)

    def rewrite(self, job):
        """The writer's job. Returns the paper, written again."""
        instructions = ("Write this paper again so that it earns a higher score. Fix what "
                        "the reviewer asks for. Take facts only from the notes, and say in "
                        "the sentence where each fact comes from. Keep what the paper "
                        "recommends. "
                        "Answer with the paper only: its title, then its paragraphs. "
                        "Write nothing about the paper after its last paragraph.")
        if job["template"]:
            instructions += ("\n\nHere is another paper, about another subject. It got a "
                             "high score. Copy how it is built. Take no fact and no "
                             "sentence from it:\n\n" + job["template"])
        text = ("THE PAPER\n" + job["paper"] + "\n\nTHE REVIEWER\n" + job["review"]
                + "\n\nNOTES FROM THE WEB\n" + job["notes"])
        return self.think(job, instructions, text)

    def hand_to(self, name, title, parent, job):
        """Give a job to another agent, wait until it is done, and return its answer."""
        worker = None
        for agent in self.ask("GET", "/companies/" + self.company + "/agents"):
            if agent["name"] == name:
                worker = agent
        # A task with a title that is still open would come back instead of a new
        # one, so every title carries its round number.
        task = self.ask("POST", "/companies/" + self.company + "/issues",
                        {"title": title, "description": pack(job), "status": "todo",
                         "assigneeAgentId": worker["id"], "parentId": parent["id"]})
        while task["status"] != "done":
            if task["status"] == "blocked":  # Paperclip blocks a task when its run fails
                raise SystemExit(name + " could not finish " + task["identifier"])
            time.sleep(2)
            task = self.ask("GET", "/issues/" + task["id"])
        comments = self.ask("GET", "/issues/" + task["id"] + "/comments")
        return comments[0]["body"]           # the newest comment is the answer

    def oversee(self, job, task):
        """The overseer's job. Returns the best score, and the paper that got it."""
        paper = job["paper"]
        target = int(job["target"])          # every part of a job arrives as text
        rounds = int(job["rounds"])
        best_score = 0                       # lower than any score, so round 1 beats it
        for turn in range(1, rounds + 1):
            job = dict(job, paper=paper)     # a copy of the job, holding the newest paper
            report = self.hand_to("Reviewer", f"Review the paper, round {turn}", task, job)
            score = int(report.splitlines()[0].split()[1])
            self.ask("POST", "/issues/" + task["id"] + "/comments",
                     {"body": f"Round {turn}. {report}"})
            if score > best_score:           # a rewrite can be worse: keep the best one
                best_score = score
                best_paper = paper
                best_turn = turn
            if score >= target or turn == rounds:
                break                        # good enough, or out of rounds: stop
            job = dict(job, review=report)
            notes = self.hand_to("Researcher", f"Find facts, round {turn}", task, job)
            job = dict(job, notes=notes)
            paper = self.hand_to("Writer", f"Rewrite the paper, round {turn}", task, job)
        return (f"Best score: {best_score}, in round {best_turn} of {turn}. "
                f"The target was {target}.\n\n{best_paper}")

    def work(self):
        """Do every task that Paperclip has given to this agent."""
        mine = (f"/companies/{self.company}/issues"
                f"?assigneeAgentId={self.me}&status=todo,in_progress")
        for task in self.ask("GET", mine):
            task_path = "/issues/" + task["id"]
            # No ask() here: a 409 is an answer we expect, and we carry on after it.
            claim = requests.post(self.api + task_path + "/checkout", headers=self.headers,
                                  json={"agentId": self.me,
                                        "expectedStatuses": ["todo", "in_progress"]})
            if claim.status_code == 409:     # another run already has this task
                continue
            claim.raise_for_status()
            # In the list, a long description is cut short. Asked for alone, it is whole.
            task = self.ask("GET", task_path)
            job = unpack(task["description"])
            if self.kind == "reviewer":
                answer = self.review(job)
            elif self.kind == "researcher":
                answer = self.research(job)
            elif self.kind == "writer":
                answer = self.rewrite(job)
            else:
                answer = self.oversee(job, task)
            self.ask("PATCH", task_path, {"status": "done", "comment": answer})
            print(task["identifier"], self.kind, "done")


def main():
    if len(sys.argv) < 2 or "PAPERCLIP_API_KEY" not in os.environ:
        print("Paperclip starts this file. You run paper.py.")
        return
    agent = PaperAgent(sys.argv[1])
    agent.work()


if __name__ == "__main__":
    main()

checks/long_text.py PRINTS

Sent: 4,700 characters
The task asked for alone: 4,700 characters
The same task in the list of tasks: 1,200 characters
JSON sent:      '{"paper": "Line one.\\nLine two."}'
JSON came back: '{"paper": "Line one.\nLine two."}'
Python cannot read it back as JSON: Invalid control character at: line 1 column 21 (char 20)

14 paper.py: hand in a paperpaper.py: ส่งรายงานเข้าไปpaper.py：交上一篇报告

NEW FILE · paper.py

"""paper.py - give a research paper to a team of four agents, and get it back with a higher score.

    python paper.py paper.txt
    python paper.py paper.txt --template model_paper.txt --target 85

The team is paper_agent.py, which must be in this folder. Ollama must be running.
"""
import argparse
import sys
import time
from pathlib import Path

import requests

API = "http://127.0.0.1:3100/api"
OLLAMA = "http://127.0.0.1:11434"
NAME = "Research Desk"
# (name, role, the word that paper_agent.py is started with)
TEAM = [("Overseer", "ceo", "overseer"), ("Reviewer", "general", "reviewer"),
        ("Researcher", "general", "researcher"), ("Writer", "general", "writer")]


def send(method, path, data=None):
    """One request to Paperclip. Returns what it answered, as Python data."""
    reply = requests.request(method, API + path, json=data)
    reply.raise_for_status()                 # stop here if Paperclip said no
    return reply.json()


def find(things, key, value):
    """The first thing in a list whose key has this value, or None."""
    for thing in things:
        if thing[key] == value:
            return thing
    return None


def pack(job):
    """A job as one text: each part under a line with its name, like "=== paper ==="."""
    text = ""
    for name, value in job.items():
        text = text + f"=== {name} ===\n{value}\n"
    return text


def options():
    """Read what was typed after "python paper.py"."""
    parser = argparse.ArgumentParser(description="Improve a research paper with four agents.")
    parser.add_argument("paper", help="the paper, a text file")
    parser.add_argument("--template", help="a paper that got a high score before")
    parser.add_argument("--target", type=int, default=85, help="stop at this score")
    parser.add_argument("--rounds", type=int, default=3, help="stop after this many reviews")
    parser.add_argument("--model", default="qwen2.5:3b", help="a model Ollama has")
    return parser.parse_args()


def text_of(name):
    """What a text file holds, or "" when no file was named."""
    if name is None:
        return ""
    return Path(name).read_text(encoding="utf-8").strip()


def team(company):
    """The four agents, by name. Each one is hired first if the company lacks it."""
    agents_path = "/companies/" + company["id"] + "/agents"
    script = Path(__file__).resolve().parent / "paper_agent.py"
    hired = {}
    for name, role, word in TEAM:
        agent = find(send("GET", agents_path), "name", name)
        if agent is None:
            # A model can take minutes, so each run may last an hour.
            start = {"command": sys.executable, "args": [str(script), word],
                     "timeoutSec": 3600}
            details = {"name": name, "role": role, "adapterType": "process",
                       "adapterConfig": start}
            if name != "Overseer":
                details["reportsTo"] = hired["Overseer"]["id"]
            agent = send("POST", agents_path, details)
            print("Hired", name + ".")
        hired[name] = agent
    return hired


def follow(task):
    """Print each comment on a task as it arrives, until the task is done or stuck."""
    shown = 0
    while True:
        task = send("GET", "/issues/" + task["id"])
        comments = send("GET", "/issues/" + task["id"] + "/comments")
        comments.reverse()                   # Paperclip lists the newest first
        for comment in comments[shown:]:
            print(comment["body"])
            print()
        shown = len(comments)
        if task["status"] in ("done", "blocked"):
            print("The task is", task["status"] + ".")
            return
        time.sleep(2)


def main():
    chosen = options()
    company = find(send("GET", "/companies"), "name", NAME)
    if company is None:
        company = send("POST", "/companies", {"name": NAME})
        print("Opened", NAME + ".")
    hired = team(company)
    job = {"paper": text_of(chosen.paper),
           "template": text_of(chosen.template), "target": chosen.target,
           "rounds": chosen.rounds, "model": chosen.model, "ollama": OLLAMA}
    started = time.time()
    # The whole job travels in the task's description, as text.
    task = send("POST", "/companies/" + company["id"] + "/issues",
                {"title": "Improve " + chosen.paper + ", " + time.strftime("%H:%M:%S"),
                 "description": pack(job), "status": "todo",
                 "assigneeAgentId": hired["Overseer"]["id"]})
    print("Created", task["identifier"] + ":", task["title"])
    print()
    follow(task)
    print(f"That took {time.time() - started:.0f} seconds.")


if __name__ == "__main__":
    main()

THE PAPER · paper.txt

Should our team write the tests first?

Our team writes the code and then writes tests later, if there is time. I think we should write the tests first. This is called test-driven development. It makes the code better and there are fewer bugs.

Writing tests first is a good idea because you think about what the code should do before you write it. Many companies do it. Our last release had a lot of bugs and customers were unhappy. Tests would have found them.

Some people say writing tests first is slow. But fixing bugs is slower. So we should write the tests first on every project.

RUN IT · PAPERCLIP AND OLLAMA MUST BOTH BE RUNNING

venv\Scripts\python paper.py paper.txt

IT PRINTS

Opened Research Desk.
Hired Overseer.
Hired Reviewer.
Hired Researcher.
Hired Writer.
Created RES-1: Improve paper.txt, 10:22:29

Round 1. Score: 45
- The paper does not clearly state the main question it is trying to answer.
- The paper does not provide evidence to support the claim that writing tests first makes the code better and finds fewer bugs.
- The paper does not address the cost of writing tests first and does not mention what the change would cost.

Round 2. Score: 45
- The paper does not address the cost of writing tests first, which is a crucial point for a decision-making process.
- The paper does not explicitly state what the change would cost, making it difficult to make a fully informed decision.
- The paper does not answer the strongest objection, which is the claim that writing tests first is slow.

Round 3. Score: 55
- The paper does not address the cost of writing tests first, which is a crucial factor in deciding whether to adopt TDD.
- The paper does not explicitly state the strongest objection to writing tests first and does not address it.
- The paper does not conclude with a clear next step, instead ending with a discussion of the benefits of TDD.

Best score: 55, in round 3 of 3. The target was 85.

Should our team write the tests first?

Our team writes the code and then writes tests later, if there is time. I think we should write the tests first. This is called test-driven development. It makes the code better and there are fewer bugs. According to the notes, Test-Driven Development (TDD) is a software development practice where test cases are written before code implementation. ISM eCompany, who specializes in web solutions, is adapting their development process to become more agile. One of those adaptations is introducing TDD into their development process, to have projects with a better code quality and a regression test suite. This aligns with the idea that TDD can optimize the development process and reduce costs. The notes also mention a case study that shows how TDD can assist companies in reducing project costs and enhancing quality software. Therefore, writing tests first is a good idea because it allows us to think about what the code should do before we write it, which can lead to fewer bugs. Additionally, the cost of writing tests first is not addressed in the notes, but the benefits of TDD in terms of code quality and cost reduction suggest that the benefits outweigh any potential costs. Our last release had a lot of bugs and customers were unhappy. Tests would have found them, supporting the idea that writing tests first can improve the quality of the code. Some people say writing tests first is slow. But fixing bugs is slower. So we should write the tests first on every project.

The notes from the web provide further insights. The 2025 guide to software development costs reveals real budgets, hidden fees, and smart tactics to keep projects on time and on budget. (https://datadrivendaily.com/software-development-costs/) Test-Driven Development (TDD) is a Software development method in which you write Automation Tests before the actual development process starts, which is coding. Here we are learning TDD in detail with these important points related to the same. (https://www.geeksforgeeks.org/software-engineering/test-driven-development/) Test-driven development improves code quality but costs velocity. See what the research says and when TDD actually pays off for your team. (https://www.arielsoftwares.com/test-driven-development/) May 29, 2023 · Learn what Test-Driven Development is, how it connects to testing, and why it can optimize your development process and reduce costs. (https://accedia.com/insights/blog/test-driven-development-key-for-reducing-development-costs) Jun 24, 2023 · Test-Driven Development (TDD) is a methodology in software development that necessitates tests to be written before to the production code. This approach can be used in any software... (https://www.researchgate.net/publication/372832171_Test_Driven_Development_and_Its_Impact_on_Program_Design_and_Software_Quality_A_Systematic_Literature_Review) Jun 8, 2026 · Test-driven development improves code quality but costs velocity. See what the research says and when TDD actually pays off for your team. (https://www.arielsoftwares.com/test-driven-development/)

The task is done.
That took 190 seconds.

15 A paper to learn from, and a bigger modelรายงานตัวอย่างให้เรียนรู้ และโมเดลที่ใหญ่ขึ้น一篇可以学的范文，和一个更大的模型

THE TEMPLATE · model_paper.txt

Should every change be reviewed before it is merged?

Question. Today one of our engineers can merge a change that nobody else has read. This paper asks whether a second engineer should read every change first, and it recommends yes, for a trial of one quarter.

Evidence. In the last quarter our service had 14 incidents. The incident reports say that 9 of them began with a change only its author had seen. In the same quarter the payments team, which already reviews every change, had 2 incidents for a similar number of changes. These are our own numbers, from the incident log, and one quarter is a small sample.

Cost. A review is not free. The payments team measured it: a change waits about four hours for a reviewer, and a review takes about twenty minutes of the reviewer's day. For our team of eight that is roughly one engineer-day a week.

The strongest objection is speed: an urgent fix cannot wait four hours. The answer is a rule for that case. An urgent fix may be merged at once, and it is reviewed the next morning.

Next step. Turn on required review for the service on the first day of next quarter. At the end of the quarter, count the incidents and the hours changes waited, and decide with those two numbers.

RUN IT · THE SAME PAPER, THE SAME SMALL MODEL

venv\Scripts\python paper.py paper.txt --template model_paper.txt --target 85

IT PRINTS

Created RES-9: Improve paper.txt, 10:25:49

Round 1. Score: 55
- The paper does not provide evidence for the claim that writing tests first improves code quality and reduces bugs.
- The objection about the time it takes to write tests first is not addressed in detail and lacks supporting data.
- The recommendation to write tests first on every project is too broad and lacks specific context or evidence for all projects.

Round 2. Score: 40
- The paper does not provide evidence for the claim that writing tests first improves code quality and reduces bugs.
- The objection about the time it takes to write tests first is not addressed in detail and lacks supporting data.
- The recommendation to write tests first on every project is too broad and lacks specific context or evidence for all projects.

Round 3. Score: 40
- Provide specific evidence for the claim that writing tests first improves code quality and reduces bugs, such as case studies or data from previous projects.
- Address the objection about the time it takes to write tests first with more detailed data or examples, such as the impact on development speed and overall project timelines.
- Offer more specific context or evidence for when writing tests first would be beneficial, rather than recommending it for every project.

Best score: 55, in round 1 of 3. The target was 85.

Should our team write the tests first?

Our team writes the code and then writes tests later, if there is time. I think we should write the tests first. This is called test-driven development. It makes the code better and there are fewer bugs.

Writing tests first is a good idea because you think about what the code should do before you write it. Many companies do it. Our last release had a lot of bugs and customers were unhappy. Tests would have found them.

Some people say writing tests first is slow. But fixing bugs is slower. So we should write the tests first on every project.

The task is done.
That took 174 seconds.

THE SAME AGAIN, WITH A LARGER MODEL

venv\Scripts\python paper.py paper.txt --template model_paper.txt --model qwen2.5:14b

IT PRINTS

Created RES-17: Improve paper.txt, 10:28:43

Round 1. Score: 50
- The paper lacks a clear, specific question. It should ask, 'Does our team reduce bugs and improve customer satisfaction by writing tests before code?'
- The evidence provided is insufficient and lacks a direct link to the proposed change. Include data from teams that practice test-driven development and compare their bug rates and customer satisfaction with similar teams that do not.
- The cost of implementing test-driven development is not addressed. Include an estimate of the time and resources required to train the team and the potential impact on project timelines.

Round 2. Score: 85
- The paper should specify the exact source of the ResearchGate study and the AirWatch case study to provide clear references.
- The paper needs to quantify the cost of training and the initial time investment for TDD, providing a more concrete estimate of the financial impact.
- The paper should address the strongest objection more thoroughly, such as providing specific examples of how TDD can be integrated into the current workflow without significantly increasing development time.

Best score: 85, in round 2 of 2. The target was 85.

THE PAPER
Should our team reduce bugs and improve customer satisfaction by writing tests before code?

Our team currently writes code and then writes tests later, if there is time. This paper argues that we should adopt test-driven development (TDD), where tests are written before the code. TDD is a practice where developers write unit tests before writing the code that will pass those tests. According to a study published on ResearchGate (Apr 10, 2020), TDD improves the effectiveness of unit test cases compared to incremental test-last development in an industrial context. Additionally, AirWatch, a company that adopted TDD, achieved significant improvements in test coverage, reduced bugs in production, and increased the speed of development (Sep 8, 2024).

Writing tests first is beneficial because it forces developers to think about the desired functionality before writing the code, leading to better-designed code and fewer bugs. Our last release had a high number of bugs, which resulted in customer dissatisfaction. If we had implemented TDD, these bugs could have been caught earlier, improving customer satisfaction.

Some argue that TDD is slow and increases development time. However, studies show that while TDD may initially increase development time, it ultimately reduces the time to market and decreases the number of bugs, which can be more costly to fix later (ResearchGate, Sep 8, 2024).

The cost of implementing TDD includes training the team and the initial time investment. According to a case study by Accedia (Sep 8, 2024), while TDD can lead to higher initial costs, it ultimately reduces development costs by catching bugs early and improving code quality.

Next step. We should start a trial of TDD on one project for one quarter. At the end of the quarter, we will measure the number of bugs and customer satisfaction levels. We will also track the time spent on training and the impact on project timelines. Based on these metrics, we can decide whether to continue with TDD or revert to our current practice.

The task is done.
That took 445 seconds.