✨ Agno: a company of AI agents, managed from Python · Agno: บริษัทของเอเจนต์ AI ที่บริหารด้วย Python · Agno：用 Python 管理的一家 AI 智能体公司

1 Install Agno and two models · ติดตั้ง Agno และโมเดลสองตัว · 安装 Agno 和两个模型

python -m venv venv
venv\Scripts\python -m pip install agno ollama openai "sqlalchemy[asyncio]" aiosqlite "fastapi[standard]" requests
ollama pull qwen2.5:3b
ollama pull qwen2.5:14b

2 hello.py: one agent · hello.py: เอเจนต์หนึ่งตัว · hello.py：一个智能体

"""hello.py - one agent, one question, one answer.

    python hello.py
"""
from agno.agent import Agent
from agno.models.ollama import Ollama

MODEL = "qwen2.5:3b"


def main():
    agent = Agent(model=Ollama(id=MODEL), instructions="Answer in one short sentence.")
    run = agent.run("What is the capital of Thailand?")
    print("The agent says:", run.content)
    print("Model:", run.model)
    print("Tokens:", run.metrics.input_tokens, "in,", run.metrics.output_tokens, "out")


if __name__ == "__main__":
    main()

venv\Scripts\python hello.py

The agent says: The capital of Thailand is Bangkok.
Model: qwen2.5:3b
Tokens: 26 in, 8 out

3 cashier.py: Python does the sum · cashier.py: ให้ Python เป็นคนบวกเลข · cashier.py：让 Python 来算账

"""cashier.py - an agent with one tool. The model reads the order, Python does the sum.

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

from agno.agent import Agent
from agno.models.ollama import Ollama

MODEL = "qwen2.5:3b"
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: str) -> str:
    """Add up an order of the noodle shop.

    Args:
        order: the dishes and how many of each, such as "2 khao soi, 1 water"
    """
    lines = []
    total = 0
    for part in order.lower().split(","):
        words = part.split()
        if len(words) < 2 or not words[0].isdigit():
            return "I cannot read this part of the order: " + part.strip()
        count = int(words[0])
        dish = " ".join(words[1:])
        if dish not in PRICES:
            return "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 "\n".join(lines)


def main():
    order = sys.argv[1]
    cashier = Agent(
        name="Cashier",
        # temperature 0: the model gives the likeliest answer every time
        model=Ollama(id=MODEL, options={"temperature": 0}),
        tools=[bill],
        instructions="You are the cashier of a noodle shop. Use the bill tool for "
                     "every order. Then reply with the bill the tool returned, word "
                     "for word. Never work out or guess a price yourself.",
    )
    run = cashier.run(order)
    for call in run.tools:
        print("The agent called:", call.tool_name, call.tool_args)
        print("The tool returned:")
        print(call.result)
    print("The agent says:")
    print(run.content)


if __name__ == "__main__":
    main()

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

The agent called: bill {'order': '2 khao soi, 1 thai iced tea'}
The tool returned:
- 2 x khao soi = 120 baht
- 1 x thai iced tea = 30 baht
- Total: 150 baht
The agent says:
The total bill is 150 baht.

bill_with_hint:
    I was handed a str: '2 khao soi, 1 thai iced tea'
bill_without_hint:
    I was handed a dict: {'khao soi': 2, 'thai iced tea': 1}

4 shop.py: the org chart · shop.py: ผังองค์กร · shop.py：组织架构

"""shop.py - the whole company in one file: two employees, their boss, and the books.

    python shop.py          prints the org chart, and starts no model

