An examination of how military escalation in the Middle East triggers US domestic spending pressures, global supply chain breakdowns, and widespread economic strain.

When regional military escalations cross into major global supply choke points, the financial fallout spreads far beyond the immediate combat zone. The conflict involving the United States, Israel, and Iran has triggered widespread disruptions that reach deep into Western economies, developing nations, and global financial markets.

Rather than assessing blame, looking closely at the broader impacts shows how interconnected modern trade is, affecting everything from American government spending to global job markets and everyday consumer prices.

The Direct Costs and Economic Pressures on the United States

While the United States operates far from the physical destruction in the Middle East, the financial and domestic toll of the conflict has been substantial.

• Government Spending and Military Costs: Sustaining long-term military operations, replacing expended munitions, and repairing tactical equipment place a heavy burden on public funds. Congressional budget assessments indicate that the Department of Defense spends tens of billions of dollars directly on the conflict, driving requests for massive supplemental funding packages. This heavy spending forces difficult choices regarding national budgets and public resources.
• Inflation and Consumer Pressures: Because energy supplies are constrained globally, fuel and utility costs inside the United States face upward pressure. This energy shock feeds into general inflation, pushing up the price of goods, transportation, and services. In turn, higher inflation complicates monetary policy, keeping borrowing costs and interest rates elevated longer than anticipated.
• Political and Market Uncertainty: Financial markets experience heightened volatility whenever regional tensions flare up. Investors react nervously to shifting energy supplies and defense expenditures, creating an environment of continuous economic caution for businesses planning investments or hiring new workers.

Global Supply Chain Disruptions and Industrial Strain

The closure of vital shipping lanes, particularly the Strait of Hormuz, created one of the largest energy supply disruptions in modern history. Because a significant percentage of the world’s petroleum and liquefied natural gas passes through this narrow maritime corridor, the blockade halted normal export flows from major producing nations.

• Industrial Input Shortages: Beyond oil and gas, the region supplies essential global commodities, including major shares of aluminum, fertilizers, and petrochemical products used in manufacturing and medical supplies. The sudden scarcity of these materials forced factories worldwide to slow production or seek expensive alternative sources.
• Aviation and Logistics Crises: Rerouting commercial aircraft to avoid closed airspace increased fuel consumption and flight times. Similarly, maritime shipping companies had to send cargo vessels on much longer journeys around alternative capes, leading to severe port congestion, soaring container shipping rates, and delayed deliveries across global trade networks.
• Stagflation Risks in Europe and Beyond: Import-dependent regions like Europe faced immediate energy shortages and soaring utility bills. The combination of stalled economic growth and high inflation raised concerns about potential stagflation, putting intense pressure on businesses and lowering consumer purchasing power.

The Employment and Currency Crisis in Developing Economies

For developing nations and emerging markets, the crisis translated into severe currency depreciation and employment challenges. As import bills for oil and gas doubled or tripled, foreign exchange reserves drained rapidly. Central banks had to intervene heavily to defend their local currencies against a strengthening US dollar, forcing them to raise interest rates.

These high interest rates choked domestic credit, making it difficult for small and medium enterprises to expand. Faced with inflated operating expenses, raw material shortages, and rising logistics costs, businesses across various sectors cut back on recruitment, leading to hiring freezes, localized job crises, and rising unemployment anxiety for the workforce.

How the Conflict Unfolded and the Local Destruction

The latest escalation began with joint military actions by the United States and Israel targeting key facilities inside Iran, which met with immediate counterstrikes. As hostilities grew, vital infrastructure, military bases, oil depots, and regional transport routes suffered heavy damage.

The physical toll on the direct participants involves extensive damage to defense installations, industrial hubs, and energy sites. Beyond the structural destruction, the psychological and human toll on local populations has been severe, creating widespread displacement, anxiety, and a deep sense of insecurity across the entire region.

The Global Crisis: Oil, Gas, and Markets

The most disruptive element of this war is not just what happens on land, but what happens to the global trade routes. Critical shipping lanes, particularly the Strait of Hormuz, faced severe blockages and security threats. Because a massive portion of the world’s petroleum and liquefied natural gas travels through this narrow passage, shipping ground to a halt.

This restriction triggered an unprecedented energy supply shock. Global oil and gas prices spiked dramatically within days, pushing up production and transportation costs everywhere. Stock markets around the world reacted with sharp declines, currencies experienced intense volatility, and central banks struggled to contain mounting inflation. Industries that rely heavily on steady fuel supplies found themselves facing sudden shortages and inflated operational costs.

The Heavy Impact on India

Countries heavily dependent on imported energy imports felt the crisis immediately. India, as one of the world’s largest importers of crude oil and liquefied petroleum gas, faced severe economic pressure.

• Energy and Fuel Shortages: The sudden surge in crude oil prices heavily increased the national import bill, straining the country’s current account balance. At the same time, shortages in imported gas forced authorities to restrict commercial supplies and prioritize household needs, leaving businesses and industries scrambling.
• Currency and Financial Pressure: As oil prices climbed, the Indian Rupee depreciated significantly against the US dollar, prompting central bank interventions to stabilize the foreign exchange reserves.
• Market and Job Crises: Higher energy costs triggered imported inflation, driving up the prices of everyday goods, transportation, and raw materials. This sudden economic squeeze impacted profit margins for small and large businesses alike, slowing down hiring processes, creating job market anxieties, and threatening steady economic growth.

Conclusion

The conflict between the United States, Israel, and Iran demonstrates that modern wars are no longer isolated events. Through intertwined supply chains, energy dependencies, and financial markets, a regional confrontation instantly transforms into a global crisis. The resulting inflation, fiscal strain, and operational difficulties felt by nations thousands of miles away highlight the fragile nature of global economic stability.

May peace find its way back to every corner of the world, and may all people live safely, prosperously, and free from the shadows of conflict.

The company shared six real cases of AI behaving in ways nobody expected, from hiding mistakes to secretly uploading files online

