LangChain: A Comprehensive Beginner’s Guide Large language models are powerful, but on their own they have limitations. They cannot access live […]

Liquid AI’s LFM2-2.6B-Exp Uses Pure Reinforcement Learning RL And Dynamic Hybrid Reasoning To Tighten Small Model Behavior Liquid AI has introduced […]

How to Build Production-Grade Agentic Workflows with GraphBit Using Deterministic Tools, Validated Execution Graphs, and Optional LLM OrchestrationI […]

Data Analyst Learning Path 2026The role of a Data Analyst in 2026 looks very different from even a few years ago. Today’s analysts are expected t […]

Top 6 YouTube Channels to Learn SQLSQL is one of those skills that shows up everywhere, data analytics, backend engineering, reporting, and even […]

From Gemma 3 270M to FunctionGemma, How Google AI Built a Compact Function Calling Specialist for Edge WorkloadsGoogle has released FunctionGemma, […]

Training a Model on Multiple GPUs with Data ParallelismThis article is divided into two parts; they are: • Data Parallelism • Distributed Data Parallelism If you have multiple GPUs, you can combine them to operate as a single GPU with greater memory capacity.

Train a Model Faster with torch.compile and Gradient AccumulationThis article is divided into two parts; they are: • Using `torch.

Instagram Story Polls: Low Effort, High EngagementPolling the people is a centuries-old tradition. Doing so digitally? That’s only been a thing for a few decades (but then again, the same could be…

MIT Technology Review’s most popular stories of 2025It’s been a busy and productive year here at MIT Technology Review. We published magazine i […]

Build AI Agents with RapidAPI for Real-Time DataAgent creation has become easier than ever but have you ever thought – how can we make them m […]

Build Your Own NotebookLlama: A PDF to Podcast Pipeline (Open, Fast, and Fully Yours)The NotebookLM is a relatively new Internet phenomenon, in which […]

A Coding Implementation on Building Self-Organizing Zettelkasten Knowledge Graphs and Sleep-Consolidation Mechanisms In this tutorial, we dive […]

The paints, coatings, and chemicals making the world a cooler placeIt’s getting harder to beat the heat. During the summer of 2025, heat waves k […]

MiniMax Releases M2.1: An Enhanced M2 Version with Features like Multi-Coding Language Support, API Integration, and Improved Tools for Structured Coding Just months after releasing M2—a fast, low-cost model designed for agents and code—MiniMax has introduced an enhanced version: MiniMax M2.1. M2 already stood out for its efficiency, running at roughly 8% of the cost of Claude Sonnet while delivering significantly higher speed. More importantly, it introduced a different computational and reasoning pattern, particularly in how the model structures and executes its thinking during complex code and tool-driven workflows. M2.1 builds on this foundation, bringing tangible improvements across key areas: better code quality, smarter instruction following, cleaner reasoning, and stronger performance across multiple programming languages. These upgrades extend the original strengths of M2 while staying true to MiniMax’s vision of “Intelligence with Everyone.” Strengthening the core capabilities of M2, M2.1 is no longer just about better coding—it also produces clearer, more structured outputs across conversations, documentation, and writing. Core Capabilities and Benchmark Results Built for real-world coding and AI-native teams: Designed to support everything from rapid “vibe builds” to complex, production-grade workflows. Goes beyond coding: Produces clearer, more structured, and higher-quality outputs across everyday conversations, technical documentation, and writing tasks. State-of-the-art multilingual coding performance: Achieves 72.5% on SWE-Multilingual, outperforming Claude Sonnet 4.5 and Gemini 3 Pro across multiple programming languages. Strong AppDev & WebDev capabilities: Scores 88.6% on VIBE-Bench, exceeding Claude Sonnet 4.5 and Gemini 3 Pro, with major improvements in native Android, iOS, and modern web development. Excellent agent and tool compatibility: Delivers consistent and stable performance across leading coding tools and agent frameworks, including Claude Code, Droid (Factory AI), Cline, Kilo Code, Roo Code, BlackBox, and more. Robust context management support: Works reliably with advanced context mechanisms such as Skill.md, Claude.md / agent.md / cursorrule, and Slash Commands, enabling scalable agent workflows. Automatic caching, zero configuration: Built-in caching works out of the box to reduce latency, lower costs, and deliver a smoother overall experience. Getting Started with MiniMax M2.1 To get started with MiniMax M2.1, you’ll need an API key from the MiniMax platform. You can generate one from the MiniMax user console. Once issued, store the API key securely and avoid exposing it in code repositories or public environments. Installing & Setting up the dependencies MiniMax supports both the Anthropic and OpenAI API formats, making it easy to integrate MiniMax models into existing workflows with minimal configuration changes—whether you’re using Anthropic-style message APIs or OpenAI-compatible setups. Copy CodeCopiedUse a different Browserpip install anthropic Copy CodeCopiedUse a different Browserimport os from getpass import getpass os.environ[‘ANTHROPIC_BASE_URL’] = ‘https://api.minimax.io/anthropic’ os.environ[‘ANTHROPIC_API_KEY’] = getpass(‘Enter MiniMax API Key: ‘) With just this minimal setup, you’re ready to start using the model. Sending Requests to the Model MiniMax M2.1 returns structured outputs that separate internal reasoning (thinking) from the final response (text). This allows you to observe how the model interprets intent and plans its answer before producing the user-facing output. Copy CodeCopiedUse a different Browserimport anthropic client = anthropic.Anthropic() message = client.messages.create( model=”MiniMax-M2.1″, max_tokens=1000, system=”You are a helpful assistant.”, messages=[ { “role”: “user”, “content”: [ { “type”: “text”, “text”: “Hi, how are you?” } ] } ] ) for block in message.content: if block.type == “thinking”: print(f”Thinking:n{block.thinking}n”) elif block.type == “text”: print(f”Text:n{block.text}n”) Copy CodeCopiedUse a different BrowserThinking: The user is just asking how I am doing. This is a friendly greeting, so I should respond in a warm, conversational way. I’ll keep it simple and friendly. Text: Hi! I’m doing well, thanks for asking! I’m ready to help you with whatever you need today. Whether it’s coding, answering questions, brainstorming ideas, or just chatting, I’m here for you. What can I help you with? What makes MiniMax stand out is the visibility into its reasoning process. Before producing the final response, the model explicitly reasons about the user’s intent, tone, and expected style—ensuring the answer is appropriate and context-aware.  By cleanly separating reasoning from responses, the model becomes easier to interpret, debug, and trust, especially in complex agent-based or multi-step workflows, and with M2.1 this clarity is paired with faster responses, more concise reasoning, and substantially reduced token consumption compared to M2. Testing the Model’s Coding Capabilities MiniMax M2 stands out for its native mastery of Interleaved Thinking, allowing it to dynamically plan and adapt within complex coding and tool-based workflows, and M2.1 extends this capability with improved code quality, more precise instruction following, clearer reasoning, and stronger performance across programming languages—particularly in handling composite instruction constraints as seen in OctoCodingBench—making it ready for office automation. To evaluate these capabilities in practice, let’s test the model using a structured coding prompt that includes multiple constraints and real-world engineering requirements. Copy CodeCopiedUse a different Browserimport anthropic client = anthropic.Anthropic() def run_test(prompt: str, title: str): print(f”n{‘=’*80}”) print(f”TEST: {title}”) print(f”{‘=’*80}n”) message = client.messages.create( model=”MiniMax-M2.1″, max_tokens=10000, system=( “You are a senior software engineer. ” “Write production-quality code with clear structure, ” “explicit assumptions, and minimal but sufficient reasoning. ” “Avoid unnecessary verbosity.” ), messages=[ { “role”: “user”, “content”: [{“type”: “text”, “text”: prompt}] } ] ) for block in message.content: if block.type == “thinking”: print(” Thinking:n”, block.thinking, “n”) elif block.type == “text”: print(” Output:n”, block.text, “n”) PROMPT= “”” Design a small Python service that processes user events. Requirements: 1. Events arrive as dictionaries with keys: user_id, event_type, timestamp. 2. Validate input strictly (types + required keys). 3. Aggregate events per user in memory. 4. Expose two functions: – ingest_event(event: dict) -> None – get_user_summary(user_id: str) -> dict 5. Code must be: – Testable – Thread-safe – Easily extensible for new event types 6. Do NOT use external libraries. Provide: – Code only – Brief inline comments where needed “”” run_test(prompt=PROMPT, title=”Instruction Following + Architecture”) This test uses a deliberately structured and constraint-heavy prompt designed to evaluate more than just code generation. The prompt requires strict input validation, in-memory state management, thread safety, testability, and extensibility—all without relying on external libraries. By combining architectural decisions with multiple non-trivial constraints, the prompt operates at a medium-to-high complexity level, making it well-suited for assessing how effectively MiniMax M2.1 follows instructions, reasons through design trade-offs, and produces production-quality code rather than isolated snippets. Model Reasoning & Output The model reasons through key architectural trade-offs before coding, carefully balancing flexibility, memory usage, and extensibility. It evaluates multiple approaches to event aggregation and deliberately chooses raw event storage to enable future extensions without modifying ingestion logic.  Thread safety is explicitly handled through locking, and strict input validation is planned to ensure data correctness, reflecting a real-world, engineering-first mindset rather than jumping straight to implementation. This thoughtful reasoning is reflected in the final output, which demonstrates strong code quality through clear structure, meaningful naming, type hints, and a thread-safe design aligned with production standards. The solution follows all prompt constraints accurately—covering validation, in-memory aggregation, extensibility, and the absence of external dependencies—while maintaining clean, focused logic that avoids unnecessary complexity and remains easy to maintain. Copy CodeCopiedUse a different Browserimport threading from typing import Dict, List, Any class EventProcessor: “”” Thread-safe event processor that aggregates user events in memory. Validates input strictly and supports easy extension for new event types. “”” def __init__(self) -> None: # Stores events per user: user_id -> list of event dictionaries self._user_events: Dict[str, List[Dict[str, Any]]] = {} # Lock for thread-safe access self._lock = threading.Lock() def ingest_event(self, event: dict) -> None: “”” Validate and ingest a single event. Strictly validates types and presence of required keys. “”” # Validate event is a dictionary if not isinstance(event, dict): raise ValueError(“Event must be a dictionary”) # Validate required keys and their types required_keys = { ‘user_id’: str, ‘event_type’: str, ‘timestamp’: (str, int, float) # Accept string or numeric timestamp } for key, expected_type in required_keys.items(): if key not in event: raise ValueError(f”Missing required key: ‘{key}'”) if not isinstance(event[key], expected_type): raise ValueError(f”Key ‘{key}’ must be of type {expected_type.__name__}”) # Thread-safe event storage with self._lock: user_id = event[‘user_id’] if user_id not in self._user_events: self._user_events[user_id] = [] self._user_events[user_id].append(event) def get_user_summary(self, user_id: str) -> dict: “”” Generate summary for a specific user. Returns aggregated event counts and timestamps. “”” if not isinstance(user_id, str): raise ValueError(“user_id must be a string”) with self._lock: user_events = self._user_events.get(user_id, []) # Aggregate event counts event_counts = {} timestamps = [] for event in user_events: event_type = event[‘event_type’] event_counts[event_type] = event_counts.get(event_type, 0) + 1 timestamps.append(event[‘timestamp’]) return { ‘user_id’: user_id, ‘total_events’: len(user_events), ‘event_counts’: event_counts, ‘timestamps’: sorted(timestamps) if timestamps else [] } “` **Key Design Choices:** 1. **Thread Safety**: Uses `threading.Lock` to protect shared state during concurrent access 2. **Input Validation**: Strict type checking for required keys with clear error messages 3. **Extensibility**: – New event types automatically handled by dynamic counting – Easy to add new aggregations in `get_user_summary` 4. **Testability**: Clear separation of concerns, easy to mock for unit tests 5. **Memory Efficiency**: Stores only essential data (event dictionaries) **Usage Example:** “`python processor = EventProcessor() # Ingest events processor.ingest_event({ ‘user_id’: ‘user123’, ‘event_type’: ‘login’, ‘timestamp’: ‘2023-01-01T10:00:00Z’ }) # Get user summary summary = processor.get_user_summary(‘user123’) print(summary) Model’s Interleaved Thinking in Action Let’s now see MiniMax M2.1’s interleaved thinking in action. We ask the model to compare two organizations based on P/E ratio and sentiment, using two dummy tools to clearly observe how the workflow operates.  This example demonstrates how M2.1 interacts with external tools in a controlled, agent-style setup. One tool simulates fetching stock metrics, while the other provides sentiment analysis, with both returning locally generated responses. As the model receives these tool outputs, it incorporates them into its reasoning and adjusts its final comparison accordingly. Defining the tools Copy CodeCopiedUse a different Browserimport anthropic import json client = anthropic.Anthropic() def get_stock_metrics(ticker): data = { “NVDA”: {“price”: 130, “pe”: 75.2}, “AMD”: {“price”: 150, “pe”: 40.5} } return json.dumps(data.get(ticker, “Ticker not found”)) def get_sentiment_analysis(company_name): sentiments = {“NVIDIA”: 0.85, “AMD”: 0.42} return f”Sentiment score for {company_name}: {sentiments.get(company_name, 0.0)}” tools = [ { “name”: “get_stock_metrics”, “description”: “Get price and P/E ratio.”, “input_schema”: { “type”: “object”, “properties”: {“ticker”: {“type”: “string”}}, “required”: [“ticker”] } }, { “name”: “get_sentiment_analysis”, “description”: “Get news sentiment score.”, “input_schema”: { “type”: “object”, “properties”: {“company_name”: {“type”: “string”}}, “required”: [“company_name”] } } ] Model Execution with Tool Interaction Copy CodeCopiedUse a different Browsermessages = [{“role”: “user”, “content”: “Compare NVDA and AMD value based on P/E and sentiment.”}] running = True print(f” [USER]: {messages[0][‘content’]}”) while running: # Get model response response = client.messages.create( model=”MiniMax-M2.1″, max_tokens=4096, messages=messages, tools=tools, ) messages.append({“role”: “assistant”, “content”: response.content}) tool_results = [] has_tool_use = False for block in response.content: if block.type == “thinking”: print(f”n [THINKING]:n{block.thinking}”) elif block.type == “text”: print(f”n [MODEL]: {block.text}”) if not any(b.type == “tool_use” for b in response.content): running = False elif block.type == “tool_use”: has_tool_use = True print(f” [TOOL CALL]: {block.name}({block.input})”) # Execute the correct mock function if block.name == “get_stock_metrics”: result = get_stock_metrics(block.input[‘ticker’]) elif block.name == “get_sentiment_analysis”: result = get_sentiment_analysis(block.input[‘company_name’]) # Add to the results list for this turn tool_results.append({ “type”: “tool_result”, “tool_use_id”: block.id, “content”: result }) if has_tool_use: messages.append({“role”: “user”, “content”: tool_results}) else: running = False print(“n Conversation Complete.”) During execution, the model decides when and which tool to call, receives the corresponding tool results, and then updates its reasoning and final response based on that data. This showcases M2.1’s ability to interleave reasoning, tool usage, and response generation—adapting its output dynamically as new information becomes available. Comparison with OpenAI’s GPT-5.2 Finally, we compare MiniMax M2.1 with GPT-5.2 using a compact multilingual instruction-following prompt. The task requires the model to identify coffee-related terms from a Spanish passage, translate only those terms into English, remove duplicates, and return the result in a strictly formatted numbered list. To run this code block, you’ll need an OpenAI API key, which can be generated from the OpenAI developer dashboard. Copy CodeCopiedUse a different Browserimport os from getpass import getpass os.environ[‘OPENAI_API_KEY’] = getpass (‘Enter OpenAI API Key: ‘) Copy CodeCopiedUse a different Browserinput_text = “”” ¡Preparar café Cold Brew es un proceso sencillo y refrescante! Todo lo que necesitas son granos de café molido grueso y agua fría. Comienza añadiendo el café molido a un recipiente o jarra grande. Luego, vierte agua fría, asegurándote de que todos los granos de café estén completamente sumergidos. Remueve la mezcla suavemente para garantizar una saturación uniforme. Cubre el recipiente y déjalo en remojo en el refrigerador durante al menos 12 a 24 horas, dependiendo de la fuerza deseada. “”” prompt = f””” The following text is written in Spanish. Task: 1. Identify all words in the text that are related to coffee or coffee preparation. 2. Translate ONLY those words into English. 3. Remove duplicates (each word should appear only once). 4. Present the result as a numbered list. Rules: – Do NOT include explanations. – Do NOT include non-coffee-related words. – Do NOT include Spanish words in the final output. Text: “”” from openai import OpenAI client = OpenAI() response = client.responses.create( model=”gpt-5.2″, input=prompt ) print(response.output_text) Copy CodeCopiedUse a different Browserimport anthropic client = anthropic.Anthropic() message = client.messages.create( model=”MiniMax-M2.1″, max_tokens=10000, system=”You are a helpful assistant.”, messages=[ { “role”: “user”, “content”: [ { “type”: “text”, “text”: prompt } ] } ] ) for block in message.content: if block.type == “thinking”: print(f”Thinking:n{block.thinking}n”) elif block.type == “text”: print(f”Text:n{block.text}n”) When comparing the outputs, MiniMax M2.1 produces a noticeably broader and more granular set of coffee-related terms than GPT-5.2. M2.1 identifies not only core nouns like coffee, beans, and water, but also preparation actions (pour, stir, cover), process-related states (submerged, soak), and contextual attributes (cold, coarse, strength, hours).  This indicates a deeper semantic pass over the text, where the model reasons through the entire preparation workflow rather than extracting only the most obvious keywords. This difference is also reflected in the reasoning process. M2.1 explicitly analyzes context, resolves edge cases (such as borrowed English terms like Cold Brew), considers duplicates, and deliberates on whether certain adjectives or verbs qualify as coffee-related before finalizing the list. GPT-5.2, by contrast, delivers a shorter and more conservative output focused on high-confidence terms, with less visible reasoning depth.  Together, this highlights M2.1’s stronger instruction adherence and semantic coverage, especially for tasks that require careful filtering, translation, and strict output control. The post MiniMax Releases M2.1: An Enhanced M2 Version with Features like Multi-Coding Language Support, API Integration, and Improved Tools for Structured Coding appeared first on Ma […]

Is Mistral OCR 3 the Best OCR Model?Obtaining the text in a messy PDF file is more problematic than it is helpful. The problem does not lie in the […]

A Coding Guide to Build an Autonomous Multi-Agent Logistics System with Route Planning, Dynamic Auctions, and Real-Time Visualization Using Graph-Based SimulationIn this tutorial, we build an advanced, fully autonomous logistics simulation in which multiple smart delivery trucks operate within a dynamic city-wide road network. We design the system so that each truck behaves as an agent capable of bidding on delivery orders, planning optimal routes, managing battery levels, seeking charging stations, and maximizing profit through self-interested decision-making. Through each code snippet, we explore how agentic behaviors emerge from simple rules, how competition shapes order allocation, and how a graph-based world enables realistic movement, routing, and resource constraints. Check out the FULL CODES here. Copy CodeCopiedUse a different Browserimport networkx as nx import matplotlib.pyplot as plt import random import time from IPython.display import clear_output from dataclasses import dataclass, field from typing import List, Dict, Optional NUM_NODES = 30 CONNECTION_RADIUS = 0.25 NUM_AGENTS = 5 STARTING_BALANCE = 1000 FUEL_PRICE = 2.0 PAYOUT_MULTIPLIER = 5.0 BATTERY_CAPACITY = 100 CRITICAL_BATTERY = 25 @dataclass class Order: id: str target_node: int weight_kg: int payout: float status: str = “pending” class AgenticTruck: def __init__(self, agent_id, start_node, graph, capacity=100): self.id = agent_id self.current_node = start_node self.graph = graph self.battery = BATTERY_CAPACITY self.balance = STARTING_BALANCE self.capacity = capacity self.state = “IDLE” self.path: List[int] = [] self.current_order: Optional[Order] = None self.target_node: int = start_node We set up all the core building blocks of the simulation, including imports, global parameters, and the basic data structures. We also define the AgenticTruck class and initialize key attributes, including position, battery, balance, and operating state. We lay the foundation for all agent behaviors to evolve. Check out the FULL CODES here. Copy CodeCopiedUse a different Browser def get_path_cost(self, start, end): try: length = nx.shortest_path_length(self.graph, start, end, weight=’weight’) path = nx.shortest_path(self.graph, start, end, weight=’weight’) return length, path except nx.NetworkXNoPath: return float(‘inf’), [] def find_nearest_charger(self): chargers = [n for n, attr in self.graph.nodes(data=True) if attr.get(‘type’) == ‘charger’] best_charger = None min_dist = float(‘inf’) best_path = [] for charger in chargers: dist, path = self.get_path_cost(self.current_node, charger) if dist self.capacity: return float(‘inf’) if self.state != “IDLE” or self.battery < CRITICAL_BATTERY: return float('inf') dist_to_target, _ = self.get_path_cost(self.current_node, order.target_node) fuel_cost = dist_to_target * FUEL_PRICE expected_profit = order.payout – fuel_cost if expected_profit < 10: return float('inf') return dist_to_target def assign_order(self, order): self.current_order = order self.state = "MOVING" self.target_node = order.target_node _, self.path = self.get_path_cost(self.current_node, self.target_node) if self.path: self.path.pop(0) def go_charge(self): charger_node, path = self.find_nearest_charger() if charger_node is not None: self.state = "TO_CHARGER" self.target_node = charger_node self.path = path if self.path: self.path.pop(0) We implement advanced decision-making logic for the trucks. We calculate shortest paths, identify nearby charging stations, and evaluate whether an order is profitable and feasible. We also prepare the truck to accept assignments or proactively seek charging when needed. Check out the FULL CODES here. Copy CodeCopiedUse a different Browser def step(self): if self.state == "IDLE" and self.battery = 100: self.battery = 100 self.state = “IDLE” return if self.path: next_node = self.path[0] edge_data = self.graph.get_edge_data(self.current_node, next_node) distance = edge_data[‘weight’] self.current_node = next_node self.path.pop(0) self.battery -= (distance * 2) self.balance -= (distance * FUEL_PRICE) if not self.path: if self.state == “MOVING”: self.balance += self.current_order.payout self.current_order.status = “completed” self.current_order = None self.state = “IDLE” elif self.state == “TO_CHARGER”: self.state = “CHARGING” We manage the step-by-step actions of each truck as the simulation runs. We handle battery recharging, financial impacts of movement, fuel consumption, and order completion. We ensure that agents transition smoothly between states, such as moving, charging, and idling. Check out the FULL CODES here. Copy CodeCopiedUse a different Browserclass Simulation: def __init__(self): self.setup_graph() self.setup_agents() self.orders = [] self.order_count = 0 def setup_graph(self): self.G = nx.random_geometric_graph(NUM_NODES, CONNECTION_RADIUS) for (u, v) in self.G.edges(): self.G.edges[u, v][‘weight’] = random.uniform(1.0, 3.0) for i in self.G.nodes(): r = random.random() if r < 0.15: self.G.nodes[i]['type'] = 'charger' self.G.nodes[i]['color'] = 'red' else: self.G.nodes[i]['type'] = 'house' self.G.nodes[i]['color'] = '#A0CBE2' def setup_agents(self): self.agents = [] for i in range(NUM_AGENTS): start_node = random.randint(0, NUM_NODES-1) cap = random.choice([50, 100, 200]) self.agents.append(AgenticTruck(i, start_node, self.G, capacity=cap)) def generate_order(self): target = random.randint(0, NUM_NODES-1) weight = random.randint(10, 120) payout = random.randint(50, 200) order = Order(id=f"ORD-{self.order_count}", target_node=target, weight_kg=weight, payout=payout) self.orders.append(order) self.order_count += 1 return order def run_market(self): for order in self.orders: if order.status == "pending": bids = {agent: agent.calculate_bid(order) for agent in self.agents} valid_bids = {k: v for k, v in bids.items() if v != float('inf')} if valid_bids: winner = min(valid_bids, key=valid_bids.get) winner.assign_order(order) order.status = "assigned" We create the simulated world and orchestrate agent interactions. We generate the graph-based city, spawn trucks with varying capacities, and produce new delivery orders. We also implement a simple market where agents bid for tasks based on profitability and distance. Check out the FULL CODES here. Copy CodeCopiedUse a different Browser def step(self): if random.random() < 0.3: self.generate_order() self.run_market() for agent in self.agents: agent.step() def visualize(self, step_num): clear_output(wait=True) plt.figure(figsize=(10, 8)) pos = nx.get_node_attributes(self.G, 'pos') node_colors = [self.G.nodes[n]['color'] for n in self.G.nodes()] nx.draw(self.G, pos, node_color=node_colors, with_labels=True, node_size=300, edge_color='gray', alpha=0.6) for agent in self.agents: x, y = pos[agent.current_node] jitter_x = x + random.uniform(-0.02, 0.02) jitter_y = y + random.uniform(-0.02, 0.02) color = 'green' if agent.state == "IDLE" else ('orange' if agent.state == "MOVING" else 'red') plt.plot(jitter_x, jitter_y, marker='s', markersize=12, color=color, markeredgecolor='black') plt.text(jitter_x, jitter_y+0.03, f"A{agent.id}n${int(agent.balance)}n{int(agent.battery)}%", fontsize=8, ha='center', fontweight='bold', bbox=dict(facecolor='white', alpha=0.7, pad=1)) for order in self.orders: if order.status in ["assigned", "pending"]: ox, oy = pos[order.target_node] plt.plot(ox, oy, marker='*', markersize=15, color='gold', markeredgecolor='black') plt.title(f"Graph-Based Logistics Swarm | Step: {step_num}nRed Nodes = Chargers | Gold Stars = Orders", fontsize=14) plt.show() print("Initializing Advanced Simulation…") sim = Simulation() for t in range(60): sim.step() sim.visualize(t) time.sleep(0.5) print("Simulation Finished.") We step through the full simulation loop and visualize the logistics swarm in real time. We update agent states, draw the network, display active orders, and animate each truck’s movement. By running this loop, we observe the emergent coordination and competition that define our multi-agent logistics ecosystem. In conclusion, we saw how the individual components, graph generation, autonomous routing, battery management, auctions, and visualization, come together to form a living, evolving system of agentic trucks. We watch as agents negotiate workloads, compete for profitable opportunities, and respond to environmental pressures such as distance, fuel costs, and charging needs. By running the simulation, we observe emergent dynamics that mirror real-world fleet behavior, providing a powerful sandbox for experimenting with logistics intelligence. Check out the FULL CODES here. Also, feel free to follow us on Twitter and don’t forget to join our 100k+ ML SubReddit and Subscribe to our Newsletter. Wait! are you on telegram? now you can join us on telegram as well. The post A Coding Guide to Build an Autonomous Multi-Agent Logistics System with Route Planning, Dynamic Auctions, and Real-Time Visualization Using Graph-Based Simulation appear […]

AI Wrapped: The 14 AI terms you couldn’t avoid in 2025If the past 12 months have taught us anything, it’s that the AI hype train is showing no s […]

Build Your Own Open-Source Logo Detector: A Practical Guide to ACR, Embeddings & Vector SearchIf you’ve ever watched a game and wondered, “How do bra […]

This AI Paper from Stanford and Harvard Explains Why Most ‘Agentic AI’ Systems Feel Impressive in Demos and then Completely Fall Apart in Real Use Ag […]