Агент у стылі Claude Code на LangChain Deep Agents

Агент для кодавання — гэта не чатбот

Лёгкая ўяваецца, што агент для кодавання — гэта проста розумнейшы чатбот, але гэта некалькана. Магчымасці Claude Code не выходзяць толькі з самай мадэлі; яны вынікаюць з агентскага каркаса, створанага наваколе мадэлі. Шэйдж-сістэма являе сабою план керавання — невідмую сістэму, якая дае мадэлі інструменты для чытання файлоў, срэду для запуску коду, памяць пра тое, што яна ужо зрабіла, і чарт-перакананні для падтрымкі правільнага курсу. Без гэтага каркаса мовная мадэль ёст толькі генератор тэксту; з яго ж адна і тая самая мадэль паводзіцца як спроможны, автонамны інжынер працэй з програмнай апаратурой.

Мета тут — разбіраць, як працуе агент у стылі Claude Code, практычна по частках, і перабудаваць кожную з яных за дапамою бібліятэкі deepagents ад LangChain. У канцы вы мусіце зрозумець ўсю структуру, таму што самі яе створыце.

Цыкл у цэнтры

Сеанс почынаецца з повідомлення корыстувача. Гэта можа быць віпадковы запіт пра тое, што знаходзіцца ў папцы, або складны заводкі, як-то перэрабка сістэмы входу і апдэйт ўсіх тэстаў. Мадэль чытае гэта повідамленне першым крокам, пасля чаго шлях роздваіцца. Калі трэба дзеянне, яна запрашвае інструмент, отрымае рэзультат і знова повтарывае працэс. Гэты цыкл аднаковы як для задання з аднім крокам, так і для задання з пяцідэсятма крокамі. Калі мадэль адпавядае звычайным тэкстам без запіту на інструмент, цыкл завершваецца, і корыстувач бачыць рэзультат.

Поле „Адаптаваць наступны крок“ аб’еднвае тры фазы, якія опісваюцца ў даследжэннях агентаў: збір інфармацыі праз чытанне файлаў, дзеяння праз рэдагаванне і запуск команд, а таксама перакананне праз адрабатка тэстаў. Яны не выконваюцца як адзінаковыя рэжымы. Гэта проста разныя вызывы інструментаў, якія праходзяць праз адну петлю.

Існуе ўмышленая зміна рэжыму — рэжым планавання. Зазвычай агент плануе і дзейнае адразу. У рэжыме планавання перад петляю знаходзіцца блок контролю. Агент дакладна аналізуе сітуацыю і практычна складае прыяўзд, не змінюючы нічога: файлы чытаюцца, ідэі прарабатваюцься, але рэдагавання і команды чакаюць, пакуль корыстнік не дасць санкцыю, і толькі пасля чаго запускаецца звычайная петля. Гэта служыць захоўнам механізмам для большых чы абавязкова рызыкаваных задач. Гэта не тое ж самае, што спіс завадак, які агент ведае для кожнай задачы, таму што рэжым планавання — гэта пауза, яку ініціюе корыстнік і якая павінна быць явна затверджана.

У дыяграме яшчэ не паказаны элементы, якія працуюць у рамках ціклу: працэс стыснення дадзейнаў, калі памяць запоўняецца, падагенты, якія запускаюць свае сабэйскія ціклы, а таксама шары дазволаў і ізоляцыі, якія стояць межы між «запускам інструмента» і рэальной сістэмай. Ні адны з гэтых элементаў не зменяе сам цікл; яны проста яго абгораджуюць.

Унутры этой структуры знаходзяцца чатыры можлівасці, якія памагаюць падтрымваць стабільнасць ціклу. Функцыя планавання змушвае агента спачатку прымусіцца да раздумаў. Інструменты выступаюць як яго «раны». Кантэкстнае кераванне запобегае таму, каб дугія задачы запоўнялі ўсю памяць. Падагенты беруць дадатковыя задачы у свае сабэйскія ціклы, ў рэзультаце чаго галоўны поток застаецца чыстым. Яны сапраўджуюць функціонаванне ціклу, але ніколі яго не перапісваюць.