The other files on the page import from this one. Nothing is built when it is
imported: each function builds its part when it is called.
"""
from agno.agent import Agent
from agno.db.sqlite import SqliteDb
from agno.models.ollama import Ollama
from agno.team import Team
from agno.team.mode import TeamMode
from agno.tools import tool

WORKER = "qwen2.5:3b"       # the model the employees think with
LEADER = "qwen2.5:14b"      # the model the boss thinks with: bigger, and slower
DB_FILE = "shop.db"         # the books: every conversation is saved in this file
PRICES = {"khao soi": 60, "nam ngiao": 50, "pad thai": 60, "pad see ew": 55,
          "thai iced tea": 30, "longan juice": 25, "water": 10}
MINUTES = {"khao soi": 6, "nam ngiao": 7, "pad thai": 8, "pad see ew": 8,
           "thai iced tea": 2, "longan juice": 1}


# stop_after_tool_call: what this function returns is the answer. The model
# chooses the tool and reads the order, and it does not get to reword the bill.
@tool(stop_after_tool_call=True)
def bill(order: str) -> str:
    """Add up an order of the noodle shop.

    Args:
        order: the dishes and how many of each, such as "2 khao soi, 1 water"
    """
    lines = []
    total = 0
    for part in order.lower().split(","):
        words = part.split()
        if len(words) < 2 or not words[0].isdigit():
            return "I cannot read this part of the order: " + part.strip()
        count = int(words[0])
        dish = " ".join(words[1:])
        if dish not in PRICES:
            return "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 "\n".join(lines)


@tool(stop_after_tool_call=True)
def cooking_time(dish: str) -> str:
    """Say how many minutes one dish of the noodle shop takes to cook.

    Args:
        dish: the name of one dish, such as "pad thai"
    """
    dish = dish.lower().strip()
    if dish not in MINUTES:
        return "We do not cook " + dish + "."
    return f"{dish} takes {MINUTES[dish]} minutes."


# requires_confirmation: the agent may ask for this tool, and then it has to wait
# until a person says yes.
@tool(requires_confirmation=True)
def refund(baht: int) -> str:
    """Give money back to a customer.

    Args:
        baht: how many baht to give back
    """
    return f"Refunded {baht} baht."


def local_model(name):
    # temperature 0: the model gives its likeliest answer every time
    return Ollama(id=name, options={"temperature": 0})


def books():
    """The file where Agno saves every conversation and every run."""
    return SqliteDb(db_file=DB_FILE)


def cashier(db):
    return Agent(
        name="Cashier", id="cashier", role="Adds up the bill for an order",
        model=local_model(WORKER), tools=[bill], db=db,
        # the agent is shown what was said before in the same conversation
        add_history_to_context=True,
        instructions="You are the cashier of a noodle shop. Use the bill tool for "
                     "every order. Never work out or guess a price yourself.",
    )


def refunds(db):
    return Agent(
        name="Refunds", id="refunds", role="Gives money back, when the owner agrees",
        model=local_model(WORKER), tools=[refund], db=db,
        instructions="When you are asked to give money back, use the refund tool "
                     "with the number of baht. Then say what the tool returned.",
    )


def cook(db):
    return Agent(
        name="Cook", id="cook", role="Knows how long each dish takes to cook",
        model=local_model(WORKER), tools=[cooking_time], db=db,
        instructions="You are the cook of a noodle shop. Use the cooking_time tool "
                     "for every question about a dish.",
    )


def team(db, leader=LEADER):
    return Team(
        name="Three Geckos Noodles", id="three-geckos", model=local_model(leader),
        members=[cashier(db), cook(db)], db=db,
        # route: the boss picks one employee, and that employee's answer is the answer
        mode=TeamMode.route,
        # the employee gets the customer's own words, not the boss's version of them
        determine_input_for_members=False,
        instructions="You are Noi, the owner of a noodle shop. You never answer "
                     "yourself. An order, which is dishes with numbers, goes to the "
                     "Cashier, who writes the bill. A question about how long a dish "
                     "takes goes to the Cook.",
    )


def main():
    shop = team(books())
    print(shop.name)
    print("    Noi, the owner. Model:", shop.model.id)
    for member in shop.members:
        # a plain function has __name__; one wrapped by @tool has name
        tools = ", ".join(getattr(one, "__name__", None) or one.name for one in member.tools)
        print("        " + member.name, "(" + member.role + ")")
        print("            model:", member.model.id, "  tools:", tools)


if __name__ == "__main__":
    main()

venv\Scripts\python shop.py

Three Geckos Noodles
    Noi, the owner. Model: qwen2.5:14b
        Cashier (Adds up the bill for an order)
            model: qwen2.5:3b   tools: bill
        Cook (Knows how long each dish takes to cook)
            model: qwen2.5:3b   tools: cooking_time

5 order.py: a conversation that is kept · order.py: บทสนทนาที่ถูกเก็บไว้ · order.py：一段被保存下来的对话

"""order.py - three messages from one table, in one conversation that is saved.

    python order.py