On September 16, 2026, OpenAI did something companies rarely do. It admitted that its AI models had, on several occasions, behaved in ways nobody asked them to. The company released a new system for tracking this kind of behavior, along with six real examples from the past six months.

None of these cases mean the AI is alive or trying to escape human control. But they do show something worth paying attention to. As AI gets smarter and starts doing more tasks on its own, keeping it under control is turning into a genuinely hard problem.

Not medium member! Access at here

What does “misalignment” actually mean?

It sounds technical, but it’s a simple idea. An AI model is supposed to follow instructions and stay within its limits. Misalignment is when it doesn’t, even if it wasn’t trying to cause harm.

Sometimes the AI just takes a shortcut. Sometimes it misunderstands the task. Sometimes it uses a tool in a way nobody expected. OpenAI’s new framework is meant to catch these moments and study them properly instead of quietly brushing them aside.

OpenAI Admits Its AI Models Did Some Strange Things, Here’s What Happened

Happy Coding ❤

The $12.93 billion acquisition that could reshape open-source AI, LangGraph agents, Ollama workflows, and how developers build AI applications in 2026.

I thought NVIDIA was in the GPU business.

Like most developers, I associated NVIDIA with graphics cards, CUDA, and massive AI data centers. If someone asked me which company was shaping the future of AI software, I’d probably have answered OpenAI, Anthropic, or maybe Google DeepMind.

Then September 2026 happened.

NVIDIA announced one of the largest acquisitions in its history: Hugging Face — the platform used by millions of developers to discover, download, fine-tune, and deploy open AI models. The deal is worth $12.93 billion, and NVIDIA says Hugging Face will remain an open platform supporting models from across the AI ecosystem.

Continue to read at here…

NVIDIA Just Bought Hugging Face — And Every AI Developer Needs to Pay Attention

NVIDIA Just Bought Hugging Face — And Every AI Developer Needs to Pay Attention was originally published in The Code Frontier on Medium, where people are continuing the conversation by highlighting and responding to this story.

Hi techies, help this user to run LLM locally.

Running enterprise backends, web APIs, and full-stack .NET apps for years gives you a pretty comfortable groove. But lately, I’ve seen more and more developers dipping their toes into local model execution, moving away from relying solely on cloud APIs to experiment with zero-latency, private, and offline setups.

A fellow senior developer recently posted asking the community how to navigate this exact transition. I’m not in a position to give them a personalized breakdown of local hardware or custom model configs right now, so I wanted to re-share their main questions here with my network.

If you’ve already built a local setup on your dev machine, your perspective would be huge here.

Here is the user that need help in this section:

Help Me Run AI Locally

Help Me Run AI Locally

The GPU giant’s new 550B hybrid MoE model, Nemotron-3 Ultra, delivers 1M-token context window agentic workflows for free. Here’s why the developer ecosystem is buzzing — and how to test it today.

For months, closed-source subscription agents like Claude Code and OpenAI Codex have dominated the developer landscape. Engineers rewrote their workflows around proprietary tool-calling loops, paying per token and surrendering complete control of their codebases to third-party cloud platforms.

Then NVIDIA flipped the script.

NVIDIA officially unveiled Nemotron-3 Ultra — a 550B total parameter (55B active) sparse Mixture-of-Experts (MoE) reasoning engine built to disrupt how developers construct, execute, and scale AI-driven software engineering.

What Makes Nemotron-3 Ultra a Game Changer?

Nemotron-3 Ultra isn’t just another open-weights model; it solves the core bottlenecks that made proprietary coding agents necessary in the first place:

• 1-Million-Token Context Window: Load full repositories, extensive test suites, and entire legacy architectures directly into memory without relying on fragmented RAG or context pruning.
• Hybrid Transformer-Mamba Architecture: By interleaving Mamba-2 state-space blocks with sparse MoE layers, it drastically lowers time-to-first-token (TTFT) and maintains ultra-high inference throughput — even during heavy multi-turn agent loops.
• Native Tool-Calling & Extended Reasoning: Designed specifically for multi-file refactoring, terminal execution, and thousands of continuous tool calls without losing execution context.
• Zero SaaS Lock-In: Deploy open weights via local clusters, dedicated cloud instances, or access them free through open API endpoints.

Want to see the full architectural breakdown, benchmarks, and production-ready Python code?

Whether you are looking to replace paid coding subscription services or build autonomous background software agents, the full implementation guide covers everything from model routing parameters to step-by-step code setups.

👉 Read the Full Deep-Dive Article & Code Implementation on Medium

OMG! NVIDIA Just Killed Claude Code and Codex

Why every developer swears the Model Context Protocol just died-and why the download numbers say otherwise

Scroll through any AI developer forum right now and you’ll see the same verdict, repeated with the confidence of a eulogy: MCP is dead.

Too complicated. Too stateful. Too easy to break. Just give developers a REST API and let them go home.

If you’re not a member, I’ve got you covered! ❤

It started building in late February 2026, when infrastructure engineer Eric Holmes published a post with a title that landed like a mic drop: “MCP is dead. Long live the CLI.” His argument wasn’t that tool-calling was pointless, it was that a plain command-line interface is often a more reliable, more composable way for both humans and agents to talk to a system than a purpose-built protocol layer.

Read full article here..

MCP Is Dead Why? Long Live MCP

What’s your experience? has MCP earned its production keep for you, or are you still reaching for a plain API when you can get away with it? Drop it in the responses.

Follow for more impressive articles and update. Here’s some other users best articles I found.

• OMG! NVIDIA Just Killed Claude Code and Codex
• SQL Keywords Every Developer Should Know Well (Beginner to Advanced)
• Master SQL Window Functions With Real World Examples

MCP Is Dead. Long Live MCP. was originally published in The Code Frontier on Medium, where people are continuing the conversation by highlighting and responding to this story.