Пад тым усім знаходзіцца слой, які мае найбольшое значэнне. Калі агент хочаць узаемадзейсцаваць з рэальным светам, выконваючы змены ў файле, запускаючы каманду або выкорыстоўваючы сетка, цяе дзеянне не прабіваеся безпосерэдна да апарату. Спачатку яно праходзіць праз правыя належнасці і сандбокс, і жадная іншая мера безпекі ў праектах не мае такога важлівага значэння. Уявіце, што вы намагаецеся захаваць агента, дадаўшы ў яго інструкціі рэчкаподобныя словы на кшталт «будзь ласка, не выдаліце нічога важлівага». Гэта проста напамінанне, і мадэль можа яго не зазначыць, неправільна яго зрозумець або проста ігнораваць. Адпраўная захопленасць знаходзіцца параду модэллю: правіла належнасця, якіе проста адхоўляюць выклік інструмента, а таксама сандбокс операцыйнай сістэмы, які зупіняе небяспечную каманду, незалежна ад таго, што прагне мадэль.

Чысты двыгун

Перш чым прыбегаць да бібліятэкі, корыстна паглядзець на двыгун без жадных дапаможных элементаў. Цэта ўжо цэлысна працуючая петля агента.

def run_agent_loop(client, user_message, tools, tool_functions, max_turns=20):
    messages = [{"role": "user", "content": user_message}]
    for _ in range(max_turns):
        # 1. Ask the model what to do next.
        response = client.messages.create(
            model="claude-sonnet-4-6", max_tokens=1024, tools=tools, messages=messages
        )
        messages = [*messages, {"role": "assistant", "content": response.content}]

        # 2. Plain text and no tool request? The job is done.
        tool_uses = [b for b in response.content if b.type == "tool_use"]
        if not tool_uses:
            return "".join(b.text for b in response.content if b.type == "text")
        # 3. Run each requested tool and hand the results back. 4. Repeat.
        results = [
            {"type": "tool_result", "tool_use_id": call.id,
             "content": tool_functions[call.name](**call.input)}
            for call in tool_uses
        ]
        messages = [*messages, {"role": "user", "content": results}]
    raise RuntimeError(f"agent loop did not finish within {max_turns} turns")

Ён складаецца прыблызна з трыдцяці ліній, а рэшта дыяграмы — гэта цікл з дадатковымі элементамі. Болей сільныя інструменты знаходзяцца ў tool_functions. Планавальнік запісвае прыметкі ў messages. Компактар скорачае messages, калі тыя становяцца занадта вялікімі. Падагент — гэта проста тая ж самая функцыя, якая запускаецца знову з новым, порожнім спіскам messages. Перакананне ў наявнасці права выконваецца ў прыеме між модэлем, які запрашвае інструмент, і лінійкай, якая яго выконвае. Ліміт max_turns — гэта прояв паранойі, які ўсе рэальныя сістэмы практыкуюць, адтолькі ўвесь час, калі модэль застраг у цікле, ён без канца вітрачае рэсурсы.

Кожны кодавальны агент мае гэтае «серцэ», цікл агента, які ператварае слова на дзеяння, і ён прыгожа просты:

1. Запытайце модэль, што робіць далей.
2. Модэль або адпавядае у звычайным тэксце, або просіць вікорыстаць інструмент.

Калі сістэма запрашвае інструмент, яна запускае гэты інструмент і вяртае рэзультат модэлю.

Верніцеся да крока 1.

Калі модэль адпавядае простым тэкстам без запіту на інструмент, заданне завершанае, таму зупініцеся і паказайце адпаведзь.

Чытанне файла, запуск команды і рэдагаванне коду — усе гэта праходзіць праз адны цыкл. Уявіце саброцку, якой даюць заданне і спіс пераконтрацоў: перакантруйце, што наступнае, зрабіце гэта, перагляньце рэзультат, зноў выберыце, і толькі пасля таго, калі спіс стане порожнім, дадзіце адчытку. Цыкл выполняе роль такога суджэння саброцкі. Ён таксама можа адлічваць свае паслядованні: простая запітанне можа выклікваць адзін цыкл, тады як масштабныя перэработкі можу выклікваць дзесяткі вызоў інструментаў, і ніхто не павінен загадзя вялічыць колькісць крокаў.

Стварэнне з Deep Agents

Няма прычыны пісаць цыкл while вручную. Стварэнне Deep Agent аўтоматычна з’яўляець рабочы цыкл. Пачніце з інсталявання бібліятэкі і прадавца модэляў.

pip install deepagents langchain-anthropic

Потым створыце простэйшага можлівага агента.

from deepagents import create_deep_agent

def get_weather(city: str) -> str:
    """Get the weather for a given city."""
    return f"It's always sunny in {city}!"
