12-ਸਵਾਲਾਂ ਦੇ ਇੱਕ ਟੈਸਟ ਵਿੱਚ, Bash wrappers ਨੇ ਸੱਤ-schema ਵਾਲੇ Model Context Protocol (MCP) ਨਾਲੋਂ ਵੱਧ tokens ਦੀ ਵਰਤੋਂ ਕੀਤੀ, ਜੋ ਇਹ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ shell ਉਹ ਸਸਤਾ ਸ਼ਾਰਟਕੱਟ ਨਹੀਂ ਹੈ ਜੋ ਬਹੁਤ ਸਾਰੇ ਇੰਜੀਨੀਅਰ ਸੋਚਦੇ ਹਨ। Token ਦੀ ਵਰਤੋਂ ਸਿੱਧੇ ਤੌਰ 'ਤੇ ਉਹਨਾਂ large-language-model (LLM) agents ਦੀ ਲਾਗਤ ਵਿੱਚ ਬਦਲ ਜਾਂਦੀ ਹੈ ਜੋ ਵੱਡੇ ਪੱਧਰ 'ਤੇ ਚੱਲਦੇ ਹਨ।

ਉਹ ਪ੍ਰਯੋਗ ਜਿਸ ਨੇ ਸਭ ਕੁਝ ਬਦਲ ਦਿੱਤਾ

ਇੱਕ ਡਿਵੈਲਪਰ ਨੇ ਚਾਰ ਤਰੀਕਿਆਂ ਦੀ ਮਾਪ ਕੀਤੀ ਜਿਸ ਨਾਲ ਇੱਕ LLM agent ਜਹਾਜ਼ਾਂ (vessel) ਦਾ ਡਾਟਾ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦਾ ਸੀ:

  • MCP – Model Context Protocol ਦੇ ਪਿੱਛੇ ਹੋਸਟ ਕੀਤੇ ਗਏ ਸੱਤ tool schemas.
  • Bash + curl (cold) – ਬਿਨਾਂ ਕਿਸੇ ਵਾਧੂ prompting ਦੇ ਇੱਕ raw shell call.
  • Bash + curl (warm) – ਉਹੀ shell call ਅਤੇ ਨਾਲ ਹੀ system prompts ਜੋ ਸੁਰੱਖਿਅਤ ਵਰਤੋਂ ਲਈ ਮਾਰਗਦਰਸ਼ਨ ਕਰਦੇ ਹਨ।
  • Dedicated CLI tool – ਇੱਕ ਖਾਸ ਉਦੇਸ਼ ਲਈ ਬਣਾਇਆ ਗਿਆ command-line interface.

ਇਹ ਚਾਰੇ ਤਰੀਕੇ 12-ਸਵਾਲਾਂ ਵਾਲੀ ਗੱਲਬਾਤ ਰਾਹੀਂ ਚਲਾਏ ਗਏ। Token ਦੀ ਖਪਤ, ਜੋ API ਬਿੱਲਾਂ ਨੂੰ ਵਧਾਉਂਦੀ ਹੈ, ਇਸ ਤਰ੍ਹਾਂ ਰਹੀ:

  • MCP: 109,779 tokens
  • Bash + curl (cold): 158,021 tokens
  • Bash + curl (warm): 178,577 tokens

Dedicated CLI tool ਦੇ ਅੰਕਾਂ ਦਾ ਖੁਲਾਸਾ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਸੀ, ਪਰ Bash ਦੇ ਦੋਵੇਂ ਰੂਪ ਪਹਿਲਾਂ ਹੀ MCP ਨਾਲੋਂ ਵੱਧ ਖਰਚਾ ਕਰ ਚੁੱਕੇ ਸਨ।

Shell ਦਾ ਖਰਚਾ protocol ਨਾਲੋਂ ਵੱਧ ਕਿਉਂ ਸੀ