Kimi K3 isn’t just cheaper — it’s rewriting the rules of frontier AI.

Beyond OpenAI: Why the Smartest Developers Are Betting on Kimi K3

It’s not about hype. It’s about math, open weights, and a model that beats GPT-5.6 Sol on the benchmarks that pay your rent.

If you’re not a member, I’ve got you covered! ❤

For the last three years, the AI conversation has sounded like a broken record: OpenAI leads, Anthropic chases, everyone else watches. If you wanted frontier intelligence, you paid the frontier tax — $30 per million output tokens, closed APIs, and the creeping fear that your AI stack was built on someone else’s land.

Then, on July 16, 2026, Moonshot AI dropped Kimi K3. And the record skipped.

At first glance, the specs read like science fiction: 2.8 trillion parameters, a 1-million-token context window, native vision, and — here’s the kicker — full open weights. But specs don’t pay bills. Performance does. And that’s where this story gets interesting.

The Benchmark Reality Check

Let’s get one thing straight: Kimi K3 doesn’t beat GPT-5.6 Sol on every test. On the Artificial Analysis Intelligence Index, GPT-5.6 Sol still edges ahead with a score of 58.9 to K3’s 57.1. Claude Fable 5 sits comfortably at 59.9.

But here’s what the aggregate scores don’t tell you: AI isn’t one leaderboard. It’s fifty. And on the leaderboards that actually matter to people building real products, K3 isn’t just competitive — it’s dominant.

Take BrowseComp, the brutal benchmark for long-horizon web research. K3 scored 91.2, beating GPT-5.6 Sol (90.4) and Claude Fable 5 (88.0).

Or Program Bench, where K3 hit 77.8, narrowly edging out GPT-5.6 Sol’s 77.6.

And then there’s the Frontend Code Arena — a blind, human-preference test where developers vote on which model writes better code without knowing which is which. K3 launched straight to #1, scoring 1,679 and beating Claude Fable 5 in 76% of matchups.

That’s not “catching up.” That’s taking the crown in the one arena where developers actually decide what works.

The $0.94 Secret

Here’s the number that should keep OpenAI’s executives awake at night: $0.94.

That’s the cost per completed task for Kimi K3 on Artificial Analysis’s private benchmark. GPT-5.6 Sol? $1.04. Claude Opus 4.8? $1.80.

But the real shock is in the token pricing. K3 charges $3 per million input tokens and $15 per million output tokens. GPT-5.6 Sol charges $5 and $30 respectively.

If you’re running an AI-native startup, that’s not a discount. That’s a business model. At scale, the difference between K3 and Sol isn’t pocket change — it’s the difference between burning runway and hitting profitability.

Open Weights = Open Future

The most radical thing about K3 isn’t its benchmark scores or its price. It’s the open weights.

On July 27, 2026, Moonshot released the full 2.8-trillion-parameter checkpoint under the Kimi K3 License.

What does that actually mean?

It means you can self-host the model in your own data center. It means you can fine-tune it on proprietary data without sending anything to a third-party API. It means you can run it air-gapped for compliance-sensitive workflows. It means no rate limits, no sudden pricing changes, no “service unavailable” errors during your product demo.

For enterprises in healthcare, finance, and defense, this isn’t a nice-to-have. It’s a requirement. And for the first time, that requirement doesn’t force you to sacrifice frontier performance.

Yes, self-hosting a 2.8T-parameter model demands serious hardware — Moonshot recommends 64+ accelerators. But the option exists. With OpenAI, it doesn’t. You’re either in their ecosystem or you’re out.

The Agentic Edge

If there’s one domain where K3 truly shines, it’s agentic AI — models that don’t just chat, but do.

On Automation Bench, a test of real-world task automation across diverse environments, K3 scored 30.8, beating GPT-5.6 Sol (29.7) and Claude Fable 5 (29.1).

On SWE Marathon, a grueling long-session coding benchmark, K3 hit 42.0 versus Claude Opus 4.8’s 40.0.

And on AA-Briefcase, Artificial Analysis’s private benchmark for long-horizon knowledge work, K3 climbed to second place with a score of 1,527, beating GPT-5.6 Sol Max (1,495) and trailing only Fable 5 Max.

This isn’t a model that writes poetry about Python. This is a model that navigates massive codebases, operates terminals, builds spreadsheets, and orchestrates multi-step workflows — the kind of work that actually moves the needle in enterprise AI.

The Catch (Because There’s Always One)

I’ll be honest with you: K3 isn’t perfect. And if you’re evaluating it for production, you need to know the downsides.

First, hallucination. Artificial Analysis measured a “materially raised hallucination rate” compared to its closed-source peers. K3 answers more questions correctly than its predecessor, but it also invents more wrong answers with unsettling confidence. For compliance-sensitive workflows, you’ll need guardrails.

Second, token consumption. K3’s “thinking mode” is always on, and it’s thirsty. One test prompt — “generate an SVG of a pelican riding a bicycle” — consumed 16,658 output tokens for 95 input tokens, costing $0.25.

Third, user experience. Moonshot itself admits that K3 “exhibits a noticeable gap in user experience compared with Claude Fable 5 and GPT 5.6 Sol.” It’s a raw, powerful tool — not a polished consumer product.

What This Means for the Future

Kimi K3 isn’t just another model. It’s a signal.

A signal that the gap between open-weight and closed-source frontier models has collapsed from “more than a year” to roughly four months.

A signal that Chinese AI labs aren’t “fast followers” distilling American breakthroughs — they’re building genuine frontier systems from the ground up.

A signal that cost and openness are becoming competitive advantages, not just ethical talking points.

OpenRouter’s data tells the story: open-source model share on the marketplace rose from 34% in January 2026 to 65% by June.

The market is voting with its API keys. And it’s voting for open.

The Bottom Line

If you’re a developer, a founder, or an engineering leader making AI decisions in 2026, you need to ask yourself a hard question: Are you paying for performance, or are you paying for a logo?

