i’ve spent over $200k on distribution mistakes to learn the lessons from this article:

This is exactly what happened to US AI models 😛 https://x.com/HeyZaraKhan/status/2082356815539380321

Must-know open-source or free tools for developers

https://mediabunny.dev/ - Open-source complete JavaScript media toolkit
https://sevalla.com/ - Deploy apps without managing infrastructure
https://gitingest.com/ - Converts Git repositories into LLM prompts.
https://www.bagui.pro/ - Open-source ShadCN UI registry
https://hurl.dev/ - Open-source CLI HTTP request tests

📸 These flash selfies feel surprisingly real!

Same setup each time: a low-angle iPhone selfie, an outstretched arm, direct flash, and a large shadow on the wall.

Then changed the hair, styling and mood:
1. Burgundy after dark
2. Silver corridor
3. Black-gold shadow
4. White shirt at midnight

Made with ChatGPT-Image2
Prompt below 👇

Stateful vs. Stateless MCP core.

(Anthropic's biggest MCP update)

Let me explain what that means:

Until this release, talking to an MCP server worked like a phone call. Both sides ran an initialize handshake, and the server returned a session id carried on every later request.

That session was a live object inside one specific server process, holding the negotiated state.

Picture a restaurant where the waiter who took the order is the only one who knows what was ordered. Everything works until that waiter goes home.

Because that state lives in one process, a balancer could not spread requests across three MCP server instances. Teams pinned clients with sticky sessions or pushed session state into shared storage, which blocked autoscaling and made a single restart drop every open session.

The latest update deletes all of it. The handshake and the Mcp-Session-Id header are gone, and each request now carries its own protocol version, client identity, and capabilities in a _meta field.

Clients that want the capability list up front can call server/discover, but nothing requires it.

The restaurant works the other way around now. That flips the restaurant around. Every request is a written order slip now, and any waiter can fill it.

So any request can land on any instance behind a plain round-robin balancer, with no shared session store. MCP servers become ordinary HTTP services that run on serverless and edge, and survive restarts.

Removing sessions broke three features, so each got rebuilt.

→ Tools that need to ask the user something mid-call used to push that request down a held-open stream. Now the server returns input_required and the client retries with the answers attached.

→ Method and tool names moved into the Mcp-Method and Mcp-Name headers, so a gateway or rate limiter can route and meter without parsing the JSON-RPC body.

→ List responses carry ttlMs and cacheScope, so clients cache tool catalogs instead of refetching them on every reconnect.

State did not disappear here, it moved somewhere the model can see it.

Applications that need continuity get an explicit handle from a tool and have the model pass it back as an argument on the next call.

A session id in a header is invisible to the model, while a handle in the arguments is something it can read, thread between tools, and recover from after a failed call.

Official Spec: https://modelcontextprotocol.io/specification/2026-07-28

Since we are on MCP, I also wrote about why the MCP versus CLI debate was the wrong one, and how agents can call tools by writing code instead of loading every schema into context.

The article is quoted below.

A Python tool that retrieves WhatsApp profile photos, verifies Business accounts, checks user status, and analyzes linked devices using the WhatsApp OSINT API.

https://github.com/kinghacker0/WhatsApp-OSINT https://x.com/tom_doerr/status/2082214320356651096