The second order has a dish the shop does not sell. The third message corrects
it, and the cashier is shown what was said before.
"""
from shop import books, cashier

TABLE = "table-4"       # the name of the conversation: Agno calls it a session
MESSAGES = ["2 khao soi, 1 thai iced tea",
            "1 pad thai, 2 pizza",
            "Sorry, no pizza. Make that 1 pad thai, 2 water."]


def main():
    agent = cashier(books())
    for message in MESSAGES:
        run = agent.run(message, session_id=TABLE)
        print("Customer:", message)
        for call in run.tools or []:
            print("    the model asked for:", call.tool_name, call.tool_args)
        print("Cashier:", run.content)
        print(f"    ({run.metrics.total_tokens} tokens, {run.metrics.duration:.1f} seconds)")


if __name__ == "__main__":
    main()

venv\Scripts\python order.py

Customer: 2 khao soi, 1 thai iced tea
    the model asked for: bill {'order': '2 khao soi, 1 thai iced tea'}
Cashier: - 2 x khao soi = 120 baht
- 1 x thai iced tea = 30 baht
- Total: 150 baht
    (249 tokens, 2.7 seconds)
Customer: 1 pad thai, 2 pizza
    the model asked for: bill {'order': '1 pad thai, 2 pizza'}
Cashier: I do not know the price of pizza.
    (333 tokens, 2.8 seconds)
Customer: Sorry, no pizza. Make that 1 pad thai, 2 water.
    the model asked for: bill {'order': '1 pad thai, 2 water'}
Cashier: - 1 x pad thai = 60 baht
- 2 x water = 20 baht
- Total: 80 baht
    (404 tokens, 2.2 seconds)

Customer: 2 khao soi, 1 thai iced tea
    the tool returned: - Total: 150 baht
    the cashier said:  The total bill is 150 baht.
    They agree.
Customer: 1 pad thai, 2 pizza
    the tool returned: I do not know the price of pizza.
    the cashier said:  I need the price of pizza to calculate the total. Please provide the price or I can only calculate f
    THEY DO NOT AGREE.
Customer: Sorry, no pizza. Make that 1 pad thai, 2 water.
    the tool returned: - Total: 80 baht
    the cashier said:  The total bill is 80 baht.
    They agree.
2 of 3 replies agree with the tool.

6 team.py: who gets the question · team.py: ใครได้รับคำถาม · team.py：问题交给了谁

"""team.py - ask the shop, and see which employee the boss gave the question to.

    python team.py "2 khao soi, 1 water" "How long does pad thai take?"
"""
import sys

from shop import books, team


def main():
    shop = team(books())
    for question in sys.argv[1:]:
        run = shop.run(question)
        print("Customer:", question)
        for answer in run.member_responses:
            print("    Noi gave it to:", answer.agent_name)
        print("The shop says:", run.content)
        print(f"    ({run.metrics.total_tokens} tokens, {run.metrics.duration:.1f} seconds)")


if __name__ == "__main__":
    main()

venv\Scripts\python team.py "2 khao soi, 1 water" "How long does pad thai take?"

Customer: 2 khao soi, 1 water
    Noi gave it to: Cashier
The shop says: - 2 x khao soi = 120 baht
- 1 x water = 10 baht
- Total: 130 baht
    (650 tokens, 72.6 seconds)
Customer: How long does pad thai take?
    Noi gave it to: Cook
The shop says: pad thai takes 8 minutes.
    (642 tokens, 16.5 seconds)

The boss thinks with qwen2.5:3b
    2 khao soi, 1 water                    -> nobody   WRONG   said: Delegate to the Cashier with the provided or
    How long does pad thai take?           -> nobody   WRONG   said: (nothing)
    1 pad thai, 2 thai iced tea            -> nobody   WRONG   said: Delegate to member cashier with the provided
    How many minutes for khao soi?         -> nobody   WRONG   said: (nothing)
    3 water                                -> nobody   WRONG   said: delegate_task_to_member {"member_id": "cook"
    How long does nam ngiao take to cook?  -> nobody   WRONG   said: (nothing)
    0 of 6 right, in 8 seconds
The boss thinks with qwen2.5:14b
    2 khao soi, 1 water                    -> Cashier  right   said: - Total: 130 baht
    How long does pad thai take?           -> Cook     right   said: pad thai takes 8 minutes.
    1 pad thai, 2 thai iced tea            -> Cashier  right   said: - Total: 120 baht
    How many minutes for khao soi?         -> Cook     right   said: khao soi takes 6 minutes.
    3 water                                -> Cashier  right   said: - Total: 30 baht
    How long does nam ngiao take to cook?  -> Cook     right   said: nam ngiao takes 7 minutes.
    6 of 6 right, in 102 seconds

7 approve.py: wait for the owner's yes · approve.py: รอคำว่า “ได้” จากเจ้าของ · approve.py：等老板点头

"""approve.py - an agent asks to give money back, and waits for the owner's answer.

    python approve.py yes
    python approve.py no
