## Diagram: Comparison of LLM Agent Action Paradigms (Text/JSON vs. Code) ### Overview The image is a technical diagram comparing two paradigms for an LLM (Large Language Model) agent to solve a multi-step problem. The task is to determine the most cost-effective country (USA, Japan, Germany, India) to purchase a "CodeAct 1" smartphone. The diagram contrasts an agent using discrete **Text/JSON** actions with an agent using a single **Code** action (labeled "CodeAct"). It visually demonstrates the workflow, required interactions, and final output for each approach. ### Components/Axes The diagram is structured into three main horizontal sections and two primary vertical columns. **1. Header Section (Top):** * **Instruction Box (Top-Left):** Contains the task prompt: "Determine the most cost-effective country to purchase the smartphone model 'CodeAct 1'. The countries to consider are the USA, Japan, Germany, and India." * **Available APIs Box (Top-Right):** Lists five available functions (APIs) the agent can call: * `[1] lookup_rates(country: str) -> (float, float)` * `[2] convert_and_tax(price: float, exchange_rate: float, tax_rate: float) -> float` * `[3] estimate_final_price(converted_price: float, shipping_cost: float) -> float` * `[4] lookup_phone_price(model: str, country: str) -> float` * `[5] estimate_shipping_cost(destination_country: str) -> float` **2. Main Comparison Section (Center):** This section is split into two columns, each representing an agent paradigm. * **Left Column: "LLM Agent using [Text/JSON] as Action"** * **Layout:** A vertical sequence of steps, each with an icon, label, and content. * **Icons:** A robot head for "Think", a code tag `</>` for "Action", a globe for "Environment", and a speech bubble for "Response". * **Content Flow:** Shows a step-by-step, interactive process where the agent thinks, issues a single tool call (in both plain text and JSON format), receives an environment response, and repeats. * **Right Column: "CodeAct: LLM Agent using [Code] as Action"** * **Layout:** A more consolidated view with a large code block as the central action. * **Icons:** Same as the left column. * **Content Flow:** Shows the agent thinking, then issuing a single, comprehensive block of Python code. The environment executes this code and returns a final result. * **Annotations:** Two green callout boxes with arrows highlight advantages: 1. Points to a `for` loop in the code: "Control & Data Flow of Code Simplifies Complex Operations" 2. Points to the use of `min()`: "Re-use `min` Function from Existing Software Infrastructures (Python library)" * **Central Arrow:** A large green arrow between the columns points from left to right with the text "Fewer Actions Required!". **3. Footer/Response Section (Bottom):** * Both columns conclude with a "Response" step showing identical final output. ### Detailed Analysis **Text/JSON Agent Workflow (Left Column - Partial Sequence Shown):** 1. **Think:** "I should calculate the phone price in USD for each country, then find the most cost-effective country." 2. **Action (Text):** `lookup_rates, Germany` **Action (JSON):** `{"tool": "lookup_rates", "country": "Germany"}` 3. **Environment:** `1.1, 0.19` (Presumably exchange_rate and tax_rate for Germany). 4. **Action (Text):** `lookup_phone_price, CodeAct 1, Germany` **Action (JSON):** `{"tool": "lookup_phone_price", "model": "CodeAct 1", "country": "Germany"}` 5. **Environment:** `700` (Local price in Germany). 6. **Action (Text):** `convert_and_tax, 700, 1.1, 0.19` **Action (JSON):** `{"tool": "convert_and_tax", "price": 700, "exchange_rate": 1.1, "tax_rate": 0.19}` 7. **Environment:** `916.3` (Price after conversion and tax). 8. **Note:** `[... interactions omitted (look up shipping cost and calculate final price) ...]` 9. **Action (Text):** `lookup_rates, Japan` (Begins process for next country). 10. **Note:** `[... interactions omitted (calculate final price for all other countries)...]` 11. **Response:** "The most cost-effective country to purchase the smartphone model is Japan with price 904.00 in USD." **CodeAct Agent Workflow (Right Column):** 1. **Think:** Identical to left column: "I should calculate the phone price in USD for each country, then find the most cost-effective country." 2. **Action (Code Block):** A single Python script: ```python countries = ['USA', 'Japan', 'Germany', 'India'] final_prices = {} for country in countries: exchange_rate, tax_rate = lookup_rates(country) local_price = lookup_phone_price("CodeAct 1", country) converted_price = convert_and_tax( local_price, exchange_rate, tax_rate ) shipping_cost = estimate_shipping_cost(country) final_price = estimate_final_price(converted_price, shipping_cost) final_prices[country] = final_price most_cost_effective_country = min(final_prices, key=final_prices.get) most_cost_effective_price = final_prices[most_cost_effective_country] print(most_cost_effective_country, most_cost_effective_price) ``` 3. **Environment:** `1.1, 0.19` (This appears to be a sample output from one of the `lookup_rates` calls within the code execution). 4. **Response:** "The most cost-effective country to purchase the smartphone model is Japan with price 904.00 in USD." ### Key Observations 1. **Identical Outcome:** Both paradigms arrive at the same conclusion: Japan is the most cost-effective country at $904.00 USD. 2. **Action Granularity:** The Text/JSON agent requires multiple, sequential, single-purpose actions (at least 4 per country, for 4 countries = 16+ actions). The CodeAct agent uses a single, composite action containing a programmatic loop. 3. **State Management:** The Text/JSON agent's state (intermediate values like `916.3`) is managed externally by the environment between calls. The CodeAct agent manages all intermediate state (`final_prices` dictionary) internally within its code. 4. **Efficiency Highlight:** The diagram explicitly notes "Fewer Actions Required!" and shows how code leverages control flow (`for` loop) and existing library functions (`min`). 5. **Visual Coding:** Actions (agent outputs) are in red text. Environment responses are in blue text. The final response is in standard black text. ### Interpretation This diagram serves as an advocacy piece for the "CodeAct" paradigm, arguing that enabling LLM agents to write and execute code is more efficient and powerful than having them issue discrete, text-based API calls. * **The Core Argument:** The problem requires repetitive, structured computation across multiple data points (countries). A code-based approach naturally handles this repetition via loops and variables, consolidating what would be dozens of discrete interactions into a single, self-contained program. * **Underlying Message:** It suggests that code is a more "native" and expressive tool for complex, multi-step reasoning and data manipulation than serialized text/JSON commands. The agent can leverage the full expressiveness of a programming language (like Python) rather than being limited to a predefined set of API calls. * **Practical Implication:** For tasks involving data aggregation, iteration, or mathematical computation, a CodeAct agent could significantly reduce latency, cost (fewer API calls), and complexity in the agent-environment interaction protocol. The diagram implies that the CodeAct approach is a step toward more capable and autonomous AI agents. * **Peircean Reading:** The diagram is an *icon* (it visually resembles the process it describes) and an *index* (it points to a causal relationship: using code *causes* fewer actions). Its *symbolic* meaning is that code is a superior medium for agent action in complex problem-solving domains. The green annotations act as interpretants, guiding the viewer to the intended conclusion about simplification and reuse.