agent = create_deep_agent(
    model="anthropic:claude-sonnet-4-6",
    tools=[get_weather],
    system_prompt="You are a helpful assistant.",
)
result = agent.invoke(
    {"messages": [{"role": "user", "content": "What's the weather in San Francisco?"}]}
)

Выклік create_deep_agent вяртае агента, у якога цыкл ужэ налаштаваны, а .invoke() запускае самэнтычны вышэй опісаны цыкл. Крамп не пакірае, які мадэль знаходзіцца пад ўсём, чы то OpenAI, Google чы Anthropic. Цыкл застаецца тым жа.

Інструменты — гэта рукі

Калі цыкл — гэта двахтар, то інструменты — гэта рукі. Без іх мадэль можа толькі размовляць. З хорашымі інструментамі яна можа чытаць код, зменяць яго і пераканацца ў выніку. Рэальныя інструменты для програмавання дзеляцца на чатыры групы:

• Інструменты для чытання працуюць без змян: read_file ачынае файл, glob знаходзіць файлы па шаблоне імен, напрыклад усі файлы .py, а grep шукае ў файлах конкрэтны тэкст. Пачатківцы часта плутаюць апошнія два, але glob знаходзіць файлы па імені, а grep — па ўмесце.

Інструменты для рэдагавання зміняюць даныя безпечнаўска: write_file стварае новыя файлы, а edit_file меняе частку вялікага існуючага файла.

Інструмент для выканання запускае команды шэлу, тыя ж, якія прадваюцца ў тэрмінале.

Інструмент-дэлегат, task, перадае падзаданне дапаможнаму агенту.

Чаму не дазволіць агенту вжываць cat для чытання і sed для рэдагавання? Ён могаў бы, але спецыяльна створаныя інструменты маюць прывілеі ў двух аспектах. Першы — цэе кантроль калікваты токенав: спецыяльны інструмент для чытання можа паглядзець на размер файлу пры яго завантажэнні і, за патрэбы, зменшыць яго, тады калі просты cat выважвае ўсё цалкам і можа перапыліць межы кантэкстнага вікна. Другі — цэе болей чыстыя правы прыўязкі: вызов вядомага інструмента edit_file дакладна паведамляе сістэму пра тое, што відбываецца, ўсёлякія правіла безпекі можна застосавіць, тады калі жорсткая шэл-каманда ёсць незрозумелай і рызыкованай.

Ёсць цікавая особлівасць. Мадэлі навчыліся на публічным Інтэрнэце, заполненым адказамі на Stack Overflow, дзе вікорыстоўваюцца cat і sed; таму нават прыгожэйшыя з іх за звычкай вядуцца на чысты shell. Сістэмны прапанаванне должна ўпоркі прыгадваць ім вікорыстоўваць справжнія інструменты, а не скорачэнні shell.

Deep Agents поставляець усю неабходную базу: планаванне, інструменты файловай сістэмы, можлівасць выканання задач і дэлегавання. Адзінаковыя інструменты дадаюцца як дэкораваныя функцыі.

import subprocess
from langchain_core.tools import tool

MAX_OUTPUT_CHARS = 20_000  # roughly 5k tokens
@tool
def run_tests(path: str = ".") -> str:
    """Run the project's pytest suite and return its output.
    Output is truncated to the last 20k characters (failures appear at the
    end). The run is killed after 5 minutes.
    """
    try:
        result = subprocess.run(["pytest", path], capture_output=True,
                                text=True, check=False, timeout=300)
    except subprocess.TimeoutExpired:
        return "pytest timed out after 300s"
    output = result.stdout + result.stderr
    if len(output) > MAX_OUTPUT_CHARS:
        return ("[... output truncated to the last 20,000 characters ...]\n"
                + output[-MAX_OUTPUT_CHARS:])
    return output
agent = create_deep_agent(
    model="anthropic:claude-sonnet-4-6",
    tools=[run_tests],            # merged in alongside the built-ins
    system_prompt="You are a coding assistant. Always run tests after editing.",
)

Дэкаратар @tool ператварае звычную функцыю ў элемент, які можа быць выкліканы модэлем. Яго докстрайнг мае вялікую значымасць, адказна модэль спрыяе яго як інструкцыю, якая паведамляе, калі і як вікорыстоўваць гэты інструмент.

Планаванне перад дзеянням

