지난 글에서 호출 하나가 어긋나는 지점들을 봤다. 호출이 안정되고 나면 다음으로 눈에 띄는 것은 속도다. 사용자가 "다음 주 출장 준비 좀 도와줘"라고 하면 날씨·환율·일정 세 가지를 봐야 하는데, 이걸 하나씩 부르면 응답이 눈에 띄게 늦다. 세 조회가 서로를 전혀 참조하지 않는데도 그렇다.
이 늦음을 줄이는 방법이 병렬 도구 호출이다. 모델이 한 응답 안에 도구 호출 여럿을 한꺼번에 담아 보내고, 우리 쪽 코드가 그것을 동시에 돌려 결과를 한 번에 돌려준다. 여기서 모델이 보낸 호출을 받아 실제 함수를 돌리고 결과를 모델에게 되돌리는 우리 쪽 코드를 실행기라고 부르자. 병렬 호출에서 모델이 하는 일은 "셋을 함께 부르겠다"고 적는 것까지이고, 셋을 정말 동시에 돌리는 것도, 하나가 죽었을 때 나머지를 살리는 것도 전부 실행기의 몫이다. 이 글은 무엇이 줄어드는지부터 재고, 묶어도 되는 호출을 가르는 기준, 실행기가 져야 할 책임, 쓰기 도구의 함정, 모델이 안 묶는 원인, 그리고 묶을 가치가 없는 자리 순으로 간다.
순차 루프의 시간
모델 왕복
한 번에 도구 하나만 부르는 루프에서는 도구 대기 시간만 더해지는 게 아니다. 모델에게 대화를 보내고 응답을 받아 오는 한 번을 모델 왕복이라고 하면, 호출과 호출 사이마다 모델 왕복이 하나씩 끼어 "다음에 뭘 부를까"를 정한다. 도구가 세 개면 모델 왕복은 네 번이다. 첫 왕복에서 날씨를 부르기로 정하고, 둘째에서 환율을, 셋째에서 일정을, 넷째에서 비로소 사용자에게 줄 답을 쓴다.
여기서 흔히 놓치는 것이 두 항의 크기다. 날씨나 환율 조회는 대개 수백 ms 안에 끝나는 HTTP 요청이다. 반면 모델 왕복은 입력 전체를 읽고 첫 토큰을 내기까지의 시간에 호출 인자나 답변을 생성하는 시간까지 더해지므로 1초 가까이 걸리는 일이 흔하다. 순차 루프를 느리게 만드는 주범은 도구가 아니라 도구 사이사이에 낀 모델 왕복인 경우가 많다.
두 식의 비교
줄어드는 항목을 식으로 적어 두면 이렇다.
은 모델 왕복 시간, 는 각 도구의 실행 시간, 은 도구 수다. 병렬에서는 첫 왕복에서 셋을 한꺼번에 부르고, 결과를 받은 둘째 왕복에서 답을 쓰므로 왕복이 둘로 고정된다. 도구 대기는 합이 아니라 가장 느린 하나만 남는다.
가령 도구 하나가 400ms, 모델 왕복이 900ms라 하고 숫자를 넣어 보자. 도구가 셋이면 순차는 900×4 + 400×3 = 4,800ms, 병렬은 900×2 + 400 = 2,200ms다. 절반 이하다. 줄어든 2,600ms를 쪼개 보면 모델 왕복 두 번이 1,800ms이고 도구 대기가 800ms다. 이득의 3분의 2가 왕복 쪽에서 나왔다. 도구가 여섯이면 순차는 900×7 + 400×6 = 8,700ms로 늘지만 병렬은 여전히 2,200ms 근처에 머문다. 모델 왕복 항이 에 비례하다가 상수가 된다는 것이 이 식에서 읽어야 할 전부다. 도구가 빠르고 모델이 느린 조합, 곧 대부분의 실제 시스템에서는 이쪽이 더 큰 이득이다.
거꾸로 보면 도구 하나가 유난히 느릴 때는 병렬의 이득이 작아진다. 셋 중 하나가 5초짜리 보고서 생성이면 순차든 병렬이든 그 5초가 지배한다. 병렬화는 느린 도구를 빠르게 만들지 않는다. 빠른 도구 여럿이 서로를 기다리게 만드는 낭비만 없앤다.
프리픽스 재전송
토큰 비용도 같이 준다. 대부분의 채팅 API는 상태를 서버에 들고 있지 않아서, 매 왕복마다 시스템 프롬프트와 도구 정의와 지금까지의 대화를 처음부터 다시 보낸다. 이렇게 매번 앞머리에 붙어 다시 나가는 부분을 프리픽스라고 한다. 왕복 횟수가 줄면 이 재전송도 함께 준다.
가령 시스템 프롬프트와 도구 정의와 대화를 합친 프리픽스가 6,000토큰이고, 호출 하나와 그 결과가 붙을 때마다 350토큰씩 늘어난다고 하자. 순차 네 왕복의 입력은 6,000·6,350·6,700·7,050토큰이라 합이 26,100토큰이다. 병렬 두 왕복은 6,000과 7,050이라 13,050토큰이다. 모델이 읽는 정보는 같은데 청구서의 입력 토큰은 반이 된다. 프롬프트 캐싱으로 반복되는 프리픽스를 싸게 처리하는 API라도 왕복마다 첫 토큰까지의 지연은 남으므로, 왕복을 줄이는 이득이 사라지지는 않는다.
묶을 수 있는 조건
데이터 의존
병렬화의 첫 전제는 어떤 호출도 다른 호출의 결과를 인자로 쓰지 않을 것이다. 뒤 호출이 앞 호출의 출력을 인자로 받는 관계를 데이터 의존이라고 한다. 사용자를 이메일로 찾아 user_id를 얻은 뒤 그 id로 주문 목록을 조회하는 흐름이 전형이다. 이걸 한 응답에 묶으면 모델은 아직 존재하지 않는 user_id를 지어내서 둘째 호출에 넣는다. 지어낸 id가 마침 다른 사람의 것이면 엉뚱한 주문을 보여 주고, 없는 id면 빈 결과를 "주문 내역이 없습니다"로 읽는다. 오류 없이 조용히 틀린 답이 나오는 전형적인 경로다.
| 상황 | 병렬 가능 | 이유 |
|---|---|---|
| 도시 세 곳의 날씨 조회 | 가능 | 같은 도구, 독립된 인자 |
| 날씨 + 환율 + 일정 | 가능 | 서로의 출력을 안 본다 |
| 사용자 조회 → 그 사용자의 주문 조회 | 불가 | 뒤가 앞의 user_id를 쓴다 |
| 재고 확인 → 주문 생성 | 불가 | 순서 자체가 의미다 |
| 결제 승인 + 포인트 적립 | 불가 | 앞이 실패하면 뒤를 하면 안 된다 |
실패 의존
표의 마지막 줄이 미묘하다. 결제 승인과 포인트 적립은 서로의 출력을 인자로 쓰지 않는다. 적립할 금액은 처음부터 사용자 요청에 들어 있다. 데이터 의존이 없으니 묶어도 될 것 같지만, 둘 사이에는 다른 종류의 끈이 있다. 앞이 실패하면 뒤를 하면 안 되는 관계, 곧 실패 의존이다. 병렬로 던지면 카드 한도 초과로 결제가 거절돼도 적립은 이미 나가 있다. 실행기가 결과를 모아 보는 시점에는 되돌릴 쓰기가 이미 하나 생겨 있는 셈이다.
실패 의존은 인자만 봐서는 안 보인다. 그래서 모델이 스스로 알아채기도 어렵다. 이런 조합은 데이터가 독립이어도 순차로 두고, 앞이 성공했을 때만 뒤를 부르도록 실행기나 도구 설계에서 막아야 한다. 결제와 적립을 아예 한 도구로 합쳐 서버 쪽 트랜잭션 안에서 처리하는 편이 더 깔끔할 때도 많다.
순서 의존
재고 확인 → 주문 생성은 또 다르다. 주문 생성 도구가 재고 확인의 결과를 인자로 받지 않을 수도 있고, 둘 다 실패하지 않을 수도 있다. 그래도 순서가 바뀌면 의미가 바뀐다. 재고가 없는데 주문이 먼저 들어가면 그 주문을 취소하는 절차가 따로 필요해진다. 이처럼 실행 순서 자체가 결과의 정당성을 정하는 관계를 순서 의존이라고 부르자. 데이터·실패·순서, 셋 중 하나라도 걸리면 묶지 않는다.
읽기와 쓰기
세 의존을 매번 따지는 것은 번거롭다. 실무에서 쓰기 좋은 판단 기준은 한 줄로 줄어든다 — 읽기끼리는 묶고, 쓰기는 묶지 않는다. 상태를 읽기만 하는 조회성 도구는 부작용이 없어서, 두 번 실행되거나 순서가 바뀌어도 세상에 남는 흔적이 없다. 실패 의존과 순서 의존은 거의 언제나 상태를 바꾸는 도구에서 생긴다. 남는 것은 데이터 의존인데, 이건 모델이 인자를 채우는 단계에서 드러나므로 읽기끼리도 따로 확인해야 한다.
이 기준이 좋은 것은 도구를 정의하는 시점에 한 번 정해 두면 된다는 점이다. 도구마다 읽기인지 쓰기인지 표시해 두면 실행기가 매 호출마다 그 표시만 보고 병렬 여부를 정한다. 판단을 모델에게 맡기지 않고 코드에 박아 두는 셈이다.
실행기의 책임
모델이 한 응답에 도구 호출 세 개를 담아 보내면, 그다음은 전부 우리 코드의 일이다.
import asyncio
WRITE_TOOLS = {"create_order", "cancel_order", "send_email"}
LIMIT = asyncio.Semaphore(5) # 동시에 나가는 호출 수 상한
async def run_tool_calls(calls, per_call=8.0, total=12.0):
# 1) 상태를 바꾸는 도구가 섞여 있으면 병렬로 돌리지 않는다.
if any(c.name in WRITE_TOOLS for c in calls):
return [await run_one(c, per_call) for c in calls]
async with asyncio.timeout(total): # 묶음 전체의 상한
results = await asyncio.gather(
*(run_one(c, per_call) for c in calls),
return_exceptions=True, # 2) 하나가 터져도 나머지를 살린다
)
# 3) 순서는 호출 순서 그대로 유지한다. 완료 순서가 아니다.
return [to_tool_result(c, r) for c, r in zip(calls, results)]
async def run_one(call, timeout):
async with LIMIT, asyncio.timeout(timeout):
return await TOOLS[call.name](**call.arguments)
주석 하나하나가 실제로 나는 사고에 대응한다.
부분 실패
묶음 안의 일부만 실패하고 나머지는 성공한 상태를 부분 실패라고 한다. return_exceptions=True가 없으면 세 조회 중 하나가 타임아웃 났을 때 gather 전체가 예외로 끝나 나머지 두 개의 성공 결과까지 버려진다. 모델은 셋 다 실패한 것으로 알고 전부 다시 부른다. 성공한 두 번의 비용을 한 번 더 치르는 셈이다.
실패한 하나만 오류로 표시해 돌려주면 모델은 훨씬 나은 판단을 한다. 그 하나만 다시 부르거나, 나머지 둘로 답할 수 있으면 "환율 정보는 지금 가져오지 못했습니다"라고 밝히고 답을 쓴다. 이때 오류 내용은 모델이 읽을 문장이어야 한다. 스택 트레이스를 그대로 넣기보다 "환율 API가 8초 안에 응답하지 않음, 재시도 가능" 정도로 줄여 주는 편이 모델의 다음 행동을 바르게 이끈다.
결과 순서
gather는 완료 순서와 상관없이 넘긴 순서대로 결과를 돌려준다. 이 성질을 깨는 것이 결과를 큐에 넣고 먼저 끝난 것부터 꺼내 붙이는 식의 구현이다. 완료된 순서대로 결과를 붙이면 모델이 보낸 호출과 받은 결과의 짝이 어긋날 수 있다.
대부분의 API는 호출마다 호출 id(tool_call_id 같은 필드)를 붙여 보내고, 결과에도 같은 id를 달아 돌려받는다. 그래서 id를 제대로 붙이면 순서가 섞여도 조용히 틀리지는 않는다. 문제는 id 없이 순서로만 맞추는 코드를 직접 짰을 때다. 서울 날씨와 부산 날씨의 결과가 뒤바뀌어도 둘 다 그럴듯한 날씨라 아무도 눈치채지 못한다. 결과는 요청 순서로 정렬하고, id로 한 번 더 짝을 확인한다. 두 겹이면 어느 한쪽이 깨져도 다른 쪽이 잡는다.
동시성 상한
모델이 한 번에 열두 개를 부르는 일이 있다. 도시 열두 곳의 날씨를 한꺼번에 묻는 식이다. 그게 그대로 외부 API로 나가면 초당 요청 수 제한, 곧 레이트리밋에 걸려 절반이 429 오류로 돌아온다. 그래서 동시에 나가는 호출 수에 동시성 상한을 둔다. 위 코드의 Semaphore(5)가 그것으로, 다섯 자리가 찰 때까지만 들여보내고 나머지는 앞이 끝나 자리가 날 때까지 기다리게 하는 문지기다.
상한을 두면 시간이 얼마나 느는지 따라가 보자. 400ms짜리 조회 열두 개에 상한 다섯이면 다섯, 다섯, 둘로 세 번에 나뉘어 1,200ms쯤 걸린다. 상한이 없으면 이론상 400ms지만, 레이트리밋에 걸려 재시도까지 하면 오히려 더 길어진다. 4~6 정도에서 시작해 외부 API의 제한을 보고 맞추는 것이 무난하다. 상한은 도구별로 따로 둘 수도 있다. 내부 캐시를 읽는 도구는 넉넉하게, 유료 외부 API는 빡빡하게 두는 식이다.
두 겹의 타임아웃
타임아웃은 둘을 따로 둔다. 호출 하나가 넘지 말아야 할 개별 타임아웃과, 묶음 전체가 넘지 말아야 할 전체 타임아웃이다. 위 코드에서는 각각 8초와 12초다.
하나만 두면 어느 쪽이든 구멍이 생긴다. 개별 타임아웃만 있으면 상한 때문에 줄을 선 호출들이 각자 8초씩 쓰면서 묶음 전체가 20초를 넘길 수 있다. 사용자는 그동안 빈 화면을 본다. 전체 타임아웃만 있으면 느린 하나가 12초를 다 먹는 동안 이미 끝난 둘도 함께 기다리고, 시간이 다 되면 셋 다 버려진다. 두 겹으로 두면 느린 하나는 8초에서 잘려 오류로 돌아가고, 나머지는 제때 결과를 낸다. 다만 위 코드처럼 전체 타임아웃이 gather를 통째로 감싸면 시간이 다 됐을 때 끝난 결과까지 함께 잃으므로, 실무에서는 전체 시간이 다 되면 그때까지 끝난 것만 거둬 나머지를 오류로 채우는 식으로 다듬는다.
부작용과 멱등성
중복 쓰기 경로
읽기 도구는 두 번 실행돼도 해가 없다. 쓰기 도구는 다르다. 같은 쓰기가 두 번 나가는 경로는 생각보다 많다. 가장 흔한 것은 타임아웃과 재시도의 조합이다. create_order를 보냈는데 8초 안에 응답이 없어 실행기가 타임아웃으로 처리한다. 그런데 서버는 9초째에 주문을 실제로 만들었다. 모델은 오류를 보고 다시 부르고, 주문이 둘이 된다.
병렬 호출은 여기에 경로를 하나 더 얹는다. 모델이 한 응답에 같은 쓰기 호출을 두 번 담는 일이다. "회의 참석자 셋에게 메일 보내 줘"에 send_email 셋을 담다가 한 사람에게 둘이 가는 식이다. 실행기가 이걸 그대로 병렬로 돌리면 두 호출이 거의 같은 순간 서버에 닿아, 서버 쪽 중복 확인조차 둘 다 "아직 없음"으로 통과하는 경쟁 상태가 생긴다. 앞 절의 실행기가 쓰기 도구가 섞이면 순차로 돌리는 이유 중 하나가 이것이다.
멱등 키
근본적인 방어는 쓰기 도구를 멱등하게 만드는 것이다. 멱등은 같은 요청을 몇 번 보내도 결과가 한 번 보낸 것과 같다는 성질이다. 흔한 구현은 요청마다 멱등 키라는 고유한 문자열을 붙이고, 서버가 이미 본 키면 새로 만들지 않고 처음 결과를 그대로 돌려주는 방식이다. 결제 API들이 오래전부터 이렇게 해 왔다.
에이전트에서 따져야 할 것은 그 키를 누가 만드느냐다. 키를 도구 인자로 열어 두고 모델에게 채우게 하면, 모델은 재시도할 때마다 새 키를 지어낼 수 있다. 그러면 키가 있어도 중복을 못 막는다. 키는 실행기가 만든다. 사용자 요청 id와 도구 이름과 핵심 인자를 묶어 해시하면, 모델이 같은 주문을 몇 번 다시 부르든 같은 키가 나온다. 모델에게는 키의 존재를 아예 안 보이는 편이 낫다. 모델이 볼 스키마에 없는 필드는 모델이 잘못 채울 수도 없다.
순차 유지
멱등 키를 갖췄다고 쓰기를 마음껏 묶어도 되는 것은 아니다. 멱등성은 같은 쓰기의 중복을 막을 뿐, 앞 절의 실패 의존과 순서 의존은 그대로 남는다. 결제와 적립을 멱등하게 만들어도 결제가 실패했을 때 적립이 나가는 문제는 그대로다.
그래서 판단은 이렇게 정리된다. 서로 다른 대상에 대한 같은 종류의 쓰기, 가령 참석자 셋에게 각각 보내는 초대 메일처럼 하나가 실패해도 나머지가 의미 있는 쓰기라면 멱등 키를 붙인 뒤 묶을 수 있다. 하나의 업무를 이루는 여러 단계의 쓰기라면 데이터가 독립이어도 순차로 둔다. 쓰기는 대개 읽기보다 드물고, 순차로 둬서 잃는 시간은 몇백 ms다. 잘못 묶어 생긴 중복 주문 하나를 사람이 정리하는 비용과는 견줄 바가 아니다.
묶지 않는 원인
모델이 병렬 호출을 지원해도 실제로 묶어 부를지는 별개다. 독립된 조회 셋을 줘도 하나씩 차례로 부르는 경우가 꽤 있고, 원인은 보통 셋 중 하나다.
순서 암시
모델이 도구를 고를 때 보는 것은 도구 이름과 설명문이다. 그 설명문에 "사용자를 조회한 뒤 주문을 조회합니다"처럼 순서를 암시하는 문장이 들어 있으면, 모델은 그 도구와 엮인 작업 전체를 순차 작업으로 읽는다. 문제는 이런 문장이 다른 도구의 설명에 들어 있어도 영향을 준다는 점이다. 도구 정의 전체가 한 프롬프트로 함께 읽히기 때문이다.
설명문에는 그 도구가 무엇을 하고 무엇을 돌려주는지만 적는다. 다른 도구와의 선후는 정말 데이터 의존이 있을 때만 적고, 그때도 "이 도구는 user_id가 필요하다"처럼 인자로 표현한다. 의존이 인자에 드러나 있으면 모델은 그 인자를 채울 값이 없을 때만 기다린다.
잘게 쪼갠 도구
도구가 지나치게 잘게 쪼개져 있어도 묶임이 줄어든다. get_weather_temp, get_weather_humidity, get_weather_wind처럼 한 대상의 값을 셋으로 나눠 두면, 모델은 이걸 하나의 작업을 이루는 단계로 인식해 순서대로 부르기 쉽다. 설령 묶어서 부르더라도 호출 셋, 결과 셋, 프리픽스에 붙는 토큰 셋이 생긴다.
같이 쓰이는 값은 한 도구가 함께 반환하는 편이 낫다. get_weather(city)가 기온·습도·바람을 한 번에 돌려주면 병렬화가 필요한 자리 자체가 사라진다. 병렬 호출이 빛나는 자리는 같은 도구를 다른 인자로 여러 번 부르거나, 서로 다른 도메인의 도구를 함께 부를 때다. 한 대상을 잘게 나눈 조각들을 묶는 것은 도구 설계의 빈틈을 실행 시간에 메우는 일에 가깝다.
단계적 사고 지시
시스템 프롬프트가 단계적 사고를 강하게 요구하는 경우도 있다. "한 번에 하나씩 신중하게 진행하세요", "각 단계의 결과를 확인한 뒤 다음 단계로 넘어가세요" 같은 지시는 정확도를 높이려고 넣은 문장이지만, 병렬 호출과 정면으로 부딪친다. 모델은 지시를 충실히 따라 독립된 조회조차 하나씩 부른다.
이런 문장은 쓰기 작업에만 걸리도록 범위를 좁힌다. "상태를 바꾸는 작업은 한 번에 하나씩 확인하며 진행한다"라고 적으면, 조심해야 할 자리에서는 조심하고 조회에서는 자유롭게 묶는다. 앞에서 본 읽기·쓰기 기준을 프롬프트에도 그대로 옮기는 셈이다.
유도 문장
반대로 묶임을 밀어 주는 것은 간단하다. 시스템 프롬프트에 한 문장이면 된다 — "서로의 결과가 필요하지 않은 조회는 한 번에 함께 요청한다." 반대 방향의 손잡이도 있다. API마다 병렬 호출 자체를 끄는 설정을 두고 있어서(OpenAI의 parallel_tool_calls, Anthropic의 disable_parallel_tool_use), 실행기가 아직 준비되지 않았으면 그 설정으로 막아 두면 된다.
순서가 중요하다. 그 문장을 넣기 전에 실행기가 부분 실패, 결과 순서, 동시성 상한, 두 겹의 타임아웃을 처리하는지부터 확인한다. 준비 안 된 실행기에 병렬 호출을 밀어 넣으면 지연 시간은 줄어도 장애가 는다. 순차일 때는 드러나지 않던 레이트리밋과 경쟁 상태가 묶이는 순간 한꺼번에 드러나기 때문이다.
적용 범위와 측정
손해 구간
도구가 한두 개뿐이면 이득이 거의 없다. 앞의 식에서 를 넣으면 줄어드는 것은 모델 왕복 한 번과 짧은 도구 대기 하나다. 그 몇백 ms를 위해 실행기에 동시성 상한과 두 겹의 타임아웃과 부분 실패 처리를 들이면 코드의 복잡도가 확실히 는다. 복잡도는 버그가 숨을 자리다.
외부 API가 초당 요청 수에 민감하거나 호출당 과금이 큰 경우도 마찬가지다. 모델은 묶을 수 있으면 넉넉하게 묶는 경향이 있어서, 순차였다면 첫 결과를 보고 부르지 않았을 호출까지 미리 던진다. 첫 검색에서 답이 나왔으면 둘째 검색은 필요 없었는데, 병렬로 던져 놓고 절반을 안 쓰게 되면 비용만 는다.
적용 조건
병렬 호출이 확실히 값을 하는 자리는 독립된 읽기 도구가 셋 이상 있고, 사용자가 응답을 기다리는 화면이다. 앞의 계산에서 도구 셋일 때 2.6초가 줄었다. 채팅 화면에서 2.6초는 사용자가 "멈췄나" 하고 새로 고침을 누르느냐 마느냐를 가르는 크기다. 반대로 밤사이 도는 배치 작업에서 2.6초는 아무도 느끼지 못한다. 그런 자리라면 순차로 두고 단순한 코드를 택하는 편이 낫다.
조건이 갖춰지지 않았으면 다른 것부터 최적화한다. 모델 왕복 자체를 줄이는 쪽, 가령 더 작은 모델로 도구 선택을 맡기거나 프리픽스를 줄여 첫 토큰을 앞당기는 쪽이 병렬화보다 손이 덜 가는 경우가 많다.
호출 수 분포
병렬 호출을 켰다고 끝이 아니다. 모델이 실제로 묶어 부르는지는 세어 봐야 안다. 가장 먼저 남길 것은 응답마다 담긴 도구 호출 개수다. 이걸 모아 분포를 보면 상태가 드러난다. 가령 도구를 부른 응답의 70%가 호출 한 개, 20%가 두 개, 10%가 세 개 이상이라 하자. 이것만으로는 좋은지 나쁜지 모른다. 비교할 기대값이 있어야 한다.
기대값은 로그에서 직접 뽑을 수 있다. 연달아 이어진 응답이 각각 읽기 호출 하나씩만 담고 있고, 뒤 호출의 인자가 앞 호출의 결과를 쓰지 않았다면, 그 둘은 묶일 수 있었는데 안 묶인 것이다. 이렇게 놓친 묶음을 세면 실제 묶음 크기와 가능했던 묶음 크기의 차이가 나온다. 차이가 크면 앞 절의 세 원인, 곧 설명문과 도구 분할과 프롬프트 지시를 차례로 의심한다.
도구별 부분 실패율
부분 실패율은 도구별로 나눠 본다. 묶음 전체의 실패율만 보면 어느 도구가 문제인지 안 보인다. 가령 셋을 묶었을 때 묶음의 15%에서 무언가 실패했는데, 나눠 보니 그 실패의 대부분이 환율 API의 타임아웃이라면 그 도구의 개별 타임아웃이나 동시성 상한을 손볼 자리다. 순차일 때는 멀쩡하던 도구가 묶인 뒤에만 실패한다면 레이트리밋을 의심한다. 동시에 들어오는 요청이 늘었기 때문이다.
모델 쪽 지표도 하나 함께 본다. 부분 실패를 돌려준 뒤 모델이 실패한 하나만 다시 부르는지, 셋을 전부 다시 부르는지다. 전부 다시 부른다면 오류 메시지가 모델에게 무엇이 성공했는지 충분히 알려 주지 못하고 있다는 뜻이다. 결국 모델이 묶을지, 실패한 뒤 무엇을 다시 부를지는 도구 이름과 설명문과 결과 문장을 읽고 정해진다. 함수 본문이 아니라 모델이 읽는 텍스트가 행동을 정한다는 것인데, 다음 글은 그 텍스트의 대부분을 차지하는 도구 스키마를 어떻게 쓸지 다룬다.
읽어주셔서 감사합니다. 😊