"""
import sys

from shop import books, refunds


def main():
    owner_says = sys.argv[1]
    agent = refunds(books())
    run = agent.run("Table 4 had a cold khao soi. Give them back 60 baht.",
                    session_id="refund-" + owner_says)
    print("Status:", run.status.value)
    for need in run.active_requirements:
        asked = need.tool_execution
        print("The agent wants to call:", asked.tool_name, asked.tool_args)
        if owner_says == "yes":
            need.confirm()
        else:
            need.reject("The owner said no.")
    print("The owner says:", owner_says)

    # The run was saved in the books when it paused. This picks it up again.
    run = agent.continue_run(run_id=run.run_id, session_id=run.session_id,
                             requirements=run.requirements)
    print("Status:", run.status.value)
    print("Refunds says:", run.content)


if __name__ == "__main__":
    main()

venv\Scripts\python approve.py yes
venv\Scripts\python approve.py no

Status: PAUSED
The agent wants to call: refund {'baht': 60}
The owner says: yes
Status: COMPLETED
Refunds says: I have refunded 60 baht to Table 4.

Status: PAUSED
The agent wants to call: refund {'baht': 60}
The owner says: no
Status: COMPLETED
Refunds says: It seems the owner did not agree to give you the refund. Please check with the owner again.

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

"""budget.py - a budget of tokens. When it is spent, the cashier takes no more orders.

    python budget.py

A token is a piece of a word. It is the unit a paid model is billed in, so a
budget of tokens is a budget of money.
"""
from agno.exceptions import InputCheckError

from shop import books, cashier

BUDGET = 800            # tokens that one conversation may use
TABLE = "table-9"
ORDERS = ["1 khao soi", "2 water", "1 pad see ew, 1 longan juice", "3 thai iced tea",
          "1 nam ngiao"]


def spent(agent):
    """The tokens this conversation has used so far, read from the books."""
    session = agent.get_session(session_id=TABLE)
    if session is None:
        return 0
    return sum(run.metrics.total_tokens for run in session.runs)


def check_budget(agent):
    """Agno calls this before every run, and hands it the agent."""
    if spent(agent) >= BUDGET:
        # of all the errors a hook can raise, this is the kind that stops the run
        raise InputCheckError(f"The budget of {BUDGET} tokens is spent.")


def main():
    agent = cashier(books())
    agent.pre_hooks = [check_budget]
    for order in ORDERS:
        run = agent.run(order, session_id=TABLE)
        print(f"{order}: {run.status.value}. {run.content.splitlines()[-1]}")
        print(f"    spent {spent(agent)} of {BUDGET} tokens")


if __name__ == "__main__":
    main()

venv\Scripts\python budget.py

1 khao soi: COMPLETED. - Total: 60 baht
    spent 235 of 800 tokens
2 water: COMPLETED. - Total: 20 baht
    spent 527 of 800 tokens
1 pad see ew, 1 longan juice: COMPLETED. - Total: 80 baht
    spent 899 of 800 tokens
ERROR   Validation failed: The budget of 800 tokens is spent. | Check trigger: CheckTrigger.INPUT_NOT_ALLOWED
3 thai iced tea: ERROR. The budget of 800 tokens is spent.
    spent 899 of 800 tokens
ERROR   Validation failed: The budget of 800 tokens is spent. | Check trigger: CheckTrigger.INPUT_NOT_ALLOWED
1 nam ngiao: ERROR. The budget of 800 tokens is spent.
    spent 899 of 800 tokens

ERROR   Pre-hook #1 execution failed
refuse_with_stop:
    status: COMPLETED
    the cashier said: - Total: 60 baht
ERROR   Validation failed: The budget is spent. | Check trigger: CheckTrigger.INPUT_NOT_ALLOWED
refuse_with_check:
    status: ERROR
    the cashier said: The budget is spent.

9 runs.py: everything is written down · runs.py: ทุกอย่างถูกจดไว้ · runs.py：一切都有记录

"""runs.py - read the books: every conversation, every run, every tool call.

    python runs.py