Калі да простага модэля дастаць складны запіт, ён часта працуе неэфектыва: выклік тут, ўсёродзе — без загальнага плану, іноды працуючы у калібрах. Хорашыя агенты для кодавання ухілваюцца ад гэтага, складаючы план перад тым, як чаго-небудзь зачыняцца. Яны пішу структураваны спіс задач, які дзеліць работу на чыстыя крокі, пасля чаго працуюць па яму і пазначаюць кожны пункт як у працэсе адвароту чым-небудзь. Гэта супанае з кухаром, які чытае весь рэцепт перад тым, як увімкнуць печку, так што чэтвёрты крок не будзе выдумвацца, пакуль трэці вяржаеся.

Ёсць прыгматычны інжынярскі трук, які дапамагае рашытаць гэтую проблему. За дзейснення довгай сесіі первачны цэль занурваецца між старонкамі рэзультатаў ад засобаў, і мадэль перастае яго бачыць. Ёнколі, каб запобiec гэтаму, сістэма практычна вяртае чырговы спіс задач у размову пасля вызоў засобаў, так сама, як колега можа пасунуць чыртак задач назад па столе як нагадванне.

У Deep Agents гэтым засобам яўляецца вбудованы write_todos. Няма прычын для налагоджэння, калі ўжо стандартны запрос сістэмы навучае агента планаваць дзеяння і падтрымляць актуальнасць спіску працы ў ходзе ціклу.

Управлінне кантэкстам

Сюды належы самыя складныя інжынярскія задачы. Кожны мадэль мае «вікна кантэксту», тое самае — фіксаваны ліміт свайго рабочага памяці. Калькі большых файлоў плюс калякве команды быстра заполняюць гэта вікно, і калі памяц перэпоўняецца, агент начынае прыменшваць кількасць апрацоўваваных дадзенняў, нават інструкцыяў, з якіх ён запускаў свою працу. Агенты-програмісты справляюцца з гэтым за дапамогою двух тактык:

1. Файлы выступаюць як зовнішняя памяць. Уместа таго, каб перадаваць вельмі большы рэзультат пошуку ў чат, агент запісвае яго на дыск і заставляе толькі назву файлу; калі ёму патрэбны дэталі, я он зноў ачынае файл.
2. Колі размова набліжаецца да ліміту, запускаецца працэс складчання дадзенняў. Агент зупіняе цыкл, сконцэнтруеўвае старэйшыя пераказы, зберагае ключовыя факты у далекасходній памяці і стырае перэпоўненую кашточную памяць.

Уявіце сабе, калі трэба напісаць вялічэзны звыт: ніхто не можа запам’ятаваць усе ў своім разуме. Вы робіце нотаткі, фіксуеце інфармацыю і трэзервуеце апусненне на адной сторонцы на столе. І тое, і другое ўжо ёсць часткай Deep Agents – прыстрою, які забезпечвае віртуальную файловую сістэму для зберагчэння вялікых выкарыстоўваных дадзенняў, а таксама автаматычны мідлвэр для стварэння апуснення, таму кантроль памяці існуе з моменту стварэння агента.

Падагенты: дзеліце і павалюйце

Дзеяння, які ўскладненыя, не пасвядчаюць для адной розмовы. Пошук у вялічэзнай базе коду можа значыць чытанне пяцідзiesятах файлаў, а пяцідзiesят файлаў не должны заняты каштоўную памэць галоўнага агента. Рашэнняя — сабагенты. Галоўны агент запускае дапаможнік, дае яму конкрэтную задачу, напрыклад, знайсці месца розташавання логікі аўтэнтыфікацыі, і дапаможнік працуе у сваёй самастойной, аддзельнай вікнах кантэксту. Калі ён заканчывае, ён вяртае стыслы падсумак. Менеджэр, які давае задачы на доследжэнне младшаму працавальніку і атрымвае падсумак у вачох абарота, таксама падтрымвае парадак.

Есць таксама меры безпекі: сабагентам строго забраняецца запускаць своіх сабагентаў. Інакш агент, які заплутаецца, можа стварыць бесканечную лянцюг падпадзельных дапаможнікаў, працэс, які спалюе бюджэт API. Строгі ліміт глыбіні падтрымвае безпеку дэлегавання.

Deep Agents уключае в сябе вбудованы інструмент task для стварэння дапаможных працоўнікаў. Спецыялізаваныя з іх, такія як спецыяльны шукач коду, опісваюцца простымі словнікамі.