Kimi K3 doesn’t beat OpenAI everywhere. But it beats them where it counts — on coding, on agentic tasks, on cost, and on freedom. It gives you frontier intelligence without frontier lock-in.

OpenAI built an empire on being the only game in town. Kimi K3 just proved there’s another town. And the rent is 40% cheaper.

What do you think — is 2026 the year open weights go mainstream? Drop your take in the comments, and follow for more frontier AI breakdowns.

The $0.94 AI That Just Dethroned OpenAI on the Only Leaderboard That Matters was originally published in The Code Frontier on Medium, where people are continuing the conversation by highlighting and responding to this story.

Exploring Kimi K3’s 1M-token context, long-horizon coding, reasoning, vision, tool calling, and OpenAI-compatible API

Introducing Kimi K3

Kimi K3 is Kimi’s most capable flagship model to date, with 2.8 trillion parameters. It is built on Kimi Delta Attention (KDA), a hybrid linear attention mechanism, and Attention Residuals, with native visual understanding and a 1M-token context window. It is the world’s first open-source model in the 3-trillion-parameter class, designed for frontier intelligence scenarios including long-horizon coding, knowledge work, and reasoning.

If you’re not a member, I’ve got you covered! ❤

For complete benchmarks and case studies, see the technical blog. Kimi is currently working closely with inference partners and open-source maintainers to align technical details and ensure the model launches reliably across the ecosystem. The full model weights will be released by July 27, 2026. More details on architecture, training, and evaluation will be published with the Kimi K3 technical report.

A 3-trillion-scale open-source model

Kimi K3 is the first open-source model to reach 2.8 trillion parameters. This is the latest step in Kimi’s continued push of model-scale boundaries: in 9 of the past 12 months (2025/07–2026/07), Kimi models have maintained the frontier in open-source model scale.

Kimi K3 is built on Kimi Delta Attention (KDA) and Attention Residuals (AttnRes). Both architectural updates are designed to help information flow more smoothly through longer sequences and deeper models. We also further increased the sparsity of the Mixture of Experts (MoE): with the Stable LatentMoE framework, the model efficiently activates 16 out of 896 experts. Together with improvements in training methodology and data recipes, these structural advances give Kimi K3 roughly 2.5x the overall scaling efficiency of K2, converting compute into capability more effectively.

Coding

Kimi K3 has strong long-horizon coding capabilities. With minimal human supervision, it can sustain long-running engineering tasks, understand and work with large codebases, and coordinate terminal tools.Kimi K3 also excels at tasks that combine software engineering and visual reasoning. It can use screenshots and visual feedback to improve workflows in game development, frontend engineering, CAD, and related scenarios.​

Knowledge work

Kimi K3 advances end-to-end knowledge work. Beyond public benchmarks, Kimi K3 (max) also shows consistent gains in our internal evaluations. These evaluations reflect recurring task patterns and challenges from real user-agent collaboration workflows. Kimi K3 demonstrates consistent advantages across production-oriented workflows, indicating broad improvements in agentic knowledge-work capabilities.​

Access requirements

Kimi K3 is a flagship model: it is unlocked after a successful top-up (minimum $1). Your cumulative top-up amount also determines your account tier and rate limits (concurrency, RPM, TPM, TPD) .​

Get started

• Playground
• Get an API Key

The examples require Python 3.9+ and the OpenAI SDK. Install the SDK and initialize the client once; later Python examples reuse client.

python3 -m pip install --upgrade 'openai>=1.0'

import os

from openai import OpenAI

client = OpenAI(
    api_key=os.environ["MOONSHOT_API_KEY"],
    base_url="https://api.moonshot.ai/v1",
)

Basic call

completion = client.chat.completions.create(
    model="kimi-k3",
    messages=[{"role": "user", "content": "Introduce Kimi K3 in one sentence."}],
)

print(completion.choices[0].message.content)

Reasoning effort

K3 always has thinking mode enabled and supports configuring its reasoning effort with the top-level reasoning_effort request field.

Reasoning effort supports low, high, and max (default max).

completion = client.chat.completions.create(
    model="kimi-k3",
    reasoning_effort="max",
    messages=[{"role": "user", "content": "Prove that the square root of 2 is irrational."}],
)

print(completion.choices[0].message.content)

For multi-turn conversations and tool calls, add the complete assistant message returned by the API to the next request. Do not keep only content.

Streaming

Streaming responses provide separate reasoning_content and final-answer content deltas.

stream = client.chat.completions.create(
    model="kimi-k3",
    messages=[{"role": "user", "content": "Explain why the sky is blue."}],
    stream=True,
)

for chunk in stream:
    delta = chunk.choices[0].delta
    reasoning = getattr(delta, "reasoning_content", None)
    if reasoning:
        print(reasoning, end="", flush=True)
    if delta.content:
        print(delta.content, end="", flush=True)

Vision input

For vision messages, content must be an array of objects, not a serialized string.

- For Local Image:

import base64
from pathlib import Path

image_data: str = base64.b64encode(Path("image.png").read_bytes()).decode()
completion = client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image_url",
                    "image_url": {"url": f"data:image/png;base64,{image_data}"},
                },
                {"type": "text", "text": "Describe this image."},
            ],
        }
    ],
)

print(completion.choices[0].message.content)

- For Video Files

from pathlib import Path

video = client.files.create(file=Path("video.mp4"), purpose="video")
try:
    completion = client.chat.completions.create(
        model="kimi-k3",
        messages=[
            {
                "role": "user",
                "content": [
                    {
                        "type": "video_url",
                        "video_url": {"url": f"ms://{video.id}"},
                    },
                    {"type": "text", "text": "Summarize this video."},
                ],
            }
        ],
    )
    print(completion.choices[0].message.content)
finally:
    client.files.delete(video.id)

Structured output

Use json_schema with strict: true to constrain the final message.content. Parse only that field, not reasoning_content.