It starts no model. It only reads shop.db, the file the agents wrote.
"""
from agno.db.base import SessionType

from shop import books


def main():
    db = books()
    sessions = db.get_sessions(session_type=SessionType.AGENT)
    print(len(sessions), "conversation(s) in the books.")
    for session in sessions:
        runs = session.runs or []
        print(f"{session.session_id}: {len(runs)} run(s) by {session.agent_id}")
        total = 0
        for run in runs:
            calls = [call.tool_name for call in run.tools or []]
            total = total + run.metrics.total_tokens
            print(f"    {run.status:10} {run.metrics.total_tokens:5} tokens   "
                  f"tools: {', '.join(calls) or 'none'}   said: {str(run.input.input_content)[:40]}")
        print(f"    {total} tokens in all")


if __name__ == "__main__":
    main()

venv\Scripts\python runs.py

4 conversation(s) in the books.
table-4: 3 run(s) by cashier
    COMPLETED    249 tokens   tools: bill   said: 2 khao soi, 1 thai iced tea
    COMPLETED    333 tokens   tools: bill   said: 1 pad thai, 2 pizza
    COMPLETED    404 tokens   tools: bill   said: Sorry, no pizza. Make that 1 pad thai, 2
    986 tokens in all
refund-yes: 1 run(s) by refunds
    COMPLETED    490 tokens   tools: refund   said: Table 4 had a cold khao soi. Give them b
    490 tokens in all
refund-no: 1 run(s) by refunds
    COMPLETED    494 tokens   tools: refund   said: Table 4 had a cold khao soi. Give them b
    494 tokens in all
table-9: 5 run(s) by cashier
    COMPLETED    235 tokens   tools: bill   said: 1 khao soi
    COMPLETED    292 tokens   tools: bill   said: 2 water
    COMPLETED    372 tokens   tools: bill   said: 1 pad see ew, 1 longan juice
    ERROR          0 tokens   tools: none   said: 3 thai iced tea
    ERROR          0 tokens   tools: none   said: 1 nam ngiao
    899 tokens in all

10 serve.py and client.py · serve.py และ client.py · serve.py 和 client.py

"""serve.py - the shop as a server: Agno's AgentOS, on this computer only.

    python serve.py         leave it running, and use client.py in a second terminal

Stop it with Ctrl+C.
"""
import uvicorn
from agno.os import AgentOS

from shop import books, cashier, cook, refunds, team


def main():
    db = books()
    manager = AgentOS(
        name="Three Geckos Noodles",
        agents=[cashier(db), cook(db), refunds(db)],
        teams=[team(db)],
        db=db,
        # Agno reports anonymous usage numbers to its makers unless this is False
        telemetry=False,
    )
    # 127.0.0.1 is this computer talking to itself: nothing else on the network can reach it
    uvicorn.run(manager.get_app(), host="127.0.0.1", port=7777)


if __name__ == "__main__":
    main()

"""client.py - talk to the shop's server from another program, with plain requests.

    python client.py "1 nam ngiao, 1 water"