code_searcher = {
    "name": "code-searcher",
    "description": "Searches the codebase to find where specific logic lives. "
                   "Use this for any open-ended 'where is X?' question.",
    # ⚠️ NOTE: the key is `system_prompt`, NOT `prompt` (see correction below).
    "system_prompt": "You are an expert at navigating codebases. Use the grep "
                     "and glob tools to locate relevant files, then report a "
                     "concise summary of what you found and where. Do not make "
                     "any edits.",
}

agent = create_deep_agent(
    model="anthropic:claude-sonnet-4-6",
    tools=[run_tests],
    system_prompt="You are a coding assistant.",
    subagents=[code_searcher],
)

Главны агент цяпер прыёмліе, што існуе спецыяліст, што дазволяе яму чыстаць свою памяць для справжней працы з кодамі.

Безпека і падтрымка чалавека

На гэтым этапе агент можа рэдагаваць файлы і запускаць команды ў шэлі на рэальнай машыне, што вымагае адзінаго моманту раздумаў. Агент з адным энтузіязмам можа выдаліць неправільныя файлы або запусціць што-небудзь разрушальнае. Сіла без кантролю — гэта справжня небяспека. Агенты для напісання коду встановляюць кантролы на два слоі:

1. Спісы дазволенага і правілы забороны дазволяюць безпечным інструментам, такім як чытанне файлаў, працаваць аўтаматычна, тады як разрушальныя інструменты, такія як выдаленне файлаў, вымагаюць падтрымкі.
2. Папярскі пытанні падтрымкі, якія таксама называюцца удзелам чалавека, змушваюць агента зупініцца і запытаць пры рызыкаваных дзеяннях. Пользоватэль падтрымвае, рэдагуе або адхоўляе дзеянне, пасля чаго цыкл продовжваецца.

Ключовая правіла безпекі гэнератыўных агентоў заключаецца ў тым, што запіт не можа быць бар’ерам для безпекі. Запрос да модэлю не выдаляць нічога важлівага ёсць ввічлівае прасба, а не бар’ер, таму што модэль можа створыць халюцынаціі, праехаючы кроз яго. Забезпечэнне безпекі павінна выконвацца за межамі самага модэля, у спецыяльным інструментарыі. Правіло дазволу можа адмовіць у выкорыстанні певнага інструмента, а сандбокс можа заблакаваць небяпечныя команды на рэвюсі сістэмы, незалежна ад таго, насколькі модэль хочаць яны будуць выкананы. З гэтай прычыны інструмент выконвання павінен маты належны бэкэнд. Ввічлівасць — гэта не безпека.

Deep Agents ставі свае меры безпекі ў спецыяльны інструментарый. Доступ да шэлу патрабуе наявнасці бэкэнда, а вбудованы механізм перэрываў у LangGraph зупіняе выконванне перад рызыковымі операцыямі.

from deepagents import create_deep_agent
# Import path for backends can vary by version - check the current
# "Backends" page in the Deep Agents docs.
from deepagents.backends import LocalShellBackend

agent = create_deep_agent(
    model="anthropic:claude-sonnet-4-6",
    system_prompt="You are a coding assistant working inside this project.",
    backend=LocalShellBackend(),   # enables the `execute` shell tool
)

Як толькі запрашуецца інструмент, які вымагае права доступу, цыкл зупіняецца, а рэзультат уключае пакет __interrupt__, які апісвае запланаваную дзеянне і доступныя варыянты: approve, edit, reject або respond. Пасля прыемкі рашэння запуск продовжваецца.

from langgraph.types import Command

result = agent.invoke({"messages": [...]}, config)
result["__interrupt__"]   # the pending action + allowed decisions — show your user

# You decide; the loop picks up exactly where it paused:
agent.invoke(Command(resume={"decisions": [{"type": "approve"}]}), config)
# ... or {"type": "reject"} — the tool is never run, and the model is told so.

Рэальныя ліміты выклікаюцца за дапамою спецыяльных прыстроёў, а не толькі паведамленняў.

Памяць між сесіямі

По умове стандартнай наладкі агент втрачае усё як толькі завершыцца размова. Праўда, корыстны асістэнт павінен памяцаць правіла кодавання праекту, што падабаеца корыстніку і дзе ён застаўся ўчора. Для гэтага існуюць два механізмы. Функцыя контрольных точакахоўвае точны стан агента, таму дзейсціва длігога заведання перазначаецца пасля перарыву і продовжваецца з таго ж момента. Даўгастраўная памяць зберагае факты, якія застаюцца актуальнымі пасля завершэння кожной размовы, напрыклад, тое, што праект запоўнюецца чатырма прабеламі.