- Name and Age schema:

import json

completion = client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {"role": "user", "content": "Lin is 28 years old. Extract the name and age."}
    ],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "person",
            "strict": True,
            "schema": {
                "type": "object",
                "properties": {
                    "name": {"type": "string"},
                    "age": {"type": "integer"},
                },
                "required": ["name", "age"],
                "additionalProperties": False,
            },
        },
    },
)

person: dict[str, object] = json.loads(
    completion.choices[0].message.content or "{}"
)
print(person)

Partial Mode

Add an assistant message with partial=True at the end of messages to continue from a text prefix. Prepend that prefix when displaying the final result.

prefix: str = "Conclusion: "
completion = client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {"role": "user", "content": "In one sentence, explain why API compatibility matters."},
        {"role": "assistant", "content": prefix, "partial": True},
    ],
)

print(prefix + (completion.choices[0].message.content or ""))

Custom tools and tool_choice

Use tool_choice="required" on the first turn to require at least one tool call. After executing every call, return the complete assistant message and append one tool result with the matching tool_call_id for each call.

- Minimal weather agent loop:

import json
from typing import Any

tools: list[dict[str, Any]] = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get the weather for a city",
            "parameters": {
                "type": "object",
                "properties": {"city": {"type": "string"}},
                "required": ["city"],
            },
        },
    }
]
messages: list[Any] = [
    {"role": "user", "content": "What is the weather in San Francisco today?"}
]

first = client.chat.completions.create(
    model="kimi-k3",
    messages=messages,
    tools=tools,
    tool_choice="required",
)
assistant_message = first.choices[0].message
messages.append(assistant_message)

for tool_call in assistant_message.tool_calls or []:
    arguments: dict[str, str] = json.loads(tool_call.function.arguments)
    result: str = json.dumps(
        {"city": arguments["city"], "weather": "sunny", "temperature_c": 24}
    )
    messages.append(
        {"role": "tool", "tool_call_id": tool_call.id, "content": result}
    )

final = client.chat.completions.create(
    model="kimi-k3",
    messages=messages,
    tools=tools,
)
print(final.choices[0].message.content)

Dynamic tool loading

Place a complete tool definition in a system message without content. The tool becomes available from that message onward.

- Load a calculator dynamically:

from typing import Any

dynamic_messages: list[dict[str, Any]] = [
    {"role": "user", "content": "Calculate 23 times 47."},
    {
        "role": "system",
        "tools": [
            {
                "type": "function",
                "function": {
                    "name": "calculate",
                    "description": "Evaluate an arithmetic expression",
                    "parameters": {
                        "type": "object",
                        "properties": {
                            "expression": {
                                "type": "string",
                                "description": "The arithmetic expression to evaluate",
                            }
                        },
                        "required": ["expression"],
                    },
                },
            }
        ],
    },
]
completion = client.chat.completions.create(
    model="kimi-k3",
    messages=dynamic_messages,
)

print(completion.choices[0].message.tool_calls)

• Include the complete name, description, and parameters definition.
• The declaration takes effect at its position in messages.
• Keep this message in later request history; the server does not retain it.

1M context and automatic caching

A new request can hit the prefix cache only when the previous request’s prompt tokens exceed 256. If the previous request’s prompt tokens are below 256, the request is not cached and is discarded.

Context caching is automatic for regular model requests; no cache ID, TTL, or extra parameter is required. Keep the long prefix unchanged so later requests can automatically attempt a cache hit.

from pathlib import Path

knowledge: str = Path("knowledge-base.md").read_text(encoding="utf-8")

for question in ["Summarize the key conclusions.", "List three implementation risks."]:
    completion = client.chat.completions.create(
        model="kimi-k3",
        messages=[
            {"role": "system", "content": knowledge},
            {"role": "user", "content": question},
        ],
    )
    print(completion.choices[0].message.content)

Official tools

Official tools are integrated through Formula:

1. Fetch tool definitions from the Formula /tools endpoint.
2. Add those definitions to the Chat Completions tools field.
3. When the model returns tool_calls, submit each function name and arguments to the Formula /fibers endpoint.
4. Add the complete assistant message and Fiber output as the corresponding tool message.
5. Call Chat Completions again until the model returns a final answer.

See Official Tools for the complete client and API contract. Web search is being updated and is not recommended for use in the near term.

Important limits

• Reasoning effort is configured with the top-level reasoning_effort request field and supports low, high, and max (default max); K3 always has thinking mode enabled.
• max_completion_tokens defaults to 131072 and can be set up to 1048576.
• temperature=1.0, top_p=0.95, n=1, presence_penalty=0, and frequency_penalty=0 are fixed; omit them from requests.
• Return the complete assistant message unchanged in multi-turn conversations and tool calls.
• Vision input does not support public image URLs. Use base64 or ms://<file-id>, and make content an array of objects.
• Web search is being updated and is not recommended for production workflows in the near term.

Happy Coding with new AI ❤

The 2.8 Trillion-Parameter Open-Source AI Model Developers Should Know was originally published in The Code Frontier on Medium, where people are continuing the conversation by highlighting and responding to this story.

A complete guide to building fault-tolerant distributed systems. Includes full code implementation, GitHub repository, and an interactive presentation.

In a microservices or distributed network architecture, transient failures aren’t just a possibility — they are a mathematical certainty. Temporary network drops, database blips, and downstream API hiccups occur constantly.

If your application handles these scenarios by throwing a raw 500 Internal Server Error back to the user, you aren't building a resilient system.

If you’re not a member, I’ve got you covered! ❤

This post details Polly, the flagship .NET resilience library, exploring how to implement an enterprise-grade, end-to-end resilience strategy using an ASP.NET Core Web API backend and a React (Axios) frontend.

The full codebase supporting this architecture is available on GitHub and check a complete presentation on this with all policies for better understanding at the bottom of this article:

👉 GitHub Repository: Polly Enterprise Understanding

