Why does my agent keep spending after any sane budget would have cut it off?
๊ธฐํ
AI agents running multi-step workflows consume tokens at 20 to 100 times the rate of a single query, and there is no infrastructure-level primitive to enforce a spending or compute ceiling at runtime. When two agents enter a recursive clarification loop or a retrieval agent over-fetches context, the only signal is the invoice at the end of the month. Frameworks like LangGraph and AutoGen each handle retries and checkpoints but none enforce a resource contract that halts execution when a declared budget is breached. A January 2026 arXiv paper formalizes what such a contract would look like, but the gap between that formalism and a deployable primitive that works across model providers and tool calls remains wide open.
์ ์ค์ํ๊ฐ
A runtime resource contract is the missing safety layer that makes agent deployments safe to hand to non-engineers.
๊ธฐํ ํ๊ฐ ๋ฐฉ์
๊ธฐํ ์ ์๋ ์ธก์ ๊ฐ์ด ์๋ ์ ์ฃผ๊ด์ ํ๊ฐ์ ๋๋ค. ์ผ๋ง๋ ๋ถํธํ์ง, ์ผ๋ง๋ ์์ฃผ ๋ฐ์ํ๋์ง, ํ์ฌ ํด๊ฒฐ์ฑ ์ด ์ผ๋ง๋ ๋ถ์กฑํ์ง๋ฅผ ๋ฐ์ํฉ๋๋ค. ์ ์๊ฐ ๋์์๋ก ๋ง๋ค ๊ฐ์น๊ฐ ๋ ๋๋ค๊ณ ์๊ฐํฉ๋๋ค.
๋ฐ์ํ์ ๋ ์ผ๋ง๋ ํฐ ๋ถํธ์ ์ด๋ํ๋์ง.
์ค์ ๋ก ์ผ๋ง๋ ์์ฃผ ์ ํ๊ฒ ๋๋์ง.
ํ์ฌ ์ด๋ฅผ ํด๊ฒฐํ ๋งํ ๋๊ตฌ๊ฐ ์ผ๋ง๋ ๋ถ์กฑํ์ง.
ํด๊ฒฐํ ๊ฐ์น ์๋ ๋ ๋ง์ ๋ฌธ์ ๋ค
ํญ์ ๋ซ๋ ์๊ฐ ๋ชจ๋ AI ์ฑ์ด ๋๋ฅผ ์์ด๋ฒ๋ฆฌ๋ ์ด์ ๋ ๋ฌด์์ผ๊น?
AI์๋ก์ด ๋ถ์ผ๋ฅผ ๋ฐฐ์ฐ๋ ๊ฒ์ด ์ฌ์ ํ ๋ฌด์์ ๋ฌผ์ด์ผ ํ ์ง ์๋ ๊ฒ์ ์ํด ์ ํ๋ฐ๋ ์ด์ ๋ ๋ฌด์์ผ๊น?
AI๋น์ ๋ฌธ๊ฐ๋ ์ AI๊ฐ ๋งํ ๋ด์ฉ์ ๊ฒ์ฆํ ์ ์์๊น?
AI๋ชจ๋ธ์ ๋ฒค์น๋งํฌ๋ก ํ ์คํธํ๊ณ ๊ฐ์ผ๋ก ๋ฐฐํฌํ๋ ์ด์ ๋ ๋ฌด์์ผ๊น?
AIAI ์์ด์ ํธ๋ ์ ์์ ์ ์ค์๋ฅผ ๊ธฐ์ตํ์ง ๋ชปํ ๊น์?
AI๋ชจ๋ธ์ด ์ค์ ๋ก ๋ฌด์์ผ๋ก ํ์ตํ๋์ง ์ ๊ฐ์ฌํ ์ ์์๊น์?