Паколькі Deep Agents работае на LangGraph, стабільнасьць дастаёцася за дапамою падключэння контрольных точакаў.

from deepagents import create_deep_agent
from langgraph.checkpoint.memory import InMemorySaver

agent = create_deep_agent(
    model="anthropic:claude-sonnet-4-6",
    tools=[run_tests],
    system_prompt="You are a coding assistant.",
    checkpointer=InMemorySaver(),   # remembers state within a session
)
# A "thread_id" ties messages together into one ongoing conversation.
config = {"configurable": {"thread_id": "project-alpha"}}
agent.invoke(
    {"messages": [{"role": "user", "content": "Start refactoring the auth module."}]},
    config=config,
)
# Later, same thread_id - the agent remembers the earlier turn:
agent.invoke(
    {"messages": [{"role": "user", "content": "Now update the tests too."}]},
    config=config,
)

InMemorySaver дзейніцца толькі пры жыцце программы. Чырваючы ў спадарожніцтве пасля перзапускаў, яго трэба заменіць на чэкпойнтар, падтрымваны базай дадзеных.

Усё ў аднам агенце

З’едыненыя разам, этыя элементы ствараюць адного агента: ядро-цыкл плюс спецыяльныя інструменты, планаванне, обработка кантэксту, дапаможны падагент, шэл і зберажаны стан — усьго семь частак.

from deepagents import create_deep_agent
from deepagents.backends import LocalShellBackend
from langchain_core.tools import tool
from langgraph.checkpoint.memory import InMemorySaver

# --- A custom tool (Part 2) — token-budgeted, see Part 2 for the full body ---
@tool
def run_tests(path: str = ".") -> str:
    """Run the project's pytest suite and return its (truncated) output."""
    import subprocess
    try:
        result = subprocess.run(["pytest", path], capture_output=True,
                                text=True, check=False, timeout=300)
    except subprocess.TimeoutExpired:
        return "pytest timed out after 300s"
    output = result.stdout + result.stderr
    return output if len(output) <= 20_000 else "[... truncated ...]\n" + output[-20_000:]

# --- A specialized subagent (Part 5) — note the `system_prompt` key ---
code_searcher = {
    "name": "code-searcher",
    "description": "Finds where specific logic lives in the codebase. "
                   "Use for open-ended 'where is X?' questions.",
    "system_prompt": "You navigate codebases using grep and glob, then report a "
                     "concise summary of what you found. You never make edits.",
}

# --- A system prompt that teaches good behavior (Parts 2 & 3) ---
SYSTEM_PROMPT = """You are a careful coding assistant.
Workflow:
1. Plan the task as a to-do list before doing anything.
2. Use your built-in read, grep, and glob tools to explore - never the raw shell
   equivalents like cat or grep.
3. Make focused edits.
4. ALWAYS run the tests after editing, and fix anything that breaks.
5. Delegate broad codebase searches to the code-searcher subagent.
"""

# --- Assemble the agent (Parts 1, 4, 6, 7 handled by the harness) ---
agent = create_deep_agent(
    model="anthropic:claude-sonnet-4-6",                  # Part 1: the loop, model-agnostic
    tools=[run_tests],                                     # Part 2: custom hands
    system_prompt=SYSTEM_PROMPT,                           # Parts 2 & 3: behavior + planning
    subagents=[code_searcher],                             # Part 5: delegation
    backend=LocalShellBackend(root_dir=".", virtual_mode=False),  # Part 6: shell access
    interrupt_on={"execute": True,                         # Part 6: the brakes —
                  "write_file": True, "edit_file": True},  #   approval before anything destructive
    checkpointer=InMemorySaver(),                          # Part 7: memory across turns
)
# Part 4 (context management) and built-in planning come on automatically.

config = {"configurable": {"thread_id": "my-project"}}
result = agent.invoke(
    {"messages": [{"role": "user", "content": "The login tests are failing. Fix them."}]},
    config=config,
)
print(result["messages"][-1].content)

Менш чым сто ліній коду дазволяюць стварыць агента для програмавання, які плануе, шукае, рэдагуе, запускае тэсты, перадае задачы памочным прыстроям, застаецца ў «піскулярнай коробцы» і контролюе свой кантэкст. Яго структура падабіцца да структуры Claude Code: простая петля, якая абгрунтуецца інструментамі, планаванням, керуванням памяцю, дэлегаваннем і механізмамі карання, які знаходзяцца за межамі самага модэлю.