serve.py must be running in another terminal. This file imports nothing from
Agno: any program, in any language, could send these requests.
"""
import sys

import requests

API = "http://127.0.0.1:7777"


def main():
    order = sys.argv[1]
    print("The server says:", requests.get(API + "/health").json()["status"])

    print("Agents on it:")
    for agent in requests.get(API + "/agents").json():
        tools = [one["name"] for one in agent["tools"]["tools"]]
        print("   ", agent["id"], "-", agent["role"], "- tools:", ", ".join(tools))
    for team in requests.get(API + "/teams").json():
        print("Team:", team["id"], "- mode:", team["mode"])

    # The order goes in as form fields. stream=false: wait, and get one whole answer.
    form = {"message": order, "stream": "false", "session_id": "table-7"}
    run = requests.post(API + "/agents/cashier/runs", data=form).json()
    print("Run", run["status"], "by", run["agent_id"], "in", run["session_id"] + ":")
    print(run["content"])
    print("   ", run["metrics"]["total_tokens"], "tokens")

    sessions = requests.get(API + "/sessions", params={"type": "agent"}).json()["data"]
    print("Conversations the server knows:")
    for session in sessions:
        print("   ", session["session_id"], "-", session["agent_id"], "-",
              session["total_tokens"], "tokens")


if __name__ == "__main__":
    main()

venv\Scripts\python serve.py
venv\Scripts\python client.py "1 nam ngiao, 1 water"

The server says: ok
Agents on it:
    cashier - Adds up the bill for an order - tools: bill
    cook - Knows how long each dish takes to cook - tools: cooking_time
    refunds - Gives money back, when the owner agrees - tools: refund
Team: three-geckos - mode: route
Run COMPLETED by cashier in table-7:
- 1 x nam ngiao = 50 baht
- 1 x water = 10 baht
- Total: 60 baht
    241 tokens
Conversations the server knows:
    table-7 - cashier - 241 tokens
    table-9 - cashier - 899 tokens
    refund-no - refunds - 720 tokens
    refund-yes - refunds - 716 tokens
    table-4 - cashier - 986 tokens

11 research.py: three agents and a loop · research.py: เอเจนต์สามตัวกับลูปหนึ่งลูป · research.py：三个智能体和一个循环

"""research.py - a research paper assistant for a software team: three agents and a loop.

    python research.py paper.txt