GitHub - Shiv-Darshan-Singh/PollyEnterpriseUnderstanding: Polly updates and understanding with implementation in the React js and Asp.Net Core API

1. Core Philosophy: Fault Tolerance vs. Resilience

Before writing code, it is critical to understand the architectural shift from absolute fault isolation to comprehensive system resilience:

• Fault Tolerance: Building a system so rigidly structured that it avoids damage altogether under predictable load. Think of a bridge built to withstand baseline wind speeds without shifting.
• Resilience: The capacity of a system to absorb structural shocks, gracefully degrade its features under heavy stress, and recover its full operating state automatically. Think of a skyscraper designed to flex during a major earthquake so it does not collapse.

Distributed software must be resilient. Instead of hard-crashing when a dependency fluctuates, a resilient system surfaces cached records, retries failed actions via a backoff schedule, drops non-essential operations, and ensures primary application workflows remain unblocked.

2. Architectural Evolution: Polly v7 vs. Polly v8

Polly has evolved dramatically to meet modern cloud-native standards. If you are still building policies using the older v7 syntax, you are sacrificing performance and memory footprint.

Feature / CapabilityOld Polly Architecture (v7)New Polly Architecture (v8)Core AbstractionIndividual standalone Policy objects (Retry, Timeout, etc.)Unified, composable ResiliencePipelinePolicy CombinationRequired complex nested PolicyWrap.Wrap(...) syntaxesFluent, native chained builders (AddRetry().AddTimeout())PerformanceHigh allocation overhead due to deep execution wrappersZero-allocation target paths, highly optimized for memoryNative ExtensionsSeparate extension integration trackingDeep, native integration into Microsoft.Extensions.Http.Resilience

Polly v8 treats your resilience rules as an efficient, streamlined assembly line. Every request enters a single ResiliencePipeline, flowing sequentially through your defensive layers with minimum resource consumption.

3. The Core Polly Strategies

Let’s break down the primary defensive strategies provided by Polly, matching their programmatic behavior to real-world operational scenarios.

Strategy 1: Retry (The Automated Redial)

• What it does: If an operation encounters a temporary error, Polly pauses for a micro-duration and executes the request again.
• Real-World Analogy: A delivery driver knocks on your door. Hearing no immediate answer, they wait two minutes and knock again instead of returning the package to the distribution warehouse instantly.

Strategy 2: Circuit Breaker (The System Fuse)

• What it does: Tracks failure rates over a rolling window. If failures cross a set threshold, the circuit “trips” open, instantly blocking all outbound requests to protect the struggling downstream service.

States:

1. Closed: System is healthy; traffic flows normally.
2. Open: Traffic is immediately deflected. Requests fail fast without hitting the network.
3. Half-Open: A measured trial request is allowed through. Success closes the circuit; a single failure trips it right back open.

Strategy 3: Timeout (The Operational Boundary)

• What it does: Enforces a strict execution deadline on asynchronous operations. If a service hangs indefinitely, Polly clips the thread and forces a failure state.
• Real-World Analogy: Hanging up the phone after waiting on hold with customer service for 30 minutes.

Strategy 4: Fallback (The Contingency Plan)

• What it does: Defines a structured “Plan B” response when all primary execution attempts fail.
• Real-World Analogy: A restaurant running out of your preferred entree, prompting the server to offer a similar dish instead of leaving you empty-handed.

4. Backend Implementation: ASP.NET Core

To get started with Polly v8 in your backend Web API, add the core resilience package to your solution:

dotnet add package Microsoft.Extensions.Http.Resilience

Implementing a Composite Resilience Pipeline

The code below configures a production-ready, named HTTP client inside Program.cs. It combines Fallback, Retry (with Exponential Backoff and Jitter), Timeout, and a Circuit Breaker into a unified pipeline.

using Polly;
using Polly.CircuitBreaker;
using Polly.Retry;
using System.Net;

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddHttpClient("EnterpriseExternalClient")
    .AddResilienceHandler("StandardEnterprisePipeline", pipelineBuilder =>
    {
        // Layer 1: Fallback Policy
        pipelineBuilder.AddFallback(new FallbackStrategyOptions<HttpResponseMessage>
        {
            ShouldHandle = new PredicateBuilder<HttpResponseMessage>()
                .HandleResult(r => r.StatusCode == HttpStatusCode.InternalServerError)
                .Handle<HttpRequestException>(),
            FallbackAction = args =>
            {
                var fallbackResponse = new HttpResponseMessage(HttpStatusCode.OK)
                {
                    Content = new StringContent("{\"status\":\"Degraded\",\"message\":\"Displaying cached static backup data.\"}")
                };
                return Outcome.FromResultAsValueTask(fallbackResponse);
            }
        });
        // Layer 2: Retry Policy with Exponential Backoff + Jitter
        pipelineBuilder.AddRetry(new RetryStrategyOptions<HttpResponseMessage>
        {
            MaxRetryAttempts = 3,
            BackoffType = DelayBackoffType.Exponential,
            UseJitter = true, // Prevents Thundering Herd problem
            Delay = TimeSpan.FromSeconds(1),
            ShouldHandle = new PredicateBuilder<HttpResponseMessage>()
                .HandleResult(r => r.StatusCode == HttpStatusCode.ServiceUnavailable)
                .Handle<TimeoutException>()
        });
        // Layer 3: Circuit Breaker Policy
        pipelineBuilder.AddCircuitBreaker(new CircuitBreakerStrategyOptions<HttpResponseMessage>
        {
            FailureRatio = 0.5, // Trip if 50% of requests fail
            SamplingDuration = TimeSpan.FromSeconds(10),
            MinimumThroughput = 8,
            BreakDuration = TimeSpan.FromSeconds(30),
            ShouldHandle = new PredicateBuilder<HttpResponseMessage>()
                .HandleResult(r => r.StatusCode == HttpStatusCode.InternalServerError)
        });
        // Layer 4: Timeout Policy
        pipelineBuilder.AddTimeout(TimeSpan.FromSeconds(3));
    });