ਹਰੇਕ Bash tool ਨੂੰ ਲਗਭਗ 2,700 tokens ਦੇ “harness prompts” ਦੀ ਲੋੜ ਸੀ – ਉਹ ਹਦਾਇਤਾਂ ਜੋ agent ਨੂੰ ਦੱਸਦੀਆਂ ਹਨ ਕਿ shell ਨੂੰ ਸੁਰੱਖਿਅਤ ਤਰੀਕੇ ਨਾਲ ਕਿਵੇਂ ਬੁਲਾਉਣਾ ਹੈ, output ਨੂੰ ਕਿਵੇਂ ਪੜ੍ਹਨਾ (parse) ਹੈ, ਅਤੇ ਗਲਤੀਆਂ (errors) ਨੂੰ ਕਿਵੇਂ ਸੰਭਾਲਣਾ ਹੈ। ਸਿਰਫ਼ ਉਹ prompts ਹੀ ਸੱਤੋਂ MCP schemas ਦੇ ਕੁੱਲ token ਭਾਰ ਤੋਂ ਵੱਧ ਹਨ।

ਖਰਚਾ ਸਿਰਫ਼ ਸ਼ੁਰੂਆਤੀ call ਤੱਕ ਸੀਮਤ ਨਹੀਂ ਹੈ। Production ਵਿੱਚ, ਉਹੀ agent ਸ਼ੁਰੂਆਤ ਵਿੱਚ ਹੀ 11 MCP servers ਨੂੰ pre-load ਕਰਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਪਹਿਲੇ user query ਦੇ ਆਉਣ ਤੋਂ ਪਹਿਲਾਂ ਹੀ 19,800 tokens ਖਪਤ ਹੋ ਜਾਂਦੇ ਹਨ। ਫਿਰ, ਹਰ ਵਾਰ (turn), agent ਹਰੇਕ server ਤੋਂ ਹਰ schema ਨੂੰ ਦੁਬਾਰਾ ਪੜ੍ਹਦਾ ਹੈ, ਇਸ ਲਈ "ਕੀ ਸਮਾਂ ਹੋਇਆ ਹੈ?" ਵਰਗੀ ਇੱਕ ਮਾਮੂਲੀ ਬੇਨਤੀ ਲਈ ਵੀ ਬਾਕੀ ਸਾਰੇ tool descriptions ਦੀ token ਕੀਮਤ ਚੁਕਾਉਣੀ ਪੈਂਦੀ ਹੈ।

Eager loading ਦਾ ਲੁਕਿਆ ਹੋਇਆ ਨੁਕਸਾਨ

ਜਦੋਂ ਇੱਕ LLM agent ਹਰ ਵਾਰ (turn) ਹਰੇਕ tool server ਨੂੰ eagerly load ਕਰਦਾ ਹੈ, ਤਾਂ token ਦਾ ਬਿੱਲ ਬਹੁਤ ਜ਼ਿਆਦਾ ਵਧ ਜਾਂਦਾ ਹੈ। ਪ੍ਰਯੋਗ ਨੇ ਦਿਖਾਇਆ ਕਿ Bash ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ "ਅਸਲ" ਕੀਮਤ shell command ਨਹੀਂ ਹੈ, ਸਗੋਂ ਉਹ ਆਲੇ-ਦੁਆਲੇ ਦਾ context ਹੈ ਜੋ ਹਰ ਵਾਰ model ਨੂੰ ਭੇਜਣਾ ਪੈਂਦਾ ਹੈ।

  • Fixed-cost tools (MCP schemas) ਹਰ turn 'ਤੇ ਇੱਕ ਅਨੁਮਾਨਿਤ token overhead ਜੋੜਦੇ ਹਨ।
  • Dynamic payloads (curl responses) ਇੱਕ ਵਧ ਰਿਹਾ ਕਰਜ਼ਾ ਜੋੜਦੇ ਹਨ ਜੋ ਗੱਲਬਾਤ ਦੀ ਲੰਬਾਈ ਅਤੇ ਡਾਟਾ ਦੇ ਆਕਾਰ ਦੇ ਨਾਲ ਵਧਦਾ ਹੈ।