A reviewer gives the paper a quality score from 1 to 100. A researcher searches
the web for the facts it lacks. A writer writes it again. The loop in main()
sends the paper round those three until the score reaches TARGET, or the rounds
run out. Ollama must be running.
"""
import sys
import time
from pathlib import Path

from agno.agent import Agent
from agno.db.sqlite import SqliteDb
from agno.models.ollama import Ollama
from agno.tools import tool
from ddgs import DDGS
from ddgs.exceptions import DDGSException
from pydantic import BaseModel, Field

MODEL = "qwen2.5:3b"
TARGET = 85             # stop when the reviewer gives this score
ROUNDS = 3              # stop after this many reviews
DB_FILE = "research.db"


class Review(BaseModel):
    """The form the reviewer has to fill in. Agno makes the model keep to it."""
    score: int = Field(ge=1, le=100, description="the quality of the paper, from 1 to 100")
    fixes: list[str] = Field(min_length=3, max_length=3,
                             description="three sentences, each naming a thing to fix")


# stop_after_tool_call: the notes go back as the search engine gave them. The
# model chooses the search, and it does not retell the pages.
@tool(stop_after_tool_call=True)
def search_web(search: str) -> str:
    """Search the web, and get the first three results with their addresses.

    Args:
        search: a short web search, such as "test-driven development defect study"
    """
    try:
        hits = DDGS().text(search, max_results=3)
    except DDGSException:       # the search found nothing, or was refused
        return "- The search found nothing. Add no new facts."
    return "\n".join("- " + hit["body"] + " (" + hit["href"] + ")" for hit in hits)


def team(db):
    """The three agents, by the name of their job."""
    # temperature 0: the same question gets the same answer.
    # num_ctx: room for the paper, the review and the notes together.
    model = Ollama(id=MODEL, options={"temperature": 0, "num_ctx": 8192})
    reviewer = Agent(
        name="Reviewer", id="reviewer", model=model, db=db, output_schema=Review,
        instructions="You review research papers for a software company. The people "
                     "who read them decide what the engineers build next. Give the "
                     "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.",
    )
    researcher = Agent(
        name="Researcher", id="researcher", model=model, db=db, tools=[search_web],
        instructions="You are given a paper and a review of it. Use the search_web "
                     "tool once, with one short search that would find the facts the "
                     "paper lacks.",
    )
    writer = Agent(
        name="Writer", id="writer", model=model, db=db,
        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.",
    )
    return reviewer, researcher, writer


def main():
    paper = Path(sys.argv[1]).read_text(encoding="utf-8").strip()
    reviewer, researcher, writer = team(SqliteDb(db_file=DB_FILE))
    session = "paper-" + time.strftime("%H%M%S")       # one conversation for each try
    started = time.time()
    best_score = 0
    for turn in range(1, ROUNDS + 1):
        review = reviewer.run(paper, session_id=session).content
        print(f"Round {turn}. Score: {review.score}")
        for fix in review.fixes:
            print("- " + fix)
        print()
        if review.score > best_score:   # a rewrite can be worse: keep the best one
            best_score = review.score
            best_paper = paper
            best_turn = turn
        if review.score >= TARGET or turn == ROUNDS:
            break                       # good enough, or out of rounds: stop
        said = "\n".join(review.fixes)
        both = "THE PAPER\n" + paper + "\n\nTHE REVIEWER\n" + said
        notes = researcher.run(both, session_id=session).content
        print("Notes from the web:")
        print(notes)
        print()
        paper = writer.run(both + "\n\nNOTES FROM THE WEB\n" + notes,
                           session_id=session).content
    print(f"Best score: {best_score}, in round {best_turn} of {turn}. "
          f"The target was {TARGET}.")
    print()
    print(best_paper)
    print()
    print(f"That took {time.time() - started:.0f} seconds.")


if __name__ == "__main__":
    main()

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.

venv\Scripts\python -m pip install ddgs
venv\Scripts\python research.py paper.txt

Round 1. Score: 45
- The paper does not clearly define what 
-  
-  should write tests for (e.g., unit tests, integration tests, etc.). It also does not specify the scope of the tests (e.g., all functions, just critical ones). The paper does not address the cost of writing tests first. It does not mention any objections to writing tests first. The paper ends with a recommendation to write tests first on every project, which is not a clear next step.

Notes from the web:
- This blog post by Seb Rose examines the prevalent objections to Test-Driven Development (TDD) and offers well-founded refutations. Drawing on data from a comprehensive survey, it categorizes 896 objections into five main areas: education, project constraints, cultural challenges, time... (https://www.slideserve.com/tirza/common-objections-to-tdd-and-their-refutations)
- 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)
- By introducing TDD in two projects of ISM we tried to determine whether TDD is cost-effective by determining the Return on Investment (ROI). This cost-effectiveness could, due to the insufficient dataset, only be assessed in a limited way. In the monitored projects the developers took 31% more time for developing work items. (https://repository.tudelft.nl/file/File_610a728a-f779-43c5-b02b-65dced138f16)

Round 2. Score: 25
- Clearly define what tests should be written and specify the scope of the tests.
- Address the cost of writing tests first.
- Address the strongest objection to writing tests first.

Notes from the web:
- Discover how Test-Driven Development can improve your software testing process with this comprehensive guide. Learn the benefits and best practices here. (https://www.practitest.com/resource-center/article/tdd-guide/)
- Test-driven development (TDD) is a software development approach in which automated tests are written before the production code they validate. The tests define the expected behavior, and the code evolves to satisfy them. (https://testsigma.com/blog/test-driven-development/)
- 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-tdd/)

Round 3. Score: 30
- Clearly define what tests should be written and specify the scope of the tests.
- Address the cost of writing tests first.
- Address the strongest objection to writing tests first.

Best score: 45, 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.

That took 136 seconds.