5. Frontend Implementation: React & Axios-Retry

Resilience shouldn’t end at your API gateway. If your backend is completely unresponsive or the client is experiencing a spotty mobile connection, your frontend application needs its own retry mechanisms to ensure a seamless user experience.

Using axios-retry in your React client mimics Polly's retry strategy right inside the user's browser.

Configuring the Client Axios Resilience Interceptor

import axios from 'axios';
import axiosRetry from 'axios-retry';

const apiClient = axios.create({
  baseURL: 'https://api.enterpriseapp.com/v1',
  timeout: 5000 // Frontend Timeout limit
});
// Configure Axios-Retry to act as a frontend resilience policy
axiosGridRetry(apiClient, {
  retries: 3, // Max retry count
  retryDelay: (retryCount) => {
    // Exponential Backoff calculation
    return retryCount * 1500; 
  },
  retryCondition: (error) => {
    // Only retry on network errors or transient 5xx server statuses
    return axiosRetry.isNetworkOrIdempotentRequestError(error) || 
           (error.response && error.response.status === 503);
  },
  onRetry: (retryCount, error, requestConfig) => {
    console.warn(`Retrying frontend request: Attempt ${retryCount} due to: ${error.message}`);
  }
});
export default apiClient;

6. Production Best Practices & Cheat Sheet

To keep this guide accessible for daily development, reference this cheat sheet when mapping architectural issues to specific Polly configurations:

Quick Reference Matrix

• Transient Network Failures / 503 Errors: Use Retry Strategy with exponential backoff and jitter enabled.
• Severe Downstream Dependency Outages: Use Circuit Breaker Strategy to shield dependencies and avoid thread pool exhaustion.
• Unbounded Latency / Sluggish APIs: Use Timeout Strategy to break hung connection threads cleanly.
• Critical User Interface Failures: Use Fallback Strategy to surface local defaults or static cached data models.

Top Pitfalls to Avoid in Production Environments

• Omitting Jitter: If 10,000 client applications hit a failing service at the exact same moment, and all retry at a fixed 2000ms window, you will create a self-inflicted DDoS attack (the Thundering Herd problem). Always use UseJitter = true.
• Retrying Non-Transient Errors: Never apply retry rules to 400 Bad Request, 401 Unauthorized, or 403 Forbidden statuses. An invalid parameter or missing token will never resolve itself on a retry—it simply wastes system resources.
• Ignoring Cancellation Tokens: Always forward your CancellationToken down into your backend ExecuteAsync steps. If a timeout strategy clips an execution loop but your internal database calls don't observe the token, the database will continue processing dead requests.

Summary & Resources

Building high-throughput, fault-tolerant ecosystems requires a dual approach: a rock-solid, thread-safe protection pipeline in the backend via Polly v8, combined with an adaptive network retry client in the frontend via Axios-Retry.

For complete setup steps, sample endpoints, and a plug-and-play architecture template, clone the project directly:

🔗 GitHub Repository: Polly Enterprise Understanding

For detailed interactive slide presentations covering these principles edge-to-edge, please launch and review the companion PollyTraining_Presentation.html deck embedded right inside the repository root! Below you can check that presentation that I have created for you.

Polly

Drop your thoughts, hot takes, or current tech stack in the comments below. I did love to hear what is actually happening on the ground in your engineering teams.

If you found this breakdown useful, drop a dew claps and share it with someone currently navigating their next career move in tech. It helps more engineers find these insights!

Happy Coding ❤

#SoftwareEngineering #TechCareers #Developers #CloudComputing #AI #RustLang #DevOps #TechJobs

Resilience Architecture: Polly v8 with ASP.NET Core and React was originally published in The Code Frontier on Medium, where people are continuing the conversation by highlighting and responding to this story.

The Future of Software Engineering Isn’t More Code — It’s These 7 Skills

AI Infrastructure, Platform Engineering, FinOps, Streaming Systems, and DevSecOps are becoming the skills that companies value-and pay for-the most.

If you’ve been following the tech job market over the past few years, you’ve probably noticed a harsh reality: the days of completing a two-month coding bootcamp, building a basic React dashboard, and landing a six-figure remote job are largely behind us.

If you’re not a member, I’ve got you covered! ❤

The industry didn’t stop hiring; it simply shifted where the budget is allocated.

As we look toward 2027, engineering compensation is concentrating heavily around complex infrastructure, high concurrency systems, specialized AI plumbing, and security. Companies are no longer paying top dollar for the people who just write feature code, they are paying for engineers who solve expensive problems like high latency, runaway cloud bills, distributed system failures and AI data bottlenecks.

If you are planning your skill stack for the next year or two here are the high value tech domains commanding the highest salaries, and why companies are writing massive checks for them.

1. AI Infrastructure & Agentic Systems Engineering:

Notice the wording here. The high-paying roles in 2027 aren’t “prompt engineers” or developers building basic wrappers around OpenAI APIs. Anyone can hit an API endpoint with JavaScript.

The massive compensation packages often reaching $200,000 to $350,000+ depending on the market are going to AI Systems Engineers. These are the folks who understand how to deploy, fine-tune, optimize, and scale model execution in production environments.

What the stack looks like:

• Frameworks and Runtimes: PyTorch, vLLM, TensorRT-LLM, Ray, LlamaIndex, LangGraph / AutoGen for agent orchestrations.
• Vector and Hybrid Search: Qdrant, Milvus, pgvector, LanceDB.
• Core Languages: Python, C++, Rust

Why it pays so well?

Running AI models in production is notoriously expensive and slow. Companies don’t just want models that work; they need latency dropped from 3 seconds to 200 milliseconds, and GPU compute bills cut in half. If you understand model quantization (AWQ, GGUF), distributed inference orchestration, and how to build autonomous multi-agent pipelines with deterministic fallbacks, you become indispensable overnight.

