Tworzenie agenta Harness od zera: sześć etapów i eksperyment izolujący osiągnięcia
Używając harnessu można poprawić wyniki testów bardziej niż sam model. Stwórz mały harness dla agenta w sześciu etapach i testuj po jednej zmianie, aby sprawdzić, co faktycznie pomogło.
Źródła: Build an Agent Harness, Then Prove Which Change Moved the Score
Weź jeden model graniczny oraz dwa narzędzia oceny. Za pomocą pierwszego osiągnął on 62,7 procenta w teście rozumowania, a za pomocą drugiego 99,9 procenta – wszystko to w tym samym tygodniu. Ta różnica wynosząca 37,2 punktu była większa niż różnica 32,5 punktu pomiędzy dwoma najlepszymi wynikami na liście liderów. Zatem mechanizm otaczający model, odrębny od samego modelu, może wpłynąć na wyniki bardziej niż sam model. Poniżej znajduje się opis składników tego mechanizmu, krótka instrukcja budowy w sześciu etapach oraz ostatni krok pokazujący, które z wprowadzonych zmian faktycznie poprawiły wynik.
Co znajduje się w narzędziu oceny
Narzędzie oceny składa się z sześciu elementów, z których żaden nie dotyka wag modelu.
- Instrukcja systemowa, czyli informacje przekazywane modelowi na temat jego roli i ograniczeń przed rozpoczęciem zadania.
- Dostęp do narzędzi: czy model może uruchamiać kod, czytać pliki lub korzystać z API, oraz co otrzymuje w zamian?
Każdy z tych elementów to decyzja podjęta przez kogoś. Wybierając określoną ramę, przejmujemy jej decyzje, nie widząc ich. To działa dobrze, dopóki nie musimy wyjaśnić, dlaczego nasze wyniki różnią się od wyników kogoś innego.
Dlaczego to ma znaczenie
Efekt ten jest widoczny w mniejszym stopniu w codziennej pracy. Wyobraźmy sobie dwa modele o różnicy 0,7 punktu w teście kodowania, gdzie zmiana narzędzi powoduje różnicę wyników około 5 punktów. Różnica, którą proszono o wykrycie, stanowi zatem około jednej siódmej szumu w pomiarach. Publiczny przykład pokazuje to samo: wynik interaktywnego testu dla jednego modelu podobno potroił się, gdy jego dostawca włączył dwie ustawienia umożliwiające mu zachowanie toku rozumowania z jednej rundy na drugą. To ten sam model, który po prostu mógł zachować swój własny sposób działania.
Najlepszym przykładem jest historia z życia wzięta. Podobno jeden inżynier wziął jedno zadanie programistyczne i wykonał je pięć razy na tym samym modelu, dodając za każdym razem jeden element zestawu. Pusty repozytorium dawał około 20 procent skuteczności. Plik z instrukcjami podniósł ten wskaźnik do około 60 procent, polecenia weryfikacyjne do 80 procent, a plik z informacjami o postępach niemal do 100 procent. Nikt nie potwierdził tych danych, więc należy je traktować jedynie jako ilustrację. Ważna jest struktura, ponieważ pozwala ona odróżnić wpływ każdego dodanego elementu, czego nie da się zrobić przy porównaniu dwóch kompletnych zestawów.
Opublikowane prace wskazują na to samo. Jedna z technik rozwija prompty poprzez analizę wcześniejszych prób i ma przewagę 10 procent w porównaniu z bazą opartą na uczeniu się wzmacniającym, a nawet do 20 procent, przy jednoczesnym zmniejszeniu liczby prób aż o 35 razy. Inna technika traktuje zgromadzony kontekst jako rozwijającą się instrukcję postępowania, co przynosi poprawę na poziomie 10,6 procent w zadaniach dla agentów. Stały notatnik umożliwił jednemu modelowi osiągnięcie wyniku od 10 do 99 procent w zadaniu polegającym na rozwiązywaniu zagadek. Wektory wag pozostały niezmienione we wszystkich trzech przypadkach.
Jedno ustalenie jest sprzeczne z drugim. Artykuł z 2026 roku podzielił ten system na cztery części, z których każda mogła się rozwijać, i oczekiwał, że taka struktura przyniesie korzyści. Wyniki wyniosły 0,657 w porównaniu z 0,642 przy rozwijaniu pojedynczej, płaskiej ciągi znaków – różnica, którą autorzy określają jako nieistotną. Ich zdaniem ustalony budżet optymalizacji rozdzielony na cztery części daje każdej z nich mniej informacji. Dodatkowa struktura z reguły nie pomaga, a ten wynik zerowy ma większą wartość niż te pozytywne, ponieważ wyklucza interpretację „bezpłatnego obiadu”.
Budowa w sześciu etapach
Całość składa się z około stu linijek kodu i nie wymaga żadnego frameworka. Wystarczy dostarczyć jedną funkcję, która wysyła tekst do modelu i zwraca tekst.
Pierwszym etapem jest najprostsza możliwa operacja: przyjąć zadanie, wywołać model z odpowiednim promptem i zmierzyć czas trwania tej operacji.
import time
def run_task(task, call_model):
t0 = time.time()
output = call_model(task["prompt"])
return {"id": task["id"], "output": output,
"seconds": round(time.time() - t0, 2)}
Druga faza umożliwia modelowi działanie i widzenie. Narzędzie pomocnicze wykonywa komendę w shellu w katalogu roboczym z ograniczeniem czasowym.
import subprocess
def run_command(cmd, workdir, timeout=60):
try:
r = subprocess.run(cmd, shell=True, cwd=workdir, timeout=timeout,
capture_output=True, text=True)
return {"exit": r.returncode, "stdout": r.stdout[-4000:],
"stderr": r.stderr[-4000:]}
except subprocess.TimeoutExpired:
return {"exit": None, "stdout": "", "stderr": "timed out"}
Dwie z twoich decyzji są już tam zawarte. Wynik jest ograniczony do ostatnich 4000 znaków, a polecenia przestają działać po 60 sekundach. Obie zmieniają to, co widzi model, więc obie powinny znaleźć się w twoich notatkach jako część narzędzi, a nie samego zadania.
Trzeci etap decyduje o tym, co zostanie przekazane pomiędzy rundami, tworząc listę wiadomości na podstawie instrukcji systemu, zadania oraz historii.
def build_messages(task, history, carry_reasoning=True):
msgs = [{"role": "system", "content": SYSTEM},
{"role": "user", "content": task["prompt"]}]
for turn in history:
if carry_reasoning:
msgs.append({"role": "assistant", "content": turn["output"]})
msgs.append({"role": "user", "content": format_result(turn["result"])})
return msgs
Uczyń przenoszenie rozumowania flagą, a nie stałym wyborem, ponieważ będziesz chciał mierzyć obie te ustawienia.
Etap czwarty analizuje działanie wychodzące z wyników modelu, nie kończąc się w tajemnicy bez błędu.
import re
ACTION = re.compile(r"<action>(.*?)</action>", re.S)
def parse_action(output):
m = ACTION.search(output)
if m:
return m.group(1).strip(), "matched"
fence = chr(96) * 3
alt = re.search(fence + r"(?:bash|sh)?\n(.*?)" + fence, output, re.S)
if alt:
return alt.group(1).strip(), "fallback_fenced"
return None, "no_match"
Zapisz drugą wartość zwracaną, ponieważ zawiera ona najwięcej informacji. Gdy znaczna część prób kończy się użyciem rozwiązania awaryjnego, parser mierzy przede wszystkim formatowanie, a nie możliwości modelu, więc wynik nie pozwala odróżnić tych dwóch aspektów. Podobna historia ostrzegawcza: detektor sprawdzający, czy model twierdził, że skończył pracę, przeszedł pięć przypadków walidacji, ale przeoczył dwa oczywiste oświadczenia ze względu na to, że kropka w nazwie pliku przerwała wzorzec oparty na zdaniach. Transkrypcje wskazywały, że testy przeszły pomyślnie, podczas gdy detektor nie odnotował żadnych takich oświadczeń.
Faza piąta to pętla, z maksymalną liczbą rund wynoszącą osiem.
MAX_TURNS = 8
def agent_loop(task, call_model, carry_reasoning=True):
history, workdir = [], task["dir"]
for turn in range(MAX_TURNS):
out = call_model(build_messages(task, history, carry_reasoning))
action, parse_status = parse_action(out)
result = run_command(action, workdir) if action else {"note": "no action"}
history.append({"output": out, "result": result, "parse": parse_status})
if action and task["done"](workdir):
return {"solved": True, "turns": turn + 1, "history": history}
return {"solved": False, "turns": MAX_TURNS, "history": history}
Tutaj task[„done”] to funkcja, którą sam dostarczasz i która bada rzeczywistość zamiast ufać twierdzeniom modelu. To właśnie ta różnica przekształca demonstrację w pomiar.
Szósty etap to to, co czyni z całej tej struktury narzędzie: funkcja eksperymentalna, która wykonywa każde zadanie w ramach każdej warianty, powtarzając każde z nich kilka razy.
def experiment(tasks, call_model, variants, runs_per=2):
results = []
for name, config in variants.items():
for task in tasks:
for r in range(runs_per):
out = agent_loop(task, call_model, **config)
results.append({"variant": name, "task": task["id"], "run": r,
"solved": out["solved"], "turns": out["turns"],
"fallbacks": sum(1 for h in out["history"]
if h["parse"] != "matched")})
return results
variants = {"carry_on": {"carry_reasoning": True},
"carry_off": {"carry_reasoning": False}}
Zmień jedną rzecz, pozostaw resztę bez zmian, uruchom obie wersje i porównaj je. Ta metoda jest brakująca w niemal każdym opublikowanym porównaniu. Zmień jednocześnie model, prompt oraz limit liczby ruchów – w ten sposób nic się nie dowiesz na temat tego, co wpłynęło na wynik.
Co mierzyć i czego oczekiwać
Warto śledzić cztery wartości liczbowe. Po pierwsze, szybkość rozwiązywania dla każdej wersji. Po drugie, liczbę ruchów potrzebnych do rozwiązania, ponieważ wersja osiągająca ten sam wynik przy mniejszej liczbie ruchów jest tańsza. Po trzecie, częstotliwość uciekania się do rozwiązania awaryjnego podczas analizy tekstu. Po czwarte, różnicę między wynikami powtarzanych prób wykonywania tej samej zadania, co jest najbardziej informacyjne. Jeśli identyczne próby dają różne wyniki, szum może być większy niż efekt, który chcesz zaobserwować.
Nie dziw się, jeśli pierwszy wynik pokaże, że obie wersje są na równi. W jednym testie tego projektu dwa modele porównawcze wykonały po dwa razy po dziesięć prostych zadań naprawczych, a wszystkie próby zakończyły się sukcesem, więc nic nie odróżniało tych modeli. Zadania były zbyt proste, by można je było od siebie odróżnić. To jest typowy wynik i wskazuje na charakter zadań, a nie na same modele. Wybieraj zadania, które dają średni wskaźnik rozwiązywalności, znacznie poniżej maksymalnego poziomu.
Ograniczenia
„Układ wspomagający” nie może nadać modelowi umiejętności, których brakuje w jego wagach, więc każdy postęp jest ograniczony tym, co te wagi mogą obsłużyć. Układ dostosowany do twoich zadań również nie będzie skuteczny. To, co sprawdza się przy naprawianiu kodu, niekoniecznie sprawdzi się przy otwartej eksploracji, ponieważ rodzaje błędów się różnią.
Zatem chodziło nigdy nie o to, że model nie ma znaczenia. Porównania traktują oba modele tak, jakby zmieniała się tylko jedna z nich, podczas gdy zmieniają się obie, a raportuje się tylko jedną.
Podobne materiały
- Stwórz Multi-Agent Router z LangGraph i agentem nadzorczym — Jak podzielić jeden przeciążony agent na specjalistów przy użyciu agenta nadzorczego w LangGraph, wykorzystując gotowe narzędzia pomocnicze oraz ręcznie tworzony StateGraph, a także omówić projektowanie stanów i typowe pułapki.
- Samolecząca zespół multi-agentów w LangGraph: architekt, tester, debugger — Stwórz maszynę stanów w LangGraph w Pythonie, w której architekt, programista, środowisko testowe pytest, debugger i recenzent współpracują ze sobą w pętli, aż testy się udają.