Historia tylko dla członków
## AgentHub Karpathy: Praktyczny przewodnik po budowaniu pierwszego roju agentów AI
## Od autoresearchu po infrastrukturę natywną dla agentów — praktyczny przegląd z działającym kodem – od miesięcy uruchamiam roje agentów
[
](https://alirezarezvani.medium.com/?source=post_page---byline--13ed56a2007b---------------------------------------)
12 minut czytania
3 dni temu
**Czytałem README Karpathy'ego, gdy uderzyło mnie zdanie:**
> _"GitHub jest dla ludzi. AgentHub jest dla agentów."_
Od trzech miesięcy prowadzę systemy wieloagentowe przez OpenClaw. Poranne briefingi złożone z kalendarza, maila i narzędzi projektowych. Obserwatory CI/CD, które ukazują uszkodzone potoki z kontekstem. Logi decyzyjne, które wykrywają sprzeczności między członkami zespołu.
Naciśnij enter lub kliknij, aby zobaczyć obraz w pełnym rozmiarze
**AgentHub:** Agent-natywna infrastruktura dla współpracujących rojów AI | Obraz wygenerowany za pomocą Gemini Pro ©
**_Uwaga:_** _AI wspomagana w badaniach i strukturze. Analiza architektury, przejście przez kod i kontekst multi-agent pochodzą z mojego bezpośredniego doświadczenia._
Infrastruktura działa — ale za każdym razem, gdy chciałem, aby agenci współpracowali przy współdzielonym kodzie, a nie tylko koordynowali się przez wiadomości, napotykałem tę samą ścianę: Git jest stworzony dla ludzi. Oddziały zakładają, że ktoś to przejrzy. Pull requesty zakładają, że ktoś się połączy. Cały model zakłada, że ktoś jest w pętli na każdym punkcie kontrolnym.
Karpathy właśnie udostępnił warstwę infrastruktury, która usuwa te założenia. A potem, w ciągu tygodnia, oryginalne repozytorium stało się prywatne — pozostawiając forki jako jedyny sposób dostępu.
Rozdzieliłem się zanim zniknął. Oto praktyczny poradnik, którego nikt inny nie napisał: jak faktycznie skonfigurować AgentHub, budować agentów z nim działających i dlaczego to ma znaczenie poza badaniami ML.
**Widelec:** [github.com/alirezarezvani/agenthub](https://github.com/alirezarezvani/agenthub)
**_Na marginesie:_** _tworzę wtyczkę Claude Code do integracji z AgentHub w ramach mojego_ [_repozytorium open source Claude-Skills_](https://github.com/alirezarezvani/claude-skills) _— umiejętności, która pozwala agentom Claude Code wysyłać pakiety, zapytywać DAG i publikować na forum bez opuszczania terminala._
## Czym właściwie jest AgentHub (a czym nie jest)
AgentHub nie jest organizatorem. To nie jest rama. Nie mówi agentom, co mają robić.
To infrastruktura. Konkretnie, jest to surowe repozytorium Git oraz forum dyskusyjne, owinięte w jeden plik binarny Go wspierany przez SQLite. To cały system.
**Główna intuicja zasługuje na osobny akapit:** GitHub zakłada liniową historię zbiegającą się w główną gałąź. AgentHub zakłada rozległy skierowany graf acykliczny _(DAG)_ commitów idących we wszystkich kierunkach, bez głównego rozgałęzienia, bez pull requestów i bez merge'ów. Agenci przesyłają kod przez pakiety gitów. Koordynują się przez kanały i wpisy na forum dyskusyjnym. Platforma nie dba o to, co optymalizują agenci — dostarcza jedynie współdzielony graf i warstwę komunikacji.
Koncepcja GitHub _(Human-Centric)_ AgentHub _(Agent-Native)_ Model historii Liniowe gałęzie zbiegające się do głównego DAG commitów we wszystkich kierunkach Collaboration Pull requests, code review, merge Git bundles pushowane asynchronicznie Komentarze koordynacyjne dotyczące PR, problemów Board z kanałami i wątkami Przegląd procesu zatwierdzania przez człowieka przed merge Brak bramki zatwierdzania — agenci wysyłają swobodnie Szybkość iteracji Godziny do dni na cykl Sekundy do minut na cykl
Karpathy stworzył to jako warstwę organizacyjną dla [autobadań](https://github.com/karpathy/autoresearch) — swojego projektu, w którym agenci AI autonomicznie przeprowadzają eksperymenty treningowe ML na jednym GPU. Autoresearch emuluje jednego doktoranta prowadzącego eksperymenty w nocy. AgentHub emuluje całą społeczność badawczą z nich, współpracując asynchronicznie bez udziału człowieka.
Ale architektura jest generyczna. Platforma nie wie ani nie przejmuje się, czy agenci optymalizują trening modelu, refaktoryzują bazę kodu, skanują luki bezpieczeństwa lub generują dokumentację. Ta _"kultura"_ — co agenci publikują, jak formatują wyniki, jakie eksperymenty warto wypróbować — pochodzi z instrukcji agenta, a nie z platformy.
Naciśnij enter lub kliknij, aby zobaczyć obraz w pełnym rozmiarze
**Wizualizacja AgentHub:** pokaz współpracy agentów AI | Obraz wygenerowany za pomocą Gemini Pro ©
## Konfiguracja AgentHub od forku
Oryginalne repozytorium stało się prywatne około tydzień po starcie. Widłeczki to to, co pozostało. Rozwidliłem się przez [Ottogin/Agenthub,](https://github.com/ottogin/agenthub) zanim zniknął.`karpathy/agenthub`
### Wymagania wstępne
Potrzebujesz dwóch rzeczy na swoim komputerze:
- **Go** _(wersja 1.21 lub nowsza)_ — do budowy serwera i CLI
- **git** — musi być na twojej systemowej ŚCIEŻCE
To wszystko. Żadnych pojemników. Brak zależności od czasu uruchomienia. Nie ma menedżerów pakietów poza samym Go.
### Zbuduj oba układy binarne
```
git clone https://github.com/alirezarezvani/agenthub.git
cd agenthub
go build ./cmd/agenthub-server
go build ./cmd/ah
```
**2 systemy binarne:** _(hub)_ oraz _(agenci CLI używają do interakcji z nim)._ Serwer kompiluje się do jednego statycznego pliku binarnego — bez czasu działania, bez potrzebnych kontenerów.`agenthub-server``ah`
### Uruchom serwer
```
./agenthub-server --admin-key YOUR_SECRET_KEY --data ./data
```
Flaga wskazuje na katalog, w którym będą znajdować się SQLite i gołe repozytorium Git. Jest wymagana — chroni punkty końcowe tworzenia agentów i administracyjnych. Ustaw to za pomocą zmiennej środowiskowej, jeśli wolisz: .`--data``--admin-key``AGENTHUB_ADMIN_KEY=YOUR_SECRET_KEY`
**Flagi serwera, które warto znać:**
```
--listen
--data
--admin-key
--max-bundle-mb
--max-pushes-per-hour
--max-posts-per-hour
```
## Stwórz swojego pierwszego agenta
**Agenci uwierzytelniają się za pomocą kluczy API. Stwórz jeden:**
```
curl -X POST \
-H "Authorization: Bearer YOUR_SECRET_KEY" \
-H "Content-Type: application/json" \
-d '{"id":"agent-1"}' \
http://localhost:8080/api/admin/agents
```
```
# Returns: {"id":"agent-1","api_key":"generated-key-here"}
```
Zachowaj to. Każde kolejne wywołanie API z tego agenta go używa.`api_key`
## Poradnik CLI
CLI owija API HTTP do użytku przez agenta:`ah`
```
ah join --server http://localhost:8080 --name agent-1 --admin-key YOUR_SECRET_KEY
ah push
ah fetch <hash>
ah log [--agent X] [--limit N]
ah children <hash>
ah leaves
ah lineage <hash>
ah diff <hash-a> <hash-b>
ah channels
ah post <channel> <message>
ah read <channel> [--limit N]
ah reply <post-id> <message>
```
Dla deweloperów agentów najważniejsze są dwa polecenia: _(znajdź granicę — na których nikt jeszcze nie budował)_ oraz _(przekrzyj swoje ulepszenia z powrotem do DAG)._`ah leaves``ah push`
## Pętla Agentów: Jak agenci faktycznie współdziałają z AgentHub
Każdy agent łączący się z AgentHub stosuje ten sam trzyetapowy wzorzec:
**Krok 1: Odkryj granicę.** Zapytaj DAG o commity leaf — to najnowsze eksperymenty, których nikt jeszcze nie rozszerzył. To tutaj zaczyna się nowa praca.
**Krok 2: Modyfikacja i testowanie.** Pobierz obiecujący commit, stwórz lokalne drzewo pracy, wprowadź zmiany _(modyfikacje kodu, modyfikacje hiperparametrów, zmiany architektury)_ i zweryfikuj lokalnie.
**Krok 3: Wprowadź wyniki i skoordynuj.** Jeśli zmiany poprawią sytuację, stwórz pakiet git i wypchnij go do huba. Publikuj wyniki, metryki i argumenty na forum dyskusyjnym, aby inni agenci mogli się z tego uczyć.
**Oto działający szablon w Pythonie, który implementuje tę pętlę na API HTTP AgentHub:**
```
import requests
import subprocess
import tempfile
import os
import json
class AgentHubClient:
"""Minimal client for interacting with an AgentHub server."""
def __init__(self, hub_url, api_key):
self.hub_url = hub_url.rstrip("/")
self.headers = {"Authorization": f"Bearer {api_key}"}
def get_frontier(self):
"""Get leaf commits - the starting points for new work."""
resp = requests.get(
f"{self.hub_url}/api/git/leaves",
headers=self.headers
)
resp.raise_for_status()
return resp.json()
def fetch_commit(self, commit_hash, dest_dir):
"""Download a git bundle for a specific commit."""
resp = requests.get(
f"{self.hub_url}/api/git/fetch/{commit_hash}",
headers=self.headers
)
resp.raise_for_status()
bundle_path = os.path.join(dest_dir, "fetched.bundle")
with open(bundle_path, "wb") as f:
f.write(resp.content)
work_dir = os.path.join(dest_dir, "work")
subprocess.run(["git", "clone", bundle_path, work_dir], check=True)
return work_dir
def push_bundle(self, work_dir, message="Agent improvement"):
"""Create a git bundle from local changes and push to hub."""
subprocess.run(["git", "add", "-A"], cwd=work_dir, check=True)
subprocess.run(
["git", "commit", "-m", message],
cwd=work_dir, check=True
)
bundle_path = os.path.join(work_dir, "push.bundle")
subprocess.run(
["git", "bundle", "create", bundle_path, "HEAD"],
cwd=work_dir, check=True
)
with open(bundle_path, "rb") as f:
resp = requests.post(
f"{self.hub_url}/api/git/push",
headers=self.headers,
files={"bundle": f}
)
resp.raise_for_status()
return resp.json()
def post_to_board(self, channel, message):
"""Post results or coordination notes to the message board."""
resp = requests.post(
f"{self.hub_url}/api/channels/{channel}/posts",
headers=self.headers,
json={"content": message}
)
resp.raise_for_status()
return resp.json()
def read_board(self, channel, limit=10):
"""Read recent posts from a channel."""
resp = requests.get(
f"{self.hub_url}/api/channels/{channel}/posts",
headers=self.headers,
params={"limit": limit}
)
resp.raise_for_status()
return resp.json()
def run_agent_loop(hub_url, api_key, modify_fn):
"""
Generic agent loop.
modify_fn: callable that takes a work_dir path and returns
(success: bool, message: str) after making changes.
"""
client = AgentHubClient(hub_url, api_key)
frontier = client.get_frontier()
if not frontier:
print("No frontier commits found. Push an initial commit first.")
return
target = frontier[0]
print(f"Working on frontier commit: {target['hash'][:12]}")
with tempfile.TemporaryDirectory() as tmp:
work_dir = client.fetch_commit(target["hash"], tmp)
success, msg = modify_fn(work_dir)
if success:
result = client.push_bundle(work_dir, message=msg)
client.post_to_board(
"results",
f"Commit {result.get('hash', 'unknown')[:12]}: {msg}"
)
print(f"Pushed improvement: {msg}")
else:
client.post_to_board(
"results",
f"Failed attempt on {target['hash'][:12]}: {msg}"
)
print(f"Attempt failed: {msg}")
```
Ten szablon jest celowo minimalny. Parametr to miejsce, gdzie znajduje się faktyczna logika agenta — wywołanie LLM do kodu Claude'a, wyszukiwanie hiperparametrów, skanowanie bezpieczeństwa – cokolwiek robi twój agent. Interakcja z infrastrukturą _(pobieranie, pchanie, post)_ pozostaje taka sama bez zmian.`modify_fn`
## Czym są pakiety git (i dlaczego AgentHub ich używa)
**Jeśli wcześniej nie spotkałeś się z pakietami git:** są to samodzielne pliki, które pakują obiekty Git _(commity, drzewa, bloby)_ w jedną przenośną jednostkę. W przeciwieństwie do standardowego połączenia wymagającego bezpośredniego połączenia z odległym serwerem, bundle można tworzyć offline i przesyłać za pomocą dowolnego mechanizmu — w tym przesyłania HTTP na serwer AgentHub.`git push`
Serwer waliduje każdy pakiet, rozpakowuje go do gołego repozytorium i aktualizuje DAG. Oznacza to, że agenci nie potrzebują trwałych połączeń Git. Pobierają zdjęcie, pracują lokalnie i po zakończeniu przesuwają wiązkę. Czyste oddzielenie pracy lokalnej od wspólnego państwa.
## Poza badaniami ML: Przypadki użycia dla zespołów inżynierskich
Karpathy stworzył AgentHub do autonomicznych eksperymentów z ML. Ale architektura jest celowo agnostyczna — a wzorce te bezpośrednio przekładają się na procesy inżynierskie.
## Roje optymalizacji kodu
**3 agentów, każdy z inną strategią:** _Agent A_ optymalizuje rozmiar pakietu, _Agent B_ wydajność w czasie działania, _Agent C_ zużycie pamięci. Każdy forkuje ten sam commit frontier, stosuje swoją strategię, uruchamia benchmarki i generuje wyniki. Tablica ogłoszeń pokazuje, które podejście wygrało. Żaden człowiek tego nie koordynuje — agenci czytają posty innych i budują na udanych próbach.
## Agenci Audytu Bezpieczeństwa
Agent skanera przeprowadza statyczną analizę commitów Frontier i publikuje wyniki na kanale _"bezpieczeństwa"._ Agent fixer odczytuje kanał, próbuje łatać i wysyła pakiety. Agent walidacyjny sprawdza, czy poprawka wprowadziła regresje. DAG rozwija gałąź zabezpieczonych commitów, na których inni agenci mogą budować.
## Agenci dokumentacji
Agent odczytuje kod na commitcie frontier, generuje dokumentację API i wysyła ją jako nowy commit. Inny agent czyta dokumentację, porównuje je z rzeczywistym kodem i publikuje rozbieżności na forum dyskusyjnym. Trzeci agent rozwiązuje rozbieżności. Dokumentacja pozostaje zsynchronizowana z kodem — bez pamięci człowieka, by ją zaktualizować.
## Jak to łączy się z istniejącymi ustawieniami agentów
Jeśli już używasz [OpenClaw do automatyzacji operacyjnej](https://medium.com/@alirezarezvani/agentic-ai-coding-stack-how-openclaw-claude-code-built-a-saas-mvp-in-4-days-95b4ec20dcbb), AgentHub wypełnia inną warstwę. OpenClaw to Twój operacyjny mózg — monitoruje, koordynuje i komunikuje się za pośrednictwem platform komunikacyjnych. AgentHub to wspólna warstwa kodu, gdzie agenci kodujący współpracują nad samym oprogramowaniem. Te dwie rzeczy się uzupełniają, a nie rywalizują.
W [stosie kodowania AI, który ostatnio dokumentowałem](https://alirezarezvani.medium.com/ai-coding-stack-how-openclaw-claude-code-built-a-saas-mvp-in-4-days-4e5e50b3291a), OpenClaw (Leo) pełnił rolę orkiestratora, który tworzył prompty dla Claude Code. AgentHub mógłby zastąpić ręczną orkiestrację zadań, gdzie wielu agentów powinno niezależnie eksplorować różne rozwiązania tego samego problemu — struktura DAG jest stworzona właśnie do tego wzorca.
Dla [zespołów już korzystających z kodu Claude z wzorcami wieloagentowymi](https://alirezarezvani.medium.com/openclaw-multi-agent-system-the-blueprint-i-built-in-12-hours-509498d02908), AgentHub zapewnia brakującą warstwę trwałości. Zespoły agentów Claude Code pracują w ramach jednej sesji. AgentHub zachowuje graf zatwierdzeń i stan koordynacji między sesjami, maszynami i czasem.
## Gdzie to zawodzi
Ta sekcja ma równie duże znaczenie jak wszystko powyżej.
**Repozytorium zostało prywatne.** Oryginalny Karpathy zniknął około tydzień po starcie. Forki takie jak mój zachowują kod, ale aktualizacje od oryginalnego autora przestały napływać. Nie wiadomo, czy stanie się to projektem utrzymywanym, czy pozostanie tylko szkiczem.`karpathy/agenthub`
**"Praca w toku. Tylko szkic. Myślę."** To są słowa samego Karpathy'ego w README. To nie jest oprogramowanie produkcyjne. To eksploracja tego, jak mogłaby wyglądać infrastruktura agent-natywna. Traktuj to odpowiednio.
**Brak informacji koordynacyjnej.** Sama platforma jest celowo "głupia". Nie pomaga agentom unikać duplikatów pracy, rozwiązywać konfliktowych zmian ani priorytetyzować obiecujących gałęzi. Cała ta logika musi żyć w instrukcjach agentów. Dla małych rojów to jest w porządku. Dla dziesiątek równoczesnych agentów narzut koordynacyjny może stać się znaczący.
**Współbieżność SQLite pod dużym obciążeniem.** Pojedyncza baza danych SQLite jest elegancka do prototypowania i zastosowania na małą skalę. Ale model blokowania zapisu w SQLite oznacza, że równoległe pushy od wielu agentów będą serializować. Na dużą skalę — powiedzmy, gdy 50 agentów naciska jednocześnie — staje się to wąskim gardłem. Architektura wymagałaby PostgreSQL lub podobnej bazy danych do współbieżności na poziomie produkcyjnym.
**Nie wysyłano przykładowych agentów.** AgentHub zapewnia infrastrukturę, a nie szablony agentów. Musisz budować własnych agentów od podstaw. Powyższy szablon Pythona to oryginalna zawartość — nic podobnego nie istnieje w oficjalnym repozytorium ani dokumentacji.
**Powierzchnia zabezpieczeń.** Każdy agent posiadający klucz API może przesyłać dowolne pakiety kodu. Nie ma bramki code review, nie ma walidacji tego, co agenci wykraczają poza format pakietu. W zaufanym środowisku jest to w porządku. W modelu otwartego wkładu — który Karpathy przewiduje dla badań rozproszonych — wymaga to starannego przemyślenia sandboxingu i walidacji.
## Co to oznacza dla infrastruktury agentów
AgentHub nie jest ostateczną odpowiedzią. To pierwsze poważne wyrażenie pytania, którego branża unikała: jak wygląda kontrola wersji, gdy główni autorzy nie są ludźmi?
Odpowiedź, jak się okazuje, nie są gałęzie i pull requesty. To rozległy DAG, gdzie każdy eksperyment działa jako commit, każdy wynik trafia do komisji koordynacyjnej, a koncepcja _"głównej gałęzi_" całkowicie znika. Agenci nie potrzebują strategii połączenia. Potrzebują odkrywania granic i dzielenia się wynikami.
To, czy Karpathy będzie kontynuował ten konkretny projekt, ma mniejsze znaczenie niż wzorzec, który on ustalił. Koncepcja — infrastruktura agent-native jako odrębna kategoria od narzędzi programistycznych — i tak doprowadzi do komercyjnych i otwartoźródłowych implementacji. Spodziewam się zobaczyć wiele platform w stylu AgentHub przed końcem 2026 roku.
Na razie fork jest aktywny, kod się kompiluje, a szablon agenta powyżej to punkt wyjścia, którego nikt inny nie opublikował. Jeśli coś na tym zbudujesz, wrzuć to na forum dyskusyjne.
## Najczęściej zadawane pytania dotyczące AgentHub
### **Czym jest AgentHub i czym różni się od GitHub?**
AgentHub to platforma współpracy Karpathy stawiająca na agentów — surowa tablica Git repozytorium oraz forum dyskusyjne zaprojektowane dla tłumów agentów AI pracujących na tym samym kodzie. W przeciwieństwie do GitHuba, nie ma gałęzi, pull requestów ani fuzji.
Agenci przesyłają kod za pomocą pakietów git do skierowanego grafu acyklicznego (DAG) zatwierdzeń i koordynują przez wbudowaną tablicę dyskusyjną. Platforma jest ogólna i nie określa, co agenci mają optymalizować.
### **Czy nadal mogę uzyskać dostęp do AgentHub po tym, jak repozytorium Karpathy'ego stało się prywatne?**
Oryginalne repozytorium zostało prywatne około tydzień po uruchomieniu 10 marca 2026 roku. Jednak wiele forków zachowuje cały kod, w tym [github.com/alirezarezvani/agenthub](https://github.com/alirezarezvani/agenthub) _(Pierwotnie Forked from innego użytkownika)._ Kod się kompiluje i uruchamia — po prostu nie otrzymasz aktualizacji od oryginalnego autora.`karpathy/agenthub`
### **Co potrzebuję, aby uruchomić AgentHub lokalnie?**
Idź na wersję 1.21 lub nowszą i git na systemowej ŚCIEŻCE. To wszystko. AgentHub kompiluje do jednego statycznego binarnego pliku bez kontenerów czy zależności w czasie wykonywania. Serwer używa SQLite do przechowywania oraz gołego repozytorium Git na dysku.
Buduj z , zaczynając od .`go build ./cmd/agenthub-server``./agenthub-server --admin-key YOUR_KEY --data ./data`
### **Czy AgentHub służy tylko do badań nad ML?**
Nie. Platforma jest celowo niezależna — udostępnia współdzielony commit DAG oraz forum dyskusyjne. Choć pierwszym przypadkiem użycia jest organizacja _autoresearchu (autonomicznych eksperymentów ML),_ architektura ta obsługuje dowolny wzorzec współpracy wieloagentowej: roje optymalizacji kodu, agentów audytu bezpieczeństwa, generatory dokumentacji lub każdy scenariusz, w którym wielu agentów niezależnie eksploruje rozwiązania tego samego problemu.
_✨ Dzięki za przeczytanie! Jeśli chcesz więcej wzorców infrastruktury AI przetestowanych w produkcji,_ zapisz [_się do mojego newslettera_](https://claude-code.beehiiv.com/), _aby otrzymywać cotygodniowe informacje._
**_Co byś zbudował na AgentHub?_** Przypadek użycia badań ML jest oczywisty — ale bardziej interesują mnie zastosowania inżynierskie. Swarmy optymalizacji kodu, skanowanie bezpieczeństwa, automatyczne refaktoryzowanie. Podziel się swoim zastosowaniem w komentarzach.
### **O autorze**
Jestem Alireza Rezvani (Reza), CTO i buduję systemy rozwoju AI dla zespołów inżynierskich. Piszę o przekształcaniu indywidualnej wiedzy w infrastrukturę zbiorową poprzez praktyczną automatyzację.
**Połącz:** [Strona](https://alirezarezvani.com/) internetowa | [LinkedIn](https://linkedin.com/in/alirezarezvani) | [Biuletyn](https://claude-code.beehiiv.com/)
**Czytaj więcej na Medium:** [Alireza Rezvani](https://alirezarezvani.medium.com/)