2. Low Latency Systems & Rust Architecture:

For years, Java, C#, and Go dominated enterprise backends and they still run a massive chunk of the world. But as real-time processing, high-frequency trading, edge computing, and AI engine development take over, Rust has crossed the threshold from an enthusiast tool to a core enterprise requirement.

Companies are rewriting critical infrastructure bottlenecks in Rust to reduce memory footprints and eliminate garbage collection pauses altogether.

What the stack looks like:

• Languages: Rust (primary), C++, Go.
• Core Concepts: Memory safety without GC, async runtimes (tokio), WebAssembly (Wasm) for edge computing, lock-free data structures.
• Target Industries: Fintech, High-Frequency Trading, Cloud Infrastructure, Database Engine Design, Cybersecurity tooling.

Why it pays so well?

Rust has a notoriously steep learning curve. Ownership, borrowing, and lifetime mechanics make it difficult to pick up casually over a weekend. Because supply remains low and enterprise demand is surging across cloud providers and fintech firms, engineers who master production-grade Rust are commanding premium salaries across the board.

3. Platform Engineering & Modern Cloud Ops:

The title “DevOps Engineer” has not vanished, but the industry has largely evolved toward Platform Engineering.

Instead of having a single DevOps engineer constantly building bespoke CI/CD pipelines for individual developer teams, companies are building Internal Developer Platforms (IDPs). The goal is simple, let product developers self-serve infrastructure safely without needing a deep background in Kubernetes or AWS IAM policies.

What the stack looks like:

• Infrastructure as Code: Terraform, OpenTofu, Pulumi (using TypeScript/Python instead of HCL).
• Container Orchestration: Kubernetes, Helm, ArgoCD (GitOps workflows).
• Observability & Telemetry: OpenTelemetry, Prometheus, Grafana, Datadog(it’s few costly as compared to others).
• Platform Frameworks: Spotify Backstage, Port.

Why it pays so well?

Developer velocity directly dictates how fast a company can ship software. If developers waste days fighting cloud permissions or breaking staging environments, it costs millions. Platform engineers who automate infrastructure into clean, secure internal tools save organizations immense developer hours-making executive teams happy to pay top-dollar for them.

4. Modern Data Engineering & Streaming Architecture:

Data engineering used to mean writing nightly ETL batch jobs that ran overnight scripts to update SQL databases. Today, that approach is too slow for modern applications.

Heading into 2027, high-earning data engineers build real-time streaming pipelines and manage unified lake house architectures that feed both live analytics and real-time AI context engines.

What the stack looks like:

• Streaming & Event Systems: Apache Kafka, Redpanda, Apache Flink.
• Storage & Lakehouses: Apache Iceberg, Delta Lake, Snowflake, Databricks.
• Transformation & Workflow: dbt, Apache Airflow, Dagster.
• Languages: SQL, Python, Scala, Rust.

Why it pays so well?

Data is worthless if it arrives late or corrupted. When a company relies on streaming data for live fraud detection, real-time recommendation engines, or financial transactions, a broken pipeline means immediate revenue loss. Engineers who can architect fault-tolerant, low-latency streaming infrastructure carry immense leverage during salary negotiations.

5. DevSecOps and AI Threat Defense:

Cybersecurity is no longer something you hand off to a separate security audit team right before a product launch. Attack surfaces have expanded rapidly, especially with shadow AI tool usage, API integrations, and automated exploitation techniques.

Companies are paying top dollar for Security Engineers who can integrate automated defense systems directly into the development lifecycle.

What the stack looks like:

• Identity & Access Management: OAuth2, OIDC, Zero-Trust Architecture, HashiCorp Vault.
• Application Security: Static & Dynamic Analysis (SAST/DAST), Software Bill of Materials (SBOM) management, Container Scanning (Trivy).
• AI Security: LLM guardrails, data loss prevention (DLP) for AI context, prompt injection defense mechanisms.

Why it pays so well?

A single data breach or regulatory penalty can cost tens of millions in damages and destroy customer trust overnight. Security remains one of the few areas where budget is rarely cut, even during economic downturns. Engineers who combine solid software development skills with deep security expertise remain among the most sought-after hires in the industry.

How to Position Yourself for These Roles Today

If you want to transition into these higher-tier compensation brackets over the next year, running through another basic online tutorial won’t cut it.

Here’s a pragmatic roadmap:

1. Move Down the Abstraction Layer: If you’re primarily a frontend developer or high-level script writer, start learning how things work under the hood. Understand networking fundamentals, memory management, container runtimes, and Linux internals.

2. Build Non-Trivial Projects: Don’t build another task tracking app. Build a distributed key-value store in Rust, deploy a multi-node Kubernetes cluster using Terraform, or architect an end-to-end RAG pipeline using open-source models with custom vector indexes.

3. Focus on Business Cost and Efficiency: High-paying engineering isn’t just about making things work, it’s about making them work efficiently. If you can talk about how you reduced query latency by 60% or slashed cloud infrastructure costs by $50,000 a year, you instantly elevate your status in any tech interview.

The tech industry isn’t shrinking; it’s simply raising the bar. The rewards are still substantial for engineers willing to step out of their comfort zone and tackle the hard infrastructure problems defining the future of software.

Over to You

Which of these stacks are you currently doubling down on for your career, and which ones do you think are overhyped?

Drop your thoughts, hot takes, or current tech stack in the comments below. I did love to hear what is actually happening on the ground in your engineering teams.

If you found this breakdown useful, drop a dew claps and share it with someone currently navigating their next career move in tech. It helps more engineers find these insights!

Happy Coding ❤

#SoftwareEngineering #TechCareers #Developers #CloudComputing #AI #RustLang #DevOps #TechJobs

The Future of Software Engineering Isn’t More Code — It’s These 7 Skills was originally published in The Code Frontier on Medium, where people are continuing the conversation by highlighting and responding to this story.