ਇਸ ਤਰ੍ਹਾਂ, ਇੱਕ shell ਜੋ ਉੱਪਰੋਂ "ਮੁਫ਼ਤ" ਲੱਗਦਾ ਹੈ, ਅਸਲ ਵਿੱਚ ਇੱਕ ਵੱਡਾ ਅਤੇ ਬਦਲਣ ਵਾਲਾ token tax ਲਾਗੂ ਕਰਦਾ ਹੈ।

AI ਇੰਜੀਨੀਅਰਾਂ ਨੂੰ ਅੱਗੇ ਕੀ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ

  • Lazy loading ਅਪਣਾਓ। ਇੱਕ tool server ਨੂੰ ਉਦੋਂ ਹੀ load ਕਰੋ ਜਦੋਂ ਉਸਦੇ schema ਦੀ ਅਸਲ ਵਿੱਚ ਲੋੜ ਹੋਵੇ, ਅਤੇ ਹਰ ਵਾਰ ਦੁਬਾਰਾ ਪੜ੍ਹਨ ਦੀ ਬਜਾਏ ਇਸਨੂੰ turns ਦੇ ਦੌਰਾਨ memory ਵਿੱਚ ਰੱਖੋ।
  • Tool schemas ਨੂੰ ਹਰ turn ਦਾ ਇੱਕ ਨਿਸ਼ਚਿਤ ਖਰਚਾ ਮੰਨੋ। Shell commands ਨੂੰ ਮੁਫ਼ਤ ਮੰਨਣ ਦੀ ਬਜਾਏ, MCP definitions ਦੇ ਜਾਣੇ-ਪਛਾਣੇ ਆਕਾਰ ਦੇ ਆਧਾਰ 'ਤੇ token budget ਦੀ ਯੋਜਨਾ ਬਣਾਓ।
  • "shell = cheap" ਦੀਆਂ ਧਾਰਨਾਵਾਂ ਦਾ ਮੁੜ ਮੁਲਾਂਕਣ ਕਰੋ। ਕਿਸੇ ਡਿਜ਼ਾਈਨ ਨੂੰ ਅੰਤਿਮ ਰੂਪ ਦੇਣ ਤੋਂ ਪਹਿਲਾਂ ਹਰੇਕ tool path ਲਈ token ਦੀ ਵਰਤੋਂ ਦਾ profile ਬਣਾਓ।
  • ਛੋਟੇ models ਲਈ shaped tools ਦੀ ਵਰਤੋਂ ਕਰੋ। ਸੀਮਤ context windows ਦੇ ਬਾਵਜੂਦ, ਚੰਗੀ ਤਰ੍ਹਾਂ ਪਰਿਭਾਸ਼ਿਤ schemas reasoning, unit conversion, ਅਤੇ error handling ਵਿੱਚ ਸੁਧਾਰ ਕਰਦੇ ਹਨ।

ਸਾਰੰਸ਼: protocol design ਨਹੀਂ, ਸਗੋਂ token economics ਲਾਗਤ ਤੈਅ ਕਰਦੀ ਹੈ। Tool servers ਨੂੰ ਕਦੋਂ ਅਤੇ ਕਿਵੇਂ load ਕੀਤਾ ਜਾਣਾ ਹੈ, ਇਸ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨ ਨਾਲ ਗੱਲਬਾਤ ਵਿੱਚੋਂ ਦਸ ਹਜ਼ਾਰਾਂ tokens ਬਚਾਏ ਜਾ ਸਕਦੇ ਹਨ, ਜਿਸ ਨਾਲ ਸਿੱਧੇ ਤੌਰ 'ਤੇ ਸੰਚਾਲਨ ਖਰਚੇ (operational spend) ਘਟਦੇ ਹਨ।

ਸਰੋਤ: https://dev.to/clarkbw--/enabling-bash-costs-more-context-than-seven-mcp-tool-schemas-2h82