Dev Shorts

[Dev Catch Up # 116] - OpenAI & HuggingFace Security Incident, Gemini 3.6 Flash, Qwen3.8, Grok For Excel, Cursor Router, Andrew NG's OpenWorker, CoWork's feature - Record a Skill, OpenShip and more!

Aravind Putrevu — Fri, 24 Jul 2026 12:30:43 GMT

Welcome to the 116th edition of DevShorts, Dev Catch Up.

For those who joined recently or are reading Dev Catch Up for the first time, I write about developer stories and open source, partly based on my work and experience interacting with people all over the globe.

Thanks for reading Dev Shorts! Subscribe for free to receive new posts and support my work.

Some recent issues from Dev Catch up:

Join 8900+ developers to hear stories from Open source and technology.

Must Read

Last week, Hugging Face disclosed a security incident. An AI agent had compromised its infrastructure. OpenAI later found that its models were behind the incident. It happened during an internal cybersecurity test. The models found a way to access the internet from the isolated environment. They then accessed Hugging Face’s systems to get benchmark answers. Check OpenAI’s post for more details.
Google has released three new Gemini models. Gemini 3.6 Flash is built for coding, knowledge work, and multimodal tasks. It uses fewer output tokens than previous model. Gemini 3.5 Flash-Lite is built for fast, high-volume tasks. Gemini 3.5 Flash Cyber works with CodeMender to find and fix security vulnerabilities. Check Google’s post for more details.
Qwen has announced Qwen3.8, an upcoming 2.4T-parameter model. Qwen says the model will be released with open weights soon. Qwen3.8-Max-Preview is already available through selected Qwen platforms. Check Qwen’s post for more details.
Anthropic has added an interesting feature to Claude Cowork. There is a feature named Record a Skill. You can now record your screen while completing a task and explain the steps. Claude turns the recording into a reusable skill. It can use the skill to repeat the task later. Check Claude’s post for more details.

OSS Highlight of the Week

This week, we are featuring Openship. It is an open source, self-hosted platform for deploying apps. You point it to a repository, and it detects the stack, builds the app, and deploys it. You do not need to prepare configuration files, pipelines, or YAML files. It also manages databases, domains, SSL, and backups. Check the GitHub repo for setup details.

Sakana AI has released Fugu-Ultra v1.1 and Fugu-Cyber. Fugu-Ultra v1.1 is built for coding, agentic tasks, and advanced reasoning. Fugu-Cyber is a multi-agent system that can analyze vulnerabilities and create detection rules. Access to Fugu-Cyber requires approval. Check Sakana AI’s posts for more details.
NVIDIA has released Cosmos 3 Edge, a 4B-parameter model for robots and vision AI agents. It can understand scenes and generate robot actions on edge devices. Developers can adapt it for their own robot policies. Check NVIDIA’s post for more details.
Cisco has released Antares-350M and Antares-1B. These open-weight models can find files that may contain vulnerabilities. They run locally, so sensitive code stays within the environment. Check Cisco’s post for more details.
Poolside has released Laguna S 2.1, an open-weight coding model. It has 118B total parameters, 8B active parameters, and a 1M-token context window. It is built for long coding and agentic tasks. Check Poolside’s post for more details.

Notable FYIs

XAI has released Grok for Excel, an AI assistant that works inside Excel. You can now complete Excel tasks using simple prompts. It can write formulas, answer questions about selected data, create charts, and rerun scenarios. Check SpaceXAI’s post for more details.
Andrew Ng has released OpenWorker, an open source AI coworker that runs on your desktop. You can give it a task, and it completes the work for you. You can connect it to models from different providers or run local models with Ollama. Check the GitHub repo for setup details.
Cursor has launched Cursor Router. It routes each coding request to the right model. Simple tasks go to lower-cost models, while harder tasks go to stronger reasoning models. This helps teams reduce token costs. Check Cursor’s post for more details.
Unsloth now supports AMD hardware. Developers can train and run more than 500 AI models on AMD GPUs. It works on Windows, WSL, and Linux. Some Qwen and Gemma models can be trained with 3 GB of VRAM. Check Unsloth’s post for more details.
Qwen has released Qwen-Image 3.0, its latest image generation model. It can create detailed layouts such as newspapers, storyboards, and UI designs. It can generate small readable text and supports 12 languages. Check Qwen’s post for more details.

That’s it from us with this edition. We hope you are going away with a ton of new information. Lastly, share this newsletter with your colleagues and pals if you find it valuable. A subscription to the newsletter will be awesome if you are reading it for the first time.

Thanks for reading Dev Shorts! This post is public so feel free to share it.

[Dev Catch Up #115]- Kimi K3, Grok 4.5, Bonsai 27B, Thinking Machine's Inkling, GPT-Live, Clawk-disposable VMs for Agents, SWE-1.7, Meta's Muse Spark 1.1, grok-build,Agent Teams in Antigravity & more!

Aravind Putrevu — Fri, 17 Jul 2026 12:31:33 GMT

Welcome to the 115th edition of DevShorts, Dev Catch Up.

Thanks for reading Dev Shorts! Subscribe for free to receive new posts and support my work.

Some recent issues from Dev Catch up:

Join 8900+ developers to hear stories from Open source and technology.

Must Read

Moonshot AI has released Kimi K3, a 2.8T-parameter model. It is built for coding and agentic tasks. It supports native vision and a 1M-token context window. The full model weights will be released by July 27, 2026. Check Kimi’s post for more details.
Thinking Machines Lab has released Inkling, a new open-weights model. The MoE Model has 975B total params, 41B active params. It can work with text, images, and audio. It supports 1M-token context window. The weights are on Hugging Face. Check Thinking Machines Lab’s post for more details.
SpaceXAI has launched Grok 4.5. SpaceXAI says this is its strongest model so far. It was trained alongside Cursor. It is built for coding, agentic tasks, and real engineering tasks. The model is good at creating well-designed, end-to-end apps. Check SpaceXAI’s post for more details.
PrismML has released Bonsai 27B, a compressed multimodal model based on Qwen3.6. Its 3.9 GB 1-bit version can run on an iPhone 17 Pro, while the 5.9 GB version targets laptops. Both versions support reasoning, vision, and tool calls on local devices. Check PrismML’s post for more details.

OSS Highlight of the Week

This week, we are featuring Clawk. It is an open source tool that gives coding agents a disposable Linux VM. It works with Claude Code, Codex, and shell sessions. The agent gets root access inside the VM. Your keychain and unmounted files stay outside it. Network access is controlled through an allow-list. Check the GitHub repo for setup details.

Google Antigravity has added Agent Teams as a research preview. The /teamwork-preview command starts a team of specialized subagents. They work together to plan, build, and verify coding tasks in parallel. This feature is limited to Google AI Ultra users. Check Antigravity’s post for more details.
Parallel has launched Search Turbo, a new fast mode for its web search API. It returns web results that AI models can use directly. This can be useful for applications that need fast web search. Check Parallel’s post for more details.
Meta has launched Muse Image and Muse Video. Muse Image can edit images and combine elements from multiple references. It can search the web for current information and improve its own output. Muse Video can generate videos with native audio. Check Meta’s post for more details.
Passmark is an opensource Playwright library. It covers end-to-end browser testing. You can write browser test steps in natural language. It uses AI models to execute those steps through Playwright. Check the GitHub repo for setup details.
Reve has launched the Reve 2.1 API. It can create and edit native 4K images. It also includes experimental APIs for working with layouts. A layout splits an image into editable regions. Developers can change one region without changing the rest of the image. Check Reve’s post for more details.
We are covering more resources on harness engineering. Here is another one on harness engineering by Lilian Weng. The guide covers workflow automation, file-based memory, subagents, and self-improving harnesses. Read the full post for more details.

Notable FYIs

OpenAI has launched GPT-Live, a new voice model for natural conversations. It can listen and speak at the same time. For harder questions, it can send search and reasoning tasks to GPT-5.5 while the conversation continues. The API is planned for a later release. Check OpenAI’s post for more details.
Cognition has released SWE-1.7, its most capable coding model so far. It is built for long-running software engineering tasks. When the model approaches its context limit, it summarizes its current work and continues from that summary. Check Cognition’s post for more details.
SpaceXAI has open sourced Grok Build, its coding agent harness and terminal UI. It shows how it assembles context, handles model responses, and runs tool calls. It also includes support for skills, plugins, hooks, MCP servers, and subagents. Check the GitHub repo for more details.
Meta has released Muse Spark 1.1, a multimodal reasoning model for agentic tasks. It has a 1M-token context window. It can compact older work while keeping important steps. It also supports planning and parallel subagents. Check Meta’s post for more details.
Mellea is an open source Python library for building structured LLM workflows. It turns Python functions into LLM calls. Docstrings become prompts, and type hints define the output format. It checks the result and retries if the requirements are not met. Check the GitHub repo for setup details.

Thanks for reading Dev Shorts! This post is public so feel free to share it.

How to Run Custom Models in Codex

Aravind Putrevu — Fri, 10 Jul 2026 13:30:53 GMT

Codex is not locked to OpenAI’s cloud models. It can connect to almost any model out there. You can connect a local model running on your own machine, or point it to other models from different providers.

Nowadays, most coding agents like Claude Code and Codex support custom models. That opens up options. You could choose a model based on cost, privacy, or just wanting to try something new.

In this guide, we will cover:

Codex App and CLI
Connect Local Models in Codex through Ollama, LM Studio, Unsloth, and llama.cpp
Connect Custom Models in Codex through OpenRouter
Four points to remember while integrating custom models

1. Codex App and CLI

OpenAI ships Codex as a desktop app and a CLI. Both let you bring your own model. The desktop app gives you a full interface, multi-agent runs, worktrees, and an in-app browser. The CLI runs right in your terminal.

2. Connect Local Models in Codex through Ollama, LM Studio, Unsloth, and llama.cpp

There are a few ways to run a model on your own machine and connect it to Codex.

Ollama is the easiest place to start, so we will begin there.

Codex App with Ollama:

Ollama can connect with the Codex Mac app, as well as the Codex terminal.

Install Ollama, then pull a model.

brew install ollama          # macOS
curl -fsSL https://ollama.com/install.sh | sh   # Linux

# pull the model

ollama pull qwen3.5:4b

Once you’ve pulled the model, start the Codex app with,

ollama launch codex-app

# If you have more than one model pulled locally, point it at the one you want
ollama launch codex-app --model qwen3.5:4b

This opens the Codex app already pointed at your local model.
To switch back to your previous codex setup, run,
```
ollama launch codex-app --restore
```
Ollama restores your old settings, and saves a backup under ~/.ollama/backup/codex-app/ before it changes anything.

Note: Use a model that supports tool calling, since Codex depends on tool calling for everything it does. For example, gemma3:4b does not support tools at all, and it will fail the moment Codex tries to use one.

Codex CLI with Ollama

Ollama connects to the Codex CLI too. Once you have pulled the model, you can launch codex cli with below commands.

ollama launch codex

# If you have more than one model pulled locally, point it at the one you want
ollama launch codex --model qwen3.5:4b

# You can also skip the launcher and use the --oss flag directly,
codex --oss -m qwen3.5:4b

Profile based setup

You can also do a profile based setup to connect ollama with codex cli.

Create ~/.codex/ollama-launch.config.toml.

model = "gpt-oss:120b"
model_provider = "ollama-launch"
model_catalog_json = "/Users/you/.codex/model.json"

[model_providers.ollama-launch]
name = "Ollama"
base_url = "http://localhost:11434/v1/"
wire_api = "responses"

Then run this,
```
codex --profile ollama-launch
```

Codex CLI with LM Studio:

LM Studio gives you a simple interface for downloading and running models.

Install LM Studio.
Once installed, you will be asked to download a model. Choose the one you want.
Go to the Developer tab. Before loading the model, check the context length. LM Studio often sets this low by default, sometimes 8192. Increase it to 32k or higher, if your machine can handle it. Codex adds tool definitions and instructions to every message behind the scenes, on top of what you actually type, so a small context window fills up fast.
Load the model, and turn the server on. Confirm the status shows as running.
Before touching Codex, check what actually loaded:
```
curl http://localhost:1234/v1/models
```
Now connect Codex. It connects a local model with the --oss flag, and use -m to pick a specific model.
```
codex --oss -m google/gemma-4-e4b
```
If you have more than one local server running at the same time, running codex --oss shows a picker, asking which one to use. Select the one you want, and it connects to that.

Profile based setup

If you want this LM Studio setup saved as a profile, add this to ~/.codex/config.toml. Name the provider lmstudio_local. If you name it just lmstudio, Codex will reject it, that name is already reserved for its own internal use.
```
[model_providers.lmstudio_local]
name = "LM Studio"
base_url = "http://localhost:1234/v1"
wire_api = "responses"
```
Profiles live in their own file. Create ~/.codex/lmstudio.config.toml:
```
model_provider = "lmstudio_local"
model = "google/gemma-4-e4b"
```
Launch it with,
```
codex --profile lmstudio
```
```
/status
```

Codex CLI with Unsloth

Unsloth is another local option. It has a web interface and some automatic tool-calling fixes built in.

Install Unsloth

curl -fsSL https://unsloth.ai/install.sh | sh

This starts Studio on port 8888. Open http://127.0.0.1:8888 in your browser and set a password.
Load a model from the dropdown, for example unsloth/gemma-4-26B-A4B-it-GGUF, and test the model is working.
Once you test the model inference in unsloth studio, you can start the codex,
```
unsloth start codex
```

Profile based setup

You can also set profile like below.

Add this to ~/.codex/config.toml.

oss_provider = "unsloth_api"

[model_providers.unsloth_api]
name = "Unsloth Studio"
base_url = "http://localhost:8888/v1"
env_key = "UNSLOTH_STUDIO_AUTH_TOKEN"
wire_api = "responses"

Then create ~/.codex/unsloth_api.config.toml.

model_provider = "unsloth_api"
model = "unsloth/gemma-4-26B-A4B-it-GGUF"

Grab your API key from Settings→API, inside Unsloth Studio. Set it.
```
export UNSLOTH_STUDIO_AUTH_TOKEN=your_key_here
```
Launch Codex with unsloth api,
```
codex --oss --profile unsloth_api
```

Codex CLI with llama.cpp

llama.cpp is another way of connecting Local LLMs to the codex.

Install it:
```
brew install llama.cpp
```
If you want to build it from source instead, check llama.cpp build page.
Download a model. hf is the command Hugging Face's tools use now, the older huggingface-cli name was retired.
```
pip install -U huggingface_hub hf_transfer
hf download unsloth/gemma-4-e4b-it-GGUF --include "*Q4_K_M*"
```
Some models use chat templates with rules that llama.cpp doesn’t fully support, and the server will reject every message when that happens. Check this before committing to a model, so you don’t spend time debugging something that was never going to work.

Find the actual file path once the download finishes.

ls -lh ~/.cache/huggingface/hub/models--unsloth--gemma-4-e4b-it-GGUF/snapshots/*/

Start the server. --jinja matters here, it's what turns on tool calling, and Codex needs that to work at all.
```
./llama-server -m  -c 32768 --jinja --port 8090
```

Add this to your Codex config.toml

[model_providers.llama_cpp]
name = "llama.cpp"
base_url = "http://localhost:8090/v1"
wire_api = "responses"

Create ~/.codex/llamacpp.config.toml.

model_provider = "llama_cpp"
model = "gemma-4-E4B-it-Q4_K_M"

Now start the codex
```
codex --profile llamacpp
```

3. Connect Custom Models in Codex through OpenRouter

Everything so far runs on your own machine. You can also point Codex to a custom model from different provider.

OpenRouter is one example, an inference provider that gives you access to models like GLM-5.2 through APIs.

Add this to ~/.codex/config.toml

[model_providers.openrouter]
name = "OpenRouter"
base_url = "https://openrouter.ai/api/v1"
env_key = "OPENROUTER_API_KEY"
wire_api = "responses"

Then create ~/.codex/openrouter.config.toml.

model_provider = "openrouter"
model = "z-ai/glm-5.2"

Set your API key, then run Codex.

export OPENROUTER_API_KEY="your_key_here"

Run Codex with this profile.
```
codex --profile openrouter
```
Check with /status, you should see openrouter listed as the model provider.

4. Four points to remember while integrating custom models

Only wire_api = "responses" works now. Codex removed wire_api = "chat" support in February 2026. If an old tutorial has you set wire_api = "chat", Codex won't start.
Three provider names are reserved: openai, ollama, and lmstudio. You can't use these under [model_providers.x], even for your own custom setup. Use something else, like lmstudio_local.
Always set your provider and API keys in ~/.codex/config.toml, your personal config file. Never in a .codex/config.toml sitting inside a project folder, Codex won’t use them from there anyway.
The model name has to match your server exactly, same spelling, same case. Check it with curl http://localhost:PORT/v1/models, and copy the name from there instead of typing it from memory.

Conclusion

We covered how to connect local models and custom models to Codex.

Now you have the option of running local models in your coding agents. If you have enough system requirements, try different models for different tasks. Open source models hold up well for everyday coding work. Running them yourself means you control the cost, and your code stays right there on your machine.

Try Codex with custom models! Happy building!

Thanks for reading Dev Shorts! This post is public so feel free to share it.

[Dev Catch Up # 114]- Fable 5 is back, OpenAI's GPT 5.6, Claude Sonnet 5, Nano Banana 2 Lite, Gemini Omni Flash, Lore -Open Source Version Control, Hosted X MCP, Nemotron-Labs-TwoTower and more!

Aravind Putrevu — Fri, 03 Jul 2026 12:30:02 GMT

Welcome to the 114th edition of DevShorts, Dev Catch Up.

Thanks for reading Dev Shorts! Subscribe for free to receive new posts and support my work.

Some recent issues from Dev Catch up:

Join 8900+ developers to hear stories from Open source and technology.

Must Read

Anthropic is restoring access to Claude Fable 5 after export controls were lifted. Fable 5 is now available globally across Claude Platform. Anthropic has also restored Mythos 5 access for some US organizations. Check Anthropic’s post for more details.
OpenAI has released the GPT 5.6 series. It has three models. Sol as the flagship model, Terra for balanced everyday use, and Luna as the faster and cheaper model. Sol is positioned for harder coding workflows and complex agent tasks. Check OpenAI’s post for more details.
Anthropic has released Claude Sonnet 5. It is built for longer agentic tasks, coding, and tool based workflows. Anthropic says it brings more Opus style agent behavior into the Sonnet tier at a lower price. Check Anthropic’s post for more details.
Google has released Nano Banana 2 Lite and Gemini Omni Flash. Nano Banana 2 Lite is for fast and low cost image generation. Gemini Omni Flash is for video generation and editing. Developers can use both models together to turn images into short videos. Check Google’s post for more details.

OSS Highlight of the Week

This week we are featuring Lore, an open source version control system. It is built for large projects that mix code with large files, like games and entertainment projects. Lore supports lightweight workspaces, fast branching, and file downloads only when needed. Check the GitHub repo for more details.

Good to know

xAI has launched Voice Agent Builder. It is a no code platform for building voice agents on Grok Voice. It is used to build voice agents without setting up the full voice stack from scratch. It also supports telephony, knowledge retrieval, tools, guardrails, MCPs, and observability in one place. Check xAI’s post for more details.
Anthropic has launched Claude Science. Its an AI workbench for scientists. Claude Science is an app that integrates the tools and packages researchers commonly use. It helps with literature review, data analysis, figures, and manuscripts. Check Anthropic’s post for more details.
NotebookLM has added Short Video Overviews. It turns uploaded sources into 60 second mobile videos. This gives users another way to understand the material, apart from text and audio overviews. Check NotebookLM’s post for more details.
Meta has released Brain2Qwerty v2. It turns brain activity into text using non invasive brain recordings. This means the system does not need surgery. Meta is also releasing the training code and the v1 dataset. Check Meta’s post for more details.

Notable FYIs

XAI has announced Hosted X MCP. It is a Streamable HTTP MCP server that lets MCP clients talk to the X API. Developers can use it with their own X account permissions. Check the X Developer Community post for more details.
Claude Code has added an experimental advisor tool. When Claude is unsure or gets stuck during a coding task, it can ask a stronger model for help. It can also use the advisor to review its approach before finishing the task. Check Claude Code docs for more details.
NVIDIA Research has released Nemotron-Labs-TwoTower. It is a diffusion language model built from Nemotron 3 Nano 30B. One part keeps the context, and the other generates tokens in parallel. NVIDIA says this keeps most of the original model quality while making generation faster. Check NVIDIA’s post for more details.
LongCat has released LongCat 2.0, an open source model. It is built for agentic coding. It supports long context work and coding tasks across larger codebases. LongCat says the model was trained and served on Chinese chips. Check LongCat’s post for more details.
Google has open sourced Copybara. The tool is used by Google internally. It transforms and moves source code between repositories. This is useful when teams need to keep private and public repositories synced. Check the GitHub repo for more details.

Thanks for reading Dev Shorts! This post is public so feel free to share it.

GLM 5.2 vs Opus 4.8 in Claude Code

Aravind Putrevu — Wed, 24 Jun 2026 14:18:25 GMT

GLM 5.2 dropped recently. And it's been all over my feed since.

Simon Willison and Patrick Toulme were also talking about it.

People are already comparing it directly with Opus 4.8 on quality. The interesting part is the price. GLM 5.2 is much cheaper per token, so I wanted to test how close it really gets.

I ran GLM 5.2 and Opus 4.8 inside Claude Code across five real developer tasks. I found some interesting insights in each test. Here is what this post covers.

GLM 5.2 and Opus 4.8: An Overview
Setting up GLM 5.2 inside Claude Code
GLM 5.2 vs Opus 4.8 in Claude Code
1. Test 1: One-shot UI build
2. Test 2: Debug a failing test
3. Test 3: Fixing a performance bottleneck
4. Test 4: Refactoring codebase
5. Test 5: A multi-step research task, with sub-agents
Key Insights from Tests

1. GLM 5.2 and Opus 4.8: An Overview

Knowing the difference, let’s do the real tests and see how both perform.

2. Setting up GLM 5.2 inside Claude Code

Claude Code is a harness, and any custom model can be set up inside it.

You can use GLM 5.2 from any inference provider. If you are using Z.ai, here is how to set it up in Claude Code. Get an API key from Z.ai's platform. Then edit ~/.claude/settings.json and add this. (Full docs here)

{
  "env": {
    "ANTHROPIC_AUTH_TOKEN": "your_zai_api_key",
    "ANTHROPIC_BASE_URL": "https://api.z.ai/api/anthropic",
    "API_TIMEOUT_MS": "3000000"
  }
}

This gets GLM running inside Claude Code. But by default it maps to GLM-4.7, not 5.2. To actually run GLM 5.2, with the full 1M context window, add this too.

{
    "env": {
      "CLAUDE_CODE_AUTO_COMPACT_WINDOW": "1000000",
      "ANTHROPIC_DEFAULT_HAIKU_MODEL": "glm-5.2[1m]",
      "ANTHROPIC_DEFAULT_SONNET_MODEL": "glm-5.2[1m]",
      "ANTHROPIC_DEFAULT_OPUS_MODEL": "glm-5.2[1m]"
    }
}

A few things to note.

The [1m] suffix enables the full 1M context. Without it, you get the default context window, not 1M.
GLM 5.2 uses 3x your quota during peak hours, 2x during off-peak.
Run /status in Claude Code to confirm which model you are on.

This setup is for Z.ai. If you are using a different provider, the config will be different.

If you are using GLM model from Fireworks AI, they have their own way of integrating it, check their documentation. Same goes for OpenRouter, the steps are different, so follow what your provider docs say.

For Fireworks AI - GLM 5.2 integration, run below commands.

curl -fsSL https://raw.githubusercontent.com/fw-ai/fireconnect/main/install.sh | FIREWORKS_API_KEY="fw_xy”z bash

fireconnect claude on --api-key fw_xyz

3. GLM 5.2 vs Opus 4.8 in Claude Code

Now let us get into the tests. I ran both models on the same tasks, same prompt, same codebase.

Test-1: One-shot UI build

The first test is a one-shot UI build. I gave the same prompt to both models to see what they build, without any follow-ups.

Prompt Given:

Build a Northern Lights tracker. Purely frontend, mock data is fine. 

It should show the best viewing locations for tonight, visibility forecast by hour, and a KP index indicator. When visibility is high, the interface should feel like it.

The design is the real test here. Auroras are one of the most visually stunning things on the planet. The UI should reflect that. Animations, atmospheric gradients, a dark sky feel. Not a weather app with a green badge. Something that actually makes you want to look up.

Use whatever stack and libraries make sense. Install what you need.

Build it end to end and verify it runs in the browser before stopping. No clarifying questions.

Both built something impressive in one shot.

What GLM 5.2 Built

GLM built the visually stronger UI. Full-screen aurora waves, bold hero text, rich location cards. It feels alive as you scroll.

The only thing it needs is a small fix on the hero animation speed. The waves move too fast and the text gets buried. One prompt, and it is right there with Opus.

What Opus 4.8 Built

Opus built a clean, functional dashboard. Structured layout, clear hierarchy, each section separated and easy to scan. Complete UI, up and running in one shot.

What I noticed:
Both delivered impressive UIs in one shot.
Opus was clean and complete with no issues out of the box.
GLM was visually stronger but needed one small fix on the animation speed.
One thing worth noting. GLM does not support image input, so it could not verify the UI in the browser the way Opus did. Opus used the browser tool to check its own output. GLM had to skip that step.
On the numbers, GLM used more tokens and took a bit longer than Opus. But the token cost is lower, so the final bill was still significantly cheaper. Almost equal quality to Opus, at a fraction of the price.

Now, here is the remaining details

Test 2: Debug a failing Test

npm test was failing. That was the whole prompt. No hints, no file names, no description of what is wrong.

Prompt Given:

npm test is failing. fix it

The real question here is whether the model can identify the root cause correctly. One failure was a real bug in the implementation. The other was a wrong assertion in the test. Each needed a different kind of fix.

What Opus 4.8 did

Opus went straight to it. Ran the tests, read the files, fixed both issues correctly. Knew exactly where to look and what to change. Clean and done.

What GLM 5.2 did

GLM took a more thorough approach. It read more context before acting and ran a shell command to verify the fix before wrapping up. Same correct fixes as Opus, but more steps and time to get there.

What I noticed:
Opus got there faster and with fewer tokens, clean and direct.
GLM found failing tests and fixed them correctly, same as Opus. Same diagnosis, same fixes.
GLM read significantly more context, 35.5k input tokens vs Opus 6.5k. It took a more thorough path before committing the fix.

Test 3: Fixing performance bottleneck

I gave both models a user complaint and a file path.

Prompt Given:

Users are reporting that the issues list loads slowly when a project has a lot of data. 

The backend entry point is src/services/issueService.ts. 
Find the bottleneck and fix it.

The actual issue was a query doing redundant work for every row it processed, with no indexes to speed it up. Fine on small data, but slow on large ones. Exactly what users were reporting.

Both models proposed the same two-layer fix. Rewrite the query, add indexes.

The difference was execution.

What GLM 5.2 did

GLM diagnosed it correctly and went deep into benchmarking. It even caught that its own rewrite was slower than expected and re-evaluated. But the investigation loops kept going, so I stepped in and asked it to wrap up. It gave the right fix, but burnt more tokens and time.

Here is where it caught its own mistake.

What Opus 4.8 did

Opus read the files, wrote the fix, verified it, and wrapped up in 5 minutes. Clean, done.

What I noticed:
Both models proposed the same fix. Rewrite the query and add indexes. Same diagnosis, same solution.
GLM went deeper than needed. It caught that its own rewrite was slower than expected and kept re-evaluating. Good reasoning, but the investigation loops ran too long. I had to step in and ask it to wrap up. Finally it gave the right answer.
Opus read the files, wrote the fix, verified it with the sqlite3 CLI, and wrapped up in under 5 minutes.
GLM burned significantly more tokens to reach the same conclusion.

Test 4: Refactoring Codebase

This test is about giving both models a messy file and seeing how they clean it up, without telling them what is wrong.

Prompt given:

file issueService.ts is getting messy. Clean it up.

Both models read the file, identified the same problems and refactored the same way.

The difference was execution speed.

What Opus 4.8 did

Opus read the file, made the changes, ran the compiler to verify, and wrapped up in 3 minutes 32 seconds. Clean and done.

What GLM 5.2 did

GLM also cleaned in the same way. But it took more steps and time to get there.

What I noticed
GLM 5.2 reasoning is as high as Opus 4.8. Just like every other test, it consumed more token and time.
Opus flagged two edge cases it changed that were not part of the original request and asked if you want to keep them. That kind of communication is useful in a real codebase.

Test 5: A multi-step research task, with sub-agents

Both models performed really well on this research task.

Prompt given:

Research the latest agentic frameworks that support multi-agent orchestration.

Find:
- Which ones are actively maintained
- What the developer community thinks of each one
- How they compare on ease of use, flexibility, and production readiness

Give me a comparison table and a recommendation on which one to start with.

What Opus 4.8 did

Opus ran 46 web searches, used sub-agents, and came back with a structured comparison table, community sentiment per framework, version numbers, enterprise users, and a clear recommendation with reasoning.

What GLM 5.2 did

GLM went deeper than Opus. It used more iterations, more tool calls, more web searches, and spawned more sub agents. It consumed significantly more tokens,

But the final result was at Opus level.

What I noticed
Both reached the same findings, same reasoning, same recommendation.
Opus stayed focused and got there efficiently. GLM went wider but arrived at the same place.
The cost difference comes down to how each model works, not the quality of the output.
For deep research tasks, GLM’s cheaper token cost is an advantage. It can afford to go wider without the bill getting out of hand.

4. Key Insights from Tests

GLM 5.2 is genuinely good. The reasoning is there. The quality is there. In most tests it reached the same answer as Opus. It is really great to see an open weight model performing at this level, matching Opus on quality.

But it consumes more token, and takes more time for many tasks. It goes wider and deeper than needed. In Test 3, it went so deep into benchmarking its own fix that it took longer than expected.

Opus, just like always more focused. It builds efficiently and moves on.

Across five tests, here is how they compare overall.

These results are based on my own tests, not any official claims or vendor comparisons. Your results may vary depending on the task and provider.

One thing worth noting. Every test here was run on high effort. At that level, GLM matched Opus consistently. Whether it holds up the same way on medium effort is still untested.

GLM 5.2 is closer to Opus 4.8 than most people think. And significantly cheaper.

I hope this blog gives you a clear picture of where GLM 5.2 stands and whether it is worth adding to your workflow. If you are already on a Claude subscription, setting up GLM alongside it takes five minutes. Start with one task and see how it feels.

Happy building.

Thanks for reading Dev Shorts! This post is public so feel free to share it.

[Dev Catch Up # 113]- GLM 5.2, Kimi-K2.7-Code, SpaceX acquires Cursor, Anthropic blocks Fable and Mythos access, Vercel’s Eve-Agent Framework, OpenRouter's Fusion,Cursor's Origin,Zed's DeltaDB & more!

Aravind Putrevu — Fri, 19 Jun 2026 12:30:41 GMT

Welcome to the 113th edition of DevShorts, Dev Catch Up.

Thanks for reading Dev Shorts! Subscribe for free to receive new posts and support my work.

Some recent issues from Dev Catch up:

Join 8900+ developers to hear stories from Open source and technology.

Must Read

Z.AI has released GLM 5.2, its new open weight coding model. It is built for long coding tasks and supports 1M context. It has two thinking effort levels, High and Max. For coding, Z.AI recommends Max for better reasoning. Check Z.AI’s post for more details.
Moonshot AI has released Kimi K2.7 Code. It improves coding and agent performance compared to K2.6. It also uses fewer reasoning tokens, which means less overthinking during coding tasks. The model is available through Kimi API and Kimi Code. Check Kimi’s post for more details.
SpaceX has decided to acquire Cursor. The goal is to build more useful AI models. A new model is already being trained, and SpaceX says it will be available in Cursor and Grok Build soon. Check SpaceX’s post for more details.
Cartesia has launched Sonic 3.5 and Ink 2 for voice AI. Sonic 3.5 is for text to speech, and Ink 2 is for speech to text. Both are built for real time voice agent use cases. Sonic 3.5 also supports more than 40 languages. Check Cartesia’s launch post for more details.

OSS Highlight of the Week

This week we are featuring Eve, Vercel’s framework for building AI agents. Eve lets developers build agents using normal project files and folders. The agent’s instructions, tools, skills, and schedules are kept in standard folders, so it is easier to understand and update the agent. Check the Vercel Eve page for more details.

Anthropic is suspending access to Fable 5 and Mythos 5 after a US government directive. The directive blocks access for foreign nationals, and Anthropic says it is removing access for all users to comply. Other Anthropic models are not affected. Check Anthropic’s post for more details.
Midjourney has launched Midjourney Medical. This is not about image generation. They are working on Ultrasonic CT, a full body ultrasound scan using sound and water. Midjourney says the scan can take as little as 60 seconds. The first location is planned in San Francisco by the end of 2027. Check Midjourney Medical’s page for more details.
Many AI products and features get launched, changed, deprecated, or shut down over time. Killed by OpenAI is a site that tracks OpenAI products, features, and APIs that were shut down, deprecated, or inactive. It also shows the status and shutdown date for each item. Check the site if you want to track OpenAI product changes.
OpenAI has added Library for files in ChatGPT. Files you upload or create in ChatGPT are saved in Library, so you can find and reuse them later. Library storage is separate from daily chat attachment limits. Check OpenAI’s help page for more details.

Notable FYIs

Zed has opened early access for DeltaDB, a version control system built for agentic coding. It records every small code change between commits, so developers can rewind to any point. It also links each code change with the agent conversation that created it. Check Zed’s DeltaDB page for more details.
OpenRouter has introduced Fusion, a tool to combine outputs from multiple models. It sends the prompt to a group of models and then uses another model to merge the useful responses. OpenRouter says this works better for deep research tasks than calling one model alone. Check OpenRouter’s post for more details.
Cursor has introduced Origin, a new code hosting and collaboration platform. It is built for teams using AI agents to code faster. The waitlist is open now. Check Cursor Origin for more details.
Exa has launched Exa Agent, an API for web research. It can search the web deeply and collect detailed information for a given task. For large tasks, it splits the work into smaller parts and runs subagents in parallel. Check Exa’s post for more details.
Kage is a tool for saving websites as offline copies. It renders the site and saves the final page with CSS, images, and fonts. It removes JavaScript, so the saved site can be opened later without scripts or network calls. Check the GitHub repo for more details.

Thanks for reading Dev Shorts! This post is public so feel free to share it.

[Dev Catch Up # 112] - Claude Fable 5 and Mythos 5, Gemini 3.5 Live Translate, Kimi Work, DiffusionGemma, Apple's Core AI, Harness Engineering, Xiaomi's MiMoCode, Herdr - Agent Multiplexer and more!

Aravind Putrevu — Fri, 12 Jun 2026 12:30:46 GMT

Welcome to the 112th edition of DevShorts, Dev Catch Up.

Thanks for reading Dev Shorts! Subscribe for free to receive new posts and support my work.

Some recent issues from Dev Catch up:

Join 8900+ developers to hear stories from Open source and technology.

Must Read

Anthropic has released Claude Fable 5 and Mythos 5. Fable 5 brings the Mythos model family to general users, but with stricter safeguards. For safety, some sensitive requests are routed to Claude Opus 4.8 instead. Mythos 5 is for trusted users who need more flexibility in areas like cybersecurity. Check Anthropic’s post for more details.
Google has released Gemini 3.5 Live Translate. It is a new audio model for live speech to speech translation. It can detect more than 70 languages and translate speech while keeping the speaker’s tone, pace, and pitch. Check Google’s post for more details.
Kimi has launched Kimi Work, a local desktop AI agent for everyday work. It can connect to your local files and use the browser for tasks. It can also run scheduled tasks and coordinate multiple agents for larger work. Check Kimi’s page for more details.
Google has released DiffusionGemma. It is an experimental open model built for faster text generation. It uses diffusion method, which creates blocks of content at once instead of going token by token. Google says it can run up to 4x faster on dedicated GPUs. Check Google’s post for more details.

OSS Highlight of the Week

This week we are featuring Herdr. It is a terminal based agent multiplexer for running multiple coding agents. You can organize agents in workspaces, tabs, and panes. It also shows whether agents are blocked, working, or done. It supports detach and reattach, so agents can keep running in the background. Check the GitHub repo for more details.

Anthropic has changed how Claude Code billing works after June 15. If you are not sure whether to use Pro, Max, API credits, or Codex, this pricing breakdown is useful. It explains what is still covered by your Claude plan and what now needs separate credits. Check FindSkill’s post for more details.
ChatGPT can now generate charts directly inside the chat. You can ask it to turn data or comparisons into simple visuals. The feature is available now on mobile and web. Check ChatGPT’s post for more details.
If you are trying to learn Agent Harness, this course is a good starting point. It explains why AI coding agents fail and how harnesses make them more reliable. It covers rules, state management, testing, observability, and clean handoffs. Check the Harness Engineering course for more details.
Loop Engineering is becoming popular for AI coding agents. Instead of prompting agents step by step, the idea is to design loops that guide the work for them. These loops can use automations, worktrees, skills, connectors, subagents, and memory. Check Addy’s post for more details.

Notable FYIs

Xiaomi has released MiMoCode, an open source AI coding agent for the terminal. It can read and write code, run commands, manage Git, and keep project memory across sessions. It also supports multiple agents, subagents, MCP, and custom model providers. Check the GitHub repo for more details.
Cohere has released North Mini Code. It is Cohere’s first model built for developers. The open source MoE coding model has 30B total parameters, with 3B active. It is built for agentic software engineering. Check Cohere’s post for more details.
We all use AI tools and know they can consume a lot of tokens. Headroom is a context compression layer for AI agents. It compresses tool outputs, logs, files, and RAG chunks before they reach the LLM. The repo says it can reduce tokens by 60 to 95 percent. Check the GitHub repo for more details.
Cognition has introduced FrontierCode, a new benchmark for coding agents. It checks whether AI generated code is good enough to merge into real production codebases. The benchmark looks beyond correctness and checks tests, scope, style, maintainability, and code quality. Check Cognition’s post for more details.
Apple has introduced Core AI for developers. It lets developers run AI models on Apple silicon. It also includes tools for model preparation, debugging, and inference performance. Check Apple’s documentation for more details.

Thanks for reading Dev Shorts! This post is public so feel free to share it.

[Dev Catch Up # 111] - MAI Models, Hermes Desktop, Gemma 4, Qwen3.7 Plus, MiniMax M3, Claude Code's dynamic workflows, OpenAI models on AWS, Trackio-wandb alternative, Meta Business Agent and more!

Aravind Putrevu — Fri, 05 Jun 2026 13:02:58 GMT

Welcome to the 111th edition of DevShorts, Dev Catch Up.

Thanks for reading Dev Shorts! Subscribe for free to receive new posts and support my work.

Some recent issues from Dev Catch up:

Join 8900+ developers to hear stories from Open source and technology.

Must Read

Microsoft AI has launched seven models. The new family covers reasoning, code, image, transcription, and voice. Among them, MAI Thinking 1 is a reasoning model trained from scratch for STEM reasoning and coding tasks. Check Microsoft’s post for more details.
Hermes Agent now has a native desktop app. It brings Hermes Agent to a simple desktop app, without needing the terminal. Users still get the same agent, memory, and skills. Check the Hermes Desktop page for download details.
Google has released Gemma 4 12B. It is an open weight model built for agentic workflows. It supports text, vision, and native audio inputs. It is laptop ready and can run locally with 16GB memory. Check Google’s post for more details.
NVIDIA has released Nemotron 3 Ultra. It is their most capable Nemotron model so far. It supports up to 1M context and gives better control over reasoning during inference. NVIDIA is also releasing the model checkpoints, training datasets, and recipes. Check NVIDIA’s post for more details.

OSS Highlight of the Week

This week we are featuring Cate. It is an infinite zoomable canvas for coding. You can keep your editor, terminal, browser, docs, and AI agents in one workspace. It helps you work on a project without switching between too many windows. Check the GitHub repo for more details.

Good to know

OpenAI is taking Codex beyond coding. Sites are a new canvas where Codex can turn ideas into dashboards. They also shipped plugins for areas like sales, product design, analytics, and finance. Each plugin brings the needed apps, skills, instructions, and workflows together. Check OpenAI’s Codex post for more details.
Anthropic released Claude Opus 4.8 last week. Whenever an Opus model gets released, expectations are usually high. Opus 4.8 brings better coding performance, effort control, cheaper Fast mode, and parallel subagents in Claude Code. Check Anthropic’s announcement for more details.
Meta has introduced Meta Business Agent. It helps businesses handle customer conversations on WhatsApp, Messenger, and Instagram. It can answer questions, suggest products, and book appointments. It uses AI to give more personalized support to customers. Check Meta’s post for more details.
Cloudflare cofounder Matthew Prince says bot traffic has now crossed human traffic on the internet. He says this happened faster than he expected because agentic traffic is growing quickly. This shows how AI agents are starting to change web traffic. Check the post for more details.
xAI has rolled out Grok Imagine 1.5 Preview. It is the latest image and video generation model from xAI. It supports up to 2K image output, 10 images per request, and videos up to 15 seconds. Check xAI’s Imagine API page for more details.

Notable FYIs

Anthropic released dynamic workflows in Claude Code. Claude can now write its own harness on the fly for complex tasks. Since dynamic workflows may use more tokens, it is better to use them only when needed. Check Anthropic’s blog for example prompts and more details.
Qwen has released Qwen3.7 Plus. It is their latest multimodal agentic model. It is built for agentic tasks like screen understanding, GUI tasks, and browser workflows. It can also navigate mobile apps and complete tasks. Check Qwen’s post for more details.
MiniMax has released MiniMax M3. It is an open weight model built for coding and agentic tasks. It supports image and video input, computer use, and 1M context. MiniMax says it is the first open weight model to bring all these together. Check MiniMax’s M3 post for more details.
NVIDIA has released the open weight Cosmos3 model. It is a collection of world models built for Physical AI. It can be used for robotics, autonomous vehicles, and smart spaces. Check the Hugging Face model card for more details.
Hugging Face has open sourced Trackio. It is a simple alternative to Weights and Biases. You can run it locally and track your experiments without setting up a hosted tool. Check the GitHub repo for more details.
OpenAI models, Codex, and Managed Agents are now available on AWS. AWS customers can use OpenAI models through Amazon Bedrock. This makes it easier for enterprises to use OpenAI inside their existing AWS setup. Check OpenAI’s post for more details.

Thanks for reading Dev Shorts! This post is public so feel free to share it.

Claude Certified Architect Foundations: The Complete Guide - Part 2

Aravind Putrevu — Wed, 20 May 2026 14:37:26 GMT

We started this guide with Part 1. We covered agentic architecture, MCP integration, and Claude Code configuration. If you have not read part 1 yet, start there.

This part covers the remaining domains and how to register for the exam. Here is what we will cover.

Prompt Engineering & Structured Output
Context Management & Reliability
How to register for the exam

I have also added more practice questions to the CCAF GitHub repo. Six sets now, covering all domains.

1. Prompt Engineering & Structured Output

Explicit Criteria
Few-shot Prompting
Structured Output
Validation-Retry Loops
Multi-pass Review
Schema Design

Explicit Criteria

We have to give exact instructions to Claude instead of vague conditions. This is called explicit criteria. Telling Claude like “be careful” or “report high security issues” does not work. Claude does not know what that means in practice.

Tell Claude exactly what to do and what not to do. When you are more specific, Claude makes fewer mistakes.

# Bad — vague, 
system_prompt = """
Review this code and flag any security issues.
Only report high confidence findings.
"""

# Good — categorical, Claude knows exactly what to flag
system_prompt = """
Review this code for security issues.
Flag a finding ONLY when:
- User input is passed directly to a SQL query without parameterization
- A secret or API key is hardcoded as a string literal
- User-supplied data is rendered in HTML without escaping

Do not flag theoretical risks or best practice suggestions.
"""

Few-shot Prompting

Give Claude examples before asking it to do the task. This is called few-shot prompting. Two to four examples is enough. More than that wastes tokens.

One thing to keep in mind. Few-shot prompting is probabilistic. Claude will follow the examples most of the time but not always. If you want something to run without fail, put it in a hook.

system_prompt = """
Extract the customer name and order ID from the message below.

Example 1:
Message: "Hi, I am John and my order 1234 has not arrived."
Output: {"name": "John", "order_id": "1234"}

Example 2:
Message: "This is Sarah. Order #5678 is damaged."
Output: {"name": "Sarah", "order_id": "5678"}

Now extract from this message:
"""

Structured Output

If you ask Claude to “output as JSON” in the prompt, it will try. But it is not guaranteed. The reliable way is to use structured outputs.

Method 1 — JSON outputs

Define the schema in output_config of the client.messages.create() call.
Claude returns the answer as JSON text in response.content[0].text.
Parse it with json.loads() to get the data.

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Extract order details from: John's order 1234 is missing"}],
    output_config={ # tells Claude to return structured JSON
        "format": {
            "type": "json_schema",
            "schema": {
                "type": "object",
                "properties": {
                    "customer_name": {"type": "string"},
                    "order_id": {"type": "string"},
                    "issue": {"type": "string"}
                },
                "required": ["customer_name", "order_id", "issue"]
            }
        }
    }
)
# Claude returns guaranteed JSON in content[0].text
result = json.loads(response.content[0].text)
# {"customer_name": "John", "order_id": "1234", "issue": "missing"}

Method 2 — Strict tool use

This method is used to pass structured input to your tools with guaranteed schema compliance.

When Claude calls a tool in an agentic workflow, it passes parameters to that tool. Without strict mode, those parameters may not match your schema exactly. With strict: True on the tool definition, Claude is forced to pass parameters that exactly match your input_schema. The structured data Claude fills in is available in block.input on the tool call response.

tools = [{
    "name": "extract_order",
    "description": "Extract order details",
    "strict": True,          # Claude must fill in all fields exactly as defined
    "input_schema": {
        "type": "object",
        "properties": {
            "customer_name": {"type": "string"},
            "order_id": {"type": "string"},
            "issue": {"type": "string"}
        },
        "required": ["customer_name", "order_id", "issue"]
    }
}]

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    tools=tools,
    tool_choice={"type": "tool", "name": "extract_order"},  # force Claude to call this tool
    messages=[{"role": "user", "content": "John's order 1234 is missing"}]
)

for block in response.content:
    if block.type == "tool_use":
        print(block.input)   # structured data Claude filled in
        # {"customer_name": "John", "order_id": "1234", "issue": "missing"}

Validation-Retry Loops

Structured output guarantees the structure. It does not guarantee the values are correct. This is where the validation-retry loop comes in. When Claude returns wrong values, you send the error back with specific details about what went wrong. Claude fixes it and tries again.


MAX_RETRIES = 3
for attempt in range(MAX_RETRIES):
    response = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=1024,
        tools=tools,
        tool_choice={"type": "tool", "name": "extract_order"},
        messages=messages
    )

    for block in response.content:
        if block.type == "tool_use":
            result = block.input

            # Validate the result
            if not result.get("order_id").startswith("ORD-"):
                # Send specific error back — not a generic "try again"
                messages.append({"role": "assistant", "content": response.content})
                messages.append({"role": "user", "content": [{
                    "type": "tool_result",
                    "tool_use_id": block.id,
                    "content": "order_id must start with ORD-. You returned: " + result["order_id"]
                }]})
                break  # go to next attempt

            return result  # valid — done

raise RuntimeError("Failed to get valid output after max retries")

Always send specific error details. Tell Claude which field failed and what you expected. A generic "try again" does not give Claude enough context to fix the issue.

Retry loops fix format errors. But if the data is simply not there in the source, retrying will not help. Claude cannot return something that does not exist.

Multi-pass Review

When Claude generates something and then reviews it in the same session, it already knows how it was built. It will miss its own mistakes. That is the problem with self-review.

Multi-pass review fixes this. You use a separate Claude session to review the output. The reviewer session has no memory of how the output was generated. It looks at the result with fresh eyes.

# Pass 1 — generate the code
generation_response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=2048,
    messages=[{"role": "user", "content": "Write a FastAPI endpoint for processing refunds"}]
)
generated_code = generation_response.content[0].text

# Pass 2 — review in a separate session
review_response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[{"role": "user", "content": f"Review this code for security vulnerabilities:\n\n{generated_code}"}]
)

Never use the same session for generation and review. Always use a separate session.

Schema Design

When you define a JSON schema for structured output, each field tells Claude what to extract and in what format. One of those fields can be an enum. It is a fixed list of allowed values. For example, if you have an issue field you can restrict it to "missing", "damaged", or "wrong_item", you define it as an enum. Claude can only pick from that list.

Three things to know in Schema Design:

Enums - always add "other" to the list. If Claude sees something that does not fit any of the defined values, it will pick the closest one instead of telling you it does not know. With "other" in the list, Claude has a safe option to fall back to.

Nullable fields — if a field may not always be present, use ["string", "null"] instead of "string". Never mark optional fields as required. Claude will make up a value just to fill it.

Flat structures — avoid deeply nested objects in your schema. Deep nesting makes it harder for Claude to fill the schema accurately. Keep your schema flat. If the data is complex, split it across multiple tool calls.

tools = [{
    "name": "extract_order",
    "description": """Extract order details. Issue must be one of: missing, damaged, wrong_item, other.
    Use other when the issue does not fit the above categories.""",
    "strict": True,  # Claude must follow the schema exactly
    "input_schema": {
        "type": "object",
        "additionalProperties": False,  # no extra fields allowed
        "properties": {
            "customer_name": {"type": "string"},
            "order_id": {"type": "string"},
            # issue must be a string 
            # issue can only be one of these four values — always include "other" in enum.
            "issue": {
                "type": "string",
                "enum": ["missing", "damaged", "wrong_item", "other"]
            },
            # fill this when issue is "other" — gives Claude somewhere to put unexpected values
            "issue_detail": {"type": "string"},
            # nullable — Claude returns null when delivery date is not mentioned in the source
            "delivery_date": {"type": ["string", "null"]}
        },
        # only these fields are required — issue_detail and delivery_date are optional
        "required": ["customer_name", "order_id", "issue"]
    }
}]

2. Context Management & Reliability

This domain carries 15% of your exam score. It is the smallest domain. But it matters. If you do not manage context well, your agents become unreliable in production.

Below are the key concepts.

Lost-in-the-Middle Effect
Progressive Summarization
Tool Result Trimming
Escalation and Ambiguity
Error Propagation
Prompt Caching
Message Batches API

Lost-in-the-Middle Effect

Claude can process up to 1 million tokens in a single request. But more context does not always mean better results.

When you pass a long input, Claude processes the beginning and end reliably. What is in the middle often gets missed. This is called the lost-in-the-middle effect.

Two things to know

Place critical information at the beginning or end. Never place it in the middle.
For large context tasks, delegate to subagents. Each subagent starts fresh with only what it needs.

Progressive Summarization

As an agent runs through multiple turns, the conversation history keeps growing. At some point it gets too large to pass in full on every API call.

Progressive summarization solves this. Instead of passing everything, you summarize the older turns and keep only the recent ones in full. The summary replaces the old turns in the messages array.

# When history gets too long, summarize older turns
summary_response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[{
        "role": "user",
        "content": f"Summarize this conversation history into key facts only:\n\n{old_turns}"
    }]
)

summary = summary_response.content[0].text

# Replace old turns with the summary
messages = [
    {"role": "user", "content": f"Previous context: {summary}"},
    *recent_turns  # keep the last few turns in full
]

When we summarize, we may lose details. Dates, percentages, and numeric values often become vague. If you want anything to stay precise, extract it into a structured state object before summarizing.

Tool Result Trimming

Every tool call adds output to the context. If a tool returns 40 fields but you only need 5, the remaining 35 are wasting tokens. Over multiple turns this adds up fast and fills your context with noise.

Trim tool results before appending them to the next API messages array. Always keep your context clean. Pass only what Claude needs. Learn more about managing tool context here.

# Bad — full tool result, 40+ fields appended to messages
result = get_customer(customer_id="C-42")
messages.append({
    "role": "user",
    "content": [{
        "type": "tool_result",
        "tool_use_id": block.id,
        "content": json.dumps(result)
    }]
})

# Good — trim before appending, only what Claude needs
result = get_customer(customer_id="C-42")
trimmed = {
    "id": result["id"],
    "name": result["name"],
    "status": result["status"]
}
messages.append({
    "role": "user",
    "content": [{
        "type": "tool_result",
        "tool_use_id": block.id,
        "content": json.dumps(trimmed)
    }]
})

Escalation and Ambiguity

Not every task should be handled autonomously. Knowing when to escalate to a human is just as important as knowing how to complete a task.

Three valid reasons to escalate:

When the user explicitly requests a human, escalate immediately. Do not attempt to investigate first.
When the agent does not have clear instructions for the situation, escalate. Do not guess.
When the agent cannot make meaningful progress, escalate.

When a tool returns multiple matching results, ask the user for more details to narrow it down. Never pick one based on a guess.

# Tool returns escalation signal
@mcp.tool()
def process_refund(order_id: str, amount: float) -> dict:
    if amount > 500:
        return {"requires_human": True, "reason": "Refund above $500 needs approval"}
    return {"success": True, "refund_id": "REF-001"}

# Agent loop checks for it
result = tool_map[block.name](**block.input)

if result.get("requires_human"):
    escalate_to_human(result)
    return

Two common mistakes to avoid.

Do not escalate just because the user seems frustrated. Frustration does not mean the task needs human intervention. Acknowledge it, try to resolve it, and only escalate if the user explicitly asks for a human.

Do not use the agent’s own confidence score as an escalation signal. Models tend to be overconfident even when they are wrong. It is not reliable.

Error Propagation

In a multi-agent system, when a subagent fails, the coordinator needs to know what went wrong. If the subagent returns a generic error, the coordinator cannot decide what to do next.

Subagents should always return structured error context. Not a generic failure status.

# Bad — coordinator has no idea what went wrong
return {"error": True}

# Good — coordinator knows what failed and what to do next
return {
    "error": True,
    "type": "tool_failure",
    "tool": "lookup_order",
    "reason": "Order not found in database",
    "retryable": False
}

Never suppress errors silently. If a subagent fails without sending a signal, the coordinator assumes success and moves on. That produces wrong results in the next steps.

Not all errors are the same. A timeout can be retried. A missing record cannot be retried. Tell the coordinator what went wrong so it can decide what to do.

Also remember, subagents do not share context automatically. If one fails, the coordinator has to pass that information forward explicitly.

Prompt Caching

Every time you call the Claude API, you send the full context. You send system prompt, conversation history, tool definitions. Claude processes all of it from scratch on every single call. That adds up fast. It becomes more tokens with higher cost.

With prompt caching we can reduce the cost. You mark the static parts of your prompt with cache_control. Claude caches them on the first call. Instead of paying full price on every call, you pay only 10% for the tokens that are already cached.

There are two ways to enable it.

Automatic caching - You just add cache_control at the top level of your request. Claude scans your prompt from top to bottom and places the cache breakpoint at the end of the last block that can be cached, which is typically the end of your system prompt or tool definitions.

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    cache_control={"type": "ephemeral"},  # automatic — Claude picks the breakpoint
    system="You are a customer support agent.................  ",
    messages=[{"role": "user", "content": user_query}]
)

Explicit caching - you mark specific content blocks with cache_control directly inside the system array. Claude caches everything before and up to that block. Use this when you want to control exactly where the cache ends.

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    system=[
        {"type": "text", "text": "You are a customer support agent."},
        {
            "type": "text",
            "text": large_document,
            "cache_control": {"type": "ephemeral"}  # cache everything up to here
        }
    ],
    messages=[{"role": "user", "content": user_query}]
)

Always cache static content only. You can put system prompts, tool definitions, and large documents in cache. Never put dynamic content in cache.

Every API call checks whether the cached prefix matches exactly. Even a single character difference causes a cache miss and Claude reprocesses everything from scratch.

TTL and pricing

TTL stands for Time to Live. It is how long the cache stays active. By default the cache expires after 5 minutes. Every cache hit resets the timer. If your requests come in less frequently, you can extend the TTL to 1 hour at 2x the cache write price.

The first call writes to cache and costs 1.25x normal input tokens.
Cache read costs 0.1x normal input tokens.
You can place a maximum of 4 cache_control breakpoints in a single request.
If you use the Batch API and prompt caching together, both discounts apply.
The first call costs more because it writes to cache. From the 4th read onwards you start saving money.

To check if caching is working, look at the response usage.

print(response.usage.cache_read_input_tokens)     # tokens read from cache
print(response.usage.cache_creation_input_tokens)  # tokens written to cache

If cache_read_input_tokens is greater than 0, the cache was hit.

Message Batches API

When you need to process a large number of API requests without needing an immediate response, use the Message Batches API. For example, processing thousands of customer feedback forms overnight, or doing bulk content generation.

You can submit up to 100,000 requests in one batch. Claude processes them asynchronously. Most batches finish within 1 hour, but they can run up to 24 hours. If they do not complete within 24 hours, they expire.

The cost is 50% off standard API pricing. The output quality is the same. Only the timing is different.

import anthropic
import time

client = anthropic.Anthropic()

# Create a batch with multiple independent requests
batch = client.messages.batches.create(
    requests=[
        {
            # This custom id will be returned with the result, 
            # so we know this output is for feedback_001
            "custom_id": "feedback_001",
            "params": {
                "model": "claude-sonnet-4-6",
                "max_tokens": 500,
                "system": "You are a support analyst. Summarize customer feedback in 2 short bullet points.",
                "messages": [
                    {
                        "role": "user",
                        "content": "The app is useful, but the login takes too much time."
                    }]
            }},
        {
            # This custom id will be returned with the result
            # so we know this output is for feedback_002
            "custom_id": "feedback_002",
            "params": {
                "model": "claude-sonnet-4-6",
                "max_tokens": 500,
                "system": "You are a support analyst. Summarize customer feedback in 2 short bullet points.",
                "messages": [
                    {
                        "role": "user",
                        "content": "The dashboard is clean, but export to PDF is missing."
                    }]
            }}
    ])

print(f"Batch ID: {batch.id}")

# Wait until the batch completes
while True:
    current_batch = client.messages.batches.retrieve(batch.id)

    if current_batch.processing_status == "ended":
        break

    time.sleep(30)

# Read the results
for result in client.messages.batches.results(batch.id):
    if result.result.type == "succeeded":
        print(f"{result.custom_id}: {result.result.message.content[0].text}")

    elif result.result.type == "errored":
        print(f"Error in {result.custom_id}: {result.result.error}")

    elif result.result.type == "canceled":
        print(f"Canceled: {result.custom_id}")

    elif result.result.type == "expired":
        print(f"Expired: {result.custom_id}")

Three things to know.

Use custom_id to tie each result back to your input. Without it you cannot match results to requests.
You can combine the Batch API with prompt caching. Both discounts apply together, so if your requests share the same system prompt, use both for maximum savings.
Use the Batch API for async workloads only. If you need a real-time response, use the standard Messages API.

3. How to Register for the exam

The exam is currently available to employees of companies in the Anthropic Partner Network. The Partner Network is free to join. Any company building with Claude qualifies for it.

Step 1 — Join the Partner Network

Your company needs to be part of the Anthropic Partner Network. If you are not in the partner network then apply for Claude Partner Network.

Step 2 — Request exam access

If you are already in the partner network, then login to the network and take up the exam.

Step 3 — About exam

60 questions. 120 minutes. No notes, no AI tools, no external resources are allowed.

Free prep resources

Free resources are available on Anthropic Academy and open to everyone. Start there regardless of whether you have exam access yet.

Certificate validity

The certificate is valid for 6 months. After that you need to recertify.

Conclusion

I hope this gave you a clear picture of what the exam covers. We went through all the domains across both parts.

I have also added 6 sets of practice questions to the GitHub repo.

These concepts are not just for the exam. Knowing them well will make you a better engineer when building with Claude.

Happy Learning!

Thanks for reading Dev Shorts! This post is public so feel free to share it.

[Dev Catch Up # 110] - Google's AI Pointer, Access Codex from Phone, OpenClaw’s Peekaboo,TM's interactive models, Flue- Agent Harness,CodeBurn, Mirage, Claude Code's goal,Google's Agent Skills & more!

Aravind Putrevu — Fri, 15 May 2026 13:16:32 GMT

Welcome to the 110th edition of DevShorts, Dev Catch Up.

Thanks for reading Dev Shorts! Subscribe for free to receive new posts and support my work.

Some recent issues from Dev Catch up:

Join 8800+ developers to hear stories from Open source and technology.

Must Read

Google DeepMind has introduced AI Pointer. You can point to something on your screen and ask Gemini to act on it. It understands what you are pointing at, so you don’t need long prompts. It also supports voice, text, and images. Check Google DeepMind’s post for more details.
OpenAI has brought Codex to the ChatGPT mobile app. You can track tasks, review outputs, and guide Codex from your phone. Your files and credentials stay on the machine where Codex is running, while updates come to your phone in real time. Check OpenAI’s post for more details.
OpenClaw’s Peekaboo is worth checking if you are exploring screen based agents. It helps AI agents capture screens, understand what is on them, and automate GUI actions. It works as both a CLI and MCP server for Codex, Claude Code, and Cursor. Check the Peekaboo GitHub repo for more details.
Thinking Machines Lab has introduced interaction models. The idea is to make AI conversations feel more natural and live. The interesting part is the architecture. One model stays responsive during the live conversation, while a background model handles reasoning, search, and tool use. Check Thinking Machines Lab’s post for more details.

OSS Highlight of the Week

This week we are featuring Flue. It is an agent harness framework for building headless and programmable agents. Think of it like Claude Code, but without the terminal UI or human operator. It supports sandboxes, sessions, skills, MCP tools, and deployment across runtimes. Check the Flue GitHub repo for more details.

Claude Code now supports /goal. You can give a task with a clear goal. Claude will keep working until that goal is done. A small evaluator model checks the progress after each turn. Check Claude Code docs for more details.
Claude Platform is now available directly on AWS. AWS customers can now use more Claude capabilities, beyond Bedrock models. It includes Claude Managed Agents, code execution, web search, Skills, MCP, and more. Check Claude’s post for more details.
OpenAI has introduced Daybreak for cybersecurity. It brings GPT 5.5 and Codex Security into security workflows. It helps teams review code, find risks, validate patches, and fix issues faster. The goal is to bring AI earlier into secure software development. Check OpenAI’s Daybreak page for details.
I came across Thariq’s post on using HTML instead of Markdown for agent outputs. Markdown works well for simple notes, but large outputs can become hard to read. HTML can show the same content with better visuals and richer information. His collection has 20 HTML examples generated by agents. Check the post and collection for more details.

Notable FYIs

Google has released Agent Skills for Google products. It includes skills for BigQuery, Cloud Run, Firebase, GKE, and more. It also covers Google Cloud onboarding, authentication, and network observability. Check the Google Skills GitHub repo for more details.
If you are using AI coding agents and want to know where your tokens are going, check CodeBurn. It shows usage across Claude Code, Codex, and Cursor. It also breaks usage down by task, tool, model, and project. You also get an interactive terminal dashboard for cost visibility. Check the CodeBurn GitHub repo for more details.
xAI has released Grok Build. It is a coding agent that runs from the terminal. It comes with familiar coding agent features like plans, skills, plugins, hooks, and parallel subagents. Check xAI’s Grok Build page for more details.
Claude Code now has Agent View. It helps you manage many Claude Code sessions from one place. You can see which agents need input, which are still working, and which are done. It is useful if you run multiple coding agents in parallel. Check Claude’s blog for more details.
Mirage is a virtual filesystem for AI agents. It gives agents one common way to access tools like S3, Google Drive, Slack, Gmail, and more. Agents can use simple file commands instead of separate APIs. Check the Mirage GitHub repo for more details.
Higgsfield has released Supercomputer. It is an AI agent for creating ads, product shots, marketing content, and campaigns. You can describe what you want, and it picks the right model for the task and gets the work done. Check Higgsfield’s post for more details.

Thanks for reading Dev Shorts! This post is public so feel free to share it.

[Dev Catch Up # 109] - Anthropic SpaceX Deal, GPT 5.5 Instant, Anthropic and Perplexity Finance Agents, Deepsec, SubQ-12M Context Model, How to Work and Compound with AI, PaperCopilot and much more!

Aravind Putrevu — Fri, 08 May 2026 12:46:17 GMT

Welcome to the 109th edition of DevShorts, Dev Catch Up.

Thanks for reading Dev Shorts! Subscribe for free to receive new posts and support my work.

Some recent issues from Dev Catch up:

Join 8800+ developers to hear stories from Open source and technology.

Must Read

Anthropic has signed a compute deal with SpaceX. This will increase Claude’s compute capacity. Because of this, Claude Code’s five hour limits are now doubled for paid tiers. Peak hour limit reductions are also removed. Check Anthropic’s announcement for more details.
OpenAI has released GPT 5.5 Instant as ChatGPT’s new default model. It is also available in the API. OpenAI says it gives smarter, more accurate, and clearer answers based on your context. Check OpenAI’s announcement for more details.
We have already seen models with 1M context windows. But SubQ has introduced a model built for 12M token reasoning. It is designed to work across full repos and long context tasks. SubQ says it runs at one fifth the cost of leading LLMs. Check SubQ’s post to know how this model works.
Claude and Perplexity are moving deeper into finance workflows. Claude has introduced finance agent templates. Perplexity has launched Perplexity Computer for Finance. Both show how AI tools are moving from general chat to specific business work. Check their posts for more details.

OSS Highlight of the Week

This week we are featuring Deepsec. It is an open source security harness from Vercel Labs. It uses coding agents to find vulnerabilities in your codebase. It can scan large repos, investigate issues, and generate findings with recommendations. Check the GitHub repo if you want to try agent based security scanning.

Good to know

Eugene Yan has written a practical post on working better with AI. He talks about giving better context, saving your preferences into config, and making output verification easier. Useful if you use AI for writing, coding, or daily work. Check Eugene’s post for more details.
Paper Copilot is a useful site for AI and ML papers. It brings papers from different conferences into one place and makes them easier to explore. Useful if you want to track new research without jumping across many sites. Check Paper Copilot for more details.
Editframe has launched Agent Skills for video. This skill helps coding agents create videos from simple prompts. You can use it with Claude Code, Cursor, or Codex. It can generate a working video or a full interactive GUI from your prompt. Check the Editframe post for more details.
Inworld has released Realtime TTS 2. It is built for realtime voice conversations. It understands the full audio context, including tone, pacing, and emotional state. Check Inworld’s post for more details.
SpAItial has released Echo 2 for 3D world generation. It can take text or image input and create a 3D world that can be explored in real time. This can be useful for games, digital twins, architecture, and robotics simulation. Check SpAItial’s post for more details.

Notable FYIs

OpenAI has released three new audio models in the API. GPT Realtime 2 brings GPT 5 class reasoning to voice apps. GPT Realtime Translate supports live speech translation, and GPT Realtime Whisper supports live transcription as someone speaks. Check OpenAI’s announcement for more details.
Last time we covered Claude Managed Agents. Now Anthropic has added more features to Claude Managed Agents. It includes dreaming, outcomes, webhooks, and multiagent orchestration. Dreaming reviews past work and improves memory over time. Outcomes checks whether the work meets the expected result. Check Anthropic’s announcement for more details.
xAI has introduced Custom Voices and Voice Library for Grok. Developers can create their own voice and use it in Grok’s TTS and Voice Agent APIs. Teams can also browse, preview, and manage voices from the xAI console. Check xAI’s announcement for more details.
Xiaomi has open sourced MiMo V2.5 Pro. It is built for agentic coding, long horizon tasks, and large context work. Xiaomi says it can handle complex workflows with many tool calls and a 1M token context window. Check Xiaomi’s post for more details.
Anthropic has released Claude Security for Claude Enterprise customers. It scans code for vulnerabilities and uses Opus 4.7 to generate proposed fixes. It also supports scheduled scans, targeted scans, triage tracking, and exports for audit workflows. Check Claude’s announcement for more details.

Thanks for reading Dev Shorts! This post is public so feel free to share it.

Claude Certified Architect Foundations: The Complete Guide - Part 1

Aravind Putrevu — Thu, 30 Apr 2026 12:31:48 GMT

The Claude Certified Architect Foundations exam was recently launched. It is Anthropic’s first official technical certification.

I have been building agentic systems with Claude for a long time. When I heard about the exam, I wanted to understand what it actually tests.

So I went through the entire exam guide, also took some mock tests to understand what they covered.

Below are the sections you need to understand to become a Claude Certified Architect.

Agentic Architecture & Orchestration
Tool Design & MCP Integration
Claude Code Configuration
Prompt Engineering & Structured Output
Context & Reliability

Each section is detailed enough to be its own blog. We will cover the first three in this part. The remaining sections along with how to register will be in Part 2.

I have also put together a set of practice questions with answers on GitHub. I will keep adding more as I come across them.

1. Agentic Architecture & Orchestration

This section carries 27% of your exam score. It covers Claude Agent SDK, the library you use to build production grade agents. Below are the key Agent SDK concepts, that turn a normal LLM into an agent.

stop_reason
Conversation History
Loop Termination
Multi-Agent Systems
Task Decomposition
Hooks
Session Management

A normal LLM call is simple. You send a message, Claude replies, done. An agent is different. It is multiple LLM calls chained together until the task is fully complete. It includes tool calling, getting results, and deciding what to do next.

Let us start with stop_reason. It is the core of every agent loop.

stop_reason

Every Claude API response has a field called stop_reason. It tells you why Claude stopped. This is what decides whether your loop continues or ends. stop_reason has multiple values. The three you need to know for the exam are,

If stop_reason == "tool_use" then it means Claude wants to call a tool. Then you execute the tool, append the result, and loop again.

If stop_reason == "end_turn" then Claude is done. We can return the response to the user. Loop ends.

If stop_reason == "max_tokens" then the response got cut off. This happens when Claude hits the max_tokens limit you set in the API call.

If the response genuinely needs more tokens, increase max_tokens. If the response is too verbose, then restructure your prompt to produce a shorter output. Never return a cut-off response as it is incomplete.

Here is the stop_reason with all three options, explained in code.

import anthropic
import json

client = anthropic.Anthropic()

class Agent:
    def __init__(self, tools):
        self.tools = tools

    def run(self, task: str) -> str:
        # Every conversation starts with the user task
        messages = [{"role": "user", "content": task}]

        while True:
            # Claude does not remember previous call, 
            # So we pass the full conversation history every time
            response = client.messages.create(
                model="claude-sonnet-4-6",
                max_tokens=1024,
                tools=self.tools,
                messages=messages
            )

            # Check the stop_reason to ensure the Task is complete
            if response.stop_reason == "end_turn":
                return extract_text(response.content)
            
            # If stop_reason is tool_use then execute the tool
            elif response.stop_reason == "tool_use":

                # Step 1 — save what Claude said, including which tool it wants to call
                messages.append({
                    "role": "assistant",
                    "content": response.content
                })

                for block in response.content:
                    if block.type == "tool_use":

                        # Step 2 — we execute the tool, not Claude
                        result = tool_map[block.name](**block.input)

                        # Step 3 — send the tool result back so Claude can continue
                        # tool_use_id tells Claude which tool call this result belongs to
                        messages.append({
                            "role": "user",
                            "content": [{
                                "type": "tool_result",
                                "tool_use_id": block.id,
                                "content": json.dumps(result)
                            }]
                        })
                # Claude now sees the result and decides what to do next

            else:
                # stop_reason == "max_tokens" — response was cut off, never return incomplete results
                raise RuntimeError(f"Unexpected: {response.stop_reason}")

The loop runs until Claude returns end_turn.

Handling stop_reason is one of the most important concepts in agentic workflows. Learn more in the official docs.

Now that you understand stop_reason, let us look at how Claude keeps track of everything that happens in the loop.

Conversation History

In agentic workflows, Claude has no memory between API calls. Every time you call the API, you have to pass the full conversation history. That is how Claude knows what happened before.

The messages array holds that history. User messages, Claude responses, and tool results all get appended here until the task is done.

So how does the messages array grow? Every time stop_reason == "tool_use", you append two things.

First, you append the response Claude just sent. This contains the tool name Claude wants to call and the input values it decided to pass.

messages.append({
    "role": "assistant",
    "content": response.content    # text block + tool_use block
})

Then you execute the tool and append the result back. The tool_use_id in the result must match the one from the response we appended previously. This tells Claude that this result is for the tool call it requested.

Now you loop again. Claude reads everything in the messages array and decides what to do next.

for block in response.content:
    if block.type == "tool_use":
        result = tool_map[block.name](**block.input)

        messages.append({
            "role": "user",
            "content": [{
                "type": "tool_result",
                "tool_use_id": block.id,
                "content": json.dumps(result)
            }]
        })

Do not add text immediately after tool results. Send tool results directly without additional text

Loop Termination

An agent loop can terminate for different reasons. We need to identify each termination reason and handle it. If we do not, the agent either runs forever, returns incomplete results, or takes actions it should not.

Here are the three ways we handle it.

stop_reason == "end_turn" - Claude is done. Return the response to the user and exit the loop.
result.get("requires_human") == True - escalate to a human and exit the loop.
MAX_ITERATIONS = 10 - the loop hit the safety cap. Raise an error and exit.

In all three cases, we handle the termination and never return incomplete results. Here is how all three work together in code.

MAX_ITERATIONS = 10

def escalate_to_human(result: dict) -> None:
    # Notify your human review system — ticket, Slack, email etc.
    print(f"Escalating to human: {result}")

def extract_text(content) -> str:
    # Extract the text block from Claude's response
    for block in content:
        if hasattr(block, "text"):
            return block.text

class Agent:
    def __init__(self, tools):
        self.tools = tools

    def run(self, task: str) -> str:
        # Every conversation starts with the user task
        messages = [{"role": "user", "content": task}]

        for i in range(MAX_ITERATIONS):
            # Claude does not remember previous calls
            # So we pass the full conversation history every time
            response = client.messages.create(
                model="claude-sonnet-4-6",
                max_tokens=1024,
                tools=self.tools,
                messages=messages
            )

            # Claude is done — return the response to the user
            if response.stop_reason == "end_turn":
                return extract_text(response.content)

            elif response.stop_reason == "tool_use":
                # Append Claude's response to history
                messages.append({
                    "role": "assistant",
                    "content": response.content
                })

                for block in response.content:
                    if block.type == "tool_use":
                        # we execute the tool
                        result = tool_map[block.name](**block.input)

                        # Tool requires human intervention — escalate and exit the loop
                        if result.get("requires_human"):
                            escalate_to_human(result)
                            return

                        # Append tool result so Claude can continue
                        messages.append({
                            "role": "user",
                            "content": [{
                                "type": "tool_result",
                                "tool_use_id": block.id,
                                "content": json.dumps(result)
                            }]
                        })

        # Max iterations reached — exit with error, never return incomplete results
        raise RuntimeError("Agent hit max iterations without completing")

Multi-Agent Systems

You now know how a single agent works. But some tasks are too complex for one agent to handle alone.

That is where multi-agent systems come in. You break the work across multiple specialized agents. Each one is the same Agent class we defined in the previous sections, just with different tools and a different responsibility.

search_agent = Agent(tools=[web_search_tool])
analysis_agent = Agent(tools=[analysis_tool])
report_agent = Agent(tools=[report_tool])

Anthropic uses a pattern called hub-and-spoke to coordinate agents. Think of it like this. One coordinator receives the task, breaks it down, and delegates to specialized agents. Each agent does its part and reports back. The coordinator collects everything and produces the final response.

Now, when do you run agents in parallel and when in sequence?

If the tasks are independent, run them in parallel. If one task needs the output of another, run them in sequence.

import asyncio

# Step 1 — Independent subagents, run in parallel
search_result, document_result = await asyncio.gather(
    search_agent.run("Search web for competitors"),
    analysis_agent.run("Analyze our internal documents")
)

# Step 2 — This subagent depends on Step 1, runs after
report_result = report_agent.run("Generate report", search_result, document_result)

# Step 3 — Coordinator collects all results and produces the final response
final_result = coordinator_agent.run("Finalize", search_result, document_result, report_result)

Every subagent starts with a fresh context. It does not have access to the coordinator's conversation history. The only way to pass context to a subagent is through its prompt. So be specific and detailed in what you pass.

# Too vague — subagent does not know enough to do its job well
search_agent.run("Search web for competitors.")

# Right — give the subagent exactly what it needs
search_agent.run("Search web for competitors in the B2B SaaS space. Focus on pricing and features.")

Agents never talk directly to the user. They always report back to the coordinator. The coordinator owns the task from start to finish.

Task Decomposition

Task decomposition is an important part of building multi-agent systems. When you build one, remember that your coordinator agent should never delegate a vague task directly to a subagent.

Take this for example. Your coordinator receives “Research the competitive landscape for our project management tool.” If it passes this directly to a subagent, the subagent does not know where to start. You will get different results every run.

Break it down first.

Search Google for “Notion vs Linear pricing plans 2026”
Extract pricing tiers, feature limits, and target user segments for both
Generate a comparison table showing where your product has an advantage

Each subtask goes to one specialized agent. Each agent has one job and knows exactly what to return.

The agents are not the problem. Vague instructions are.

Hooks

When you build an agent, some actions need to be controlled programmatically. You cannot rely on Claude to always follow prompt instructions. That is where hooks come in.

Hooks are callback functions you register in the Claude Agent SDK. They fire automatically at specific points during agent execution. No prompts involved.

Two hooks you need to know for the exam,

PreToolUse :

It fires before a tool executes. Since it runs before, it can block the action. Use it when you want to stop Claude from doing something like blocking rm -rf commands, preventing writes to .env, or requiring human approval before processing a refund above $500.

PostToolUse :

PostToolUse fires after a tool executes. It cannot block anything since the action already happened. Use it for things like auto-formatting a file after Claude edits it, writing to an audit log after a deletion, or running a linter after every code change.

Here is a real example. Your agent has a process_refund tool. Any refund above $500 needs human approval before it goes through.

from claude_agent_sdk import ClaudeAgentOptions, ClaudeSDKClient, HookMatcher

async def block_large_refunds(input_data, tool_use_id, context):
    tool_name = input_data["tool_name"]
    tool_input = input_data["tool_input"]

    # Only intercept the process_refund tool
    if tool_name != "process_refund":
        return {}  # allow all other tools to proceed

    # Block refunds above $500 — requires human approval
    if tool_input.get("amount", 0) > 500:
        return {
            "hookSpecificOutput": {
                "hookEventName": input_data["hook_event_name"],
                # deny stops the tool from executing
                "permissionDecision": "deny",
                # this reason is sent back to Claude so it knows why it was blocked
                "permissionDecisionReason": "Refunds above $500 require human approval"
            }
        }

    # Allow refunds under $500 to proceed normally
    return {}

options = ClaudeAgentOptions(
    hooks={
        # PreToolUse fires before the tool executes
        "PreToolUse": [
            # matcher tells the SDK which tool to intercept
            HookMatcher(matcher="process_refund", hooks=[block_large_refunds])
        ]
    }
)

async with ClaudeSDKClient(options=options) as client:
    await client.query("Process a $600 refund for order ORD-999")
    async for message in client.receive_response():
        print(message)

The key difference between hooks and prompt instructions is reliability. A prompt instruction like “never process refunds above $500” is not guaranteed. Claude may follow it or not. A hook always fires. If you want something enforced without exception, put it in a hook.

Session Management

A session contains the full conversation history. The SDK saves it to disk automatically so you can come back to it later.

Here is what you need to know.

Session Resumption
Session Isolation
Session Forking

Session Resumption

Imagine your agent is halfway through a long task and the server crashes. Without session resumption, it starts from scratch. With it, you pass the session ID and the agent continues from where it stopped.

Here is how you implement it.

from claude_agent_sdk import ClaudeAgentOptions, query, ResultMessage

# Start a session and save the session ID
session_id = None
async for message in query("Analyze the refund flow in our codebase"):
    if isinstance(message, ResultMessage):
        session_id = message.session_id

# Resume later — agent has full context from before
async for message in query(
    prompt="Now fix the bug you found",
    options=ClaudeAgentOptions(
        resume=session_id,
        allowed_tools=["Read", "Edit", "Write", "Glob", "Grep"],
    ),
):
    if isinstance(message, ResultMessage) and message.subtype == "success":
        print(message.result)

Session Isolation

Each user or task gets its own session. If two users share the same session, Claude will mix up their context and produce wrong results. Always create a new session for each user or task.

Session Forking

Sometimes you want to try a different approach from where you are, without affecting your current session. For example, your agent has analyzed a codebase and you want to try both a REST and a GraphQL implementation. Instead of starting over, you fork the session. Both forks start from the same point. The original stays untouched.

from claude_agent_sdk import ClaudeAgentOptions, query

# Fork — original session stays unchanged
options = ClaudeAgentOptions(
    resume=session_id,
    fork_session=True   # new session ID, same history
)

async for message in query("Try a GraphQL approach instead", options=options):
    print(message)

To learn more about working with sessions, check out the Claude Agent SDK session guide.

2. Tool Design & MCP Integration

MCP stands for Model Context Protocol. It is an open standard for connecting your agent to external services. For example, your agent can query a database, fetch GitHub issues, or send a Slack message through an MCP server.

If you are new to MCP, check out our complete MCP Server Guide that covers everything from scratch.

Below are the key concepts.

MCP Components
Tool Descriptions
Structured Error Responses
Tool Distribution
MCP Server Configuration

MCP Components

An MCP server consists of three things.

Tools are functions exposed by the MCP server. When Claude calls a tool, the MCP server executes that function. Claude decides when to call the tool and what input to send.
Resources are read only data exposed by the MCP server. They give Claude extra context for the task. For example, a resource can be an API spec, database schema, product catalog, or project document.
Prompts are reusable instructions exposed by the MCP server. They tell Claude how to handle a repeated task. In supported clients, prompts can also be triggered as slash commands.

Here is a simple MCP server example. This one connects to PostgreSQL and shows all three components.

from mcp.server.fastmcp import FastMCP
import psycopg2
import os

mcp = FastMCP("DatabaseServer")

# Connect to PostgreSQL — use environment variables for credentials
conn = psycopg2.connect(
    host=os.getenv("DB_HOST"),
    database=os.getenv("DB_NAME"),
    user=os.getenv("DB_USER"),
    password=os.getenv("DB_PASSWORD")
)

# Tool — model calls this to query the database
@mcp.tool()
def get_order(order_id: str) -> dict:
    """Look up an order by order ID from the database."""
    cursor = conn.cursor()
    cursor.execute("SELECT id, status, item FROM orders WHERE id = %s", (order_id,))
    row = cursor.fetchone()
    
    if not row:
        return {"error": "Order not found"}
    
    return {"id": row[0], "status": row[1], "item": row[2]}

# Resource — exposes the full product catalog from the database
@mcp.resource("data://product-catalog")
def get_product_catalog() -> str:
    """Returns all products from the database."""
    cursor = conn.cursor()
    cursor.execute("SELECT name, price FROM products")
    rows = cursor.fetchall()
    return "\n".join([f"{row[0]} - ${row[1]}" for row in rows])

# Prompt — can appear as a slash command in supported clients
@mcp.prompt()
def review_order_prompt() -> str:
    """Template for reviewing an order status."""
    return """You are an order review specialist. 
When reviewing an order:
- Check the current status
- Identify any issues
- Suggest next steps"""

if __name__ == "__main__":
    mcp.run()

Once this MCP server is running and connected to your agent, you can query it directly.

“What is the status of order ORD-999?”

The agent calls the get_order tool, queries the database in real time, and returns the result.

Tool Descriptions

When Claude has multiple tools, it uses the tool description to decide which one to call. If the description is vague, Claude may pick the wrong tool.

A good tool description should clearly say three things.

What the tool does
What input it expects
When to use it and when not to

# Bad — too vague, Claude cannot differentiate
@mcp.tool()
def get_order(order_id: str) -> dict:
    """Retrieves order details."""
    ...

# Good — clear boundaries, Claude knows exactly when to use it
@mcp.tool()
def get_order(order_id: str) -> dict:
    """Look up an order by order ID. 
    Use this when you need order status, items, and shipping details. 
    Do not use this for customer account lookups."""
    ...

Structured Error Responses

When a tool fails, do not return a generic error. Claude needs to know what went wrong so it can decide what to do next.

In production, return more than just an error. Tell Claude what went wrong, whether it can retry, and what to do next.

Here are a few common categories.

Transient - If the external service is down or timed out, we return the error as transient. It means the failure is temporary and usually safe to retry.
Validation - If the input is missing or invalid, we return the error as validation. It means Claude should fix the input before calling the tool again.
Business - If the tool runs, but the action is not allowed by your system rules, we return the error as business. It means there is no point retrying the same request.
Permission - If the user or agent does not have access to perform the action, we return the error as permission. It means access should be granted first before retrying.

@mcp.tool()
def process_refund(order_id: str, amount: float) -> dict:
    """Process a refund for a given order."""

    # validation — bad input, no point retrying
    if not order_id:
        return {"error": True, "errorCategory": "validation", "isRetryable": False, "message": "order_id is required"}

    # business — order is not eligible for refund, refund window has expired
    if order_status == "delivered_over_30_days":
        return {"error": True, "errorCategory": "business", "isRetryable": False, "message": "Refund window has expired. Orders can only be refunded within 30 days of delivery."}
    
    # transient — service down, safe to retry
    if not payment_service.is_available():
        return {"error": True, "errorCategory": "transient", "isRetryable": True, "message": "Payment service unavailable. Try again."}

    return {"success": True, "refundId": "REF-001"}

Never return a generic error like {"error": "Operation failed"}. The more context you give Claude, the better it recovers.

Tool Distribution

Give each agent only the tools it really needs. Too many tools can confuse Claude. It may call the wrong tool or take the wrong action.

# Bad — agent has access to tools it should never use
research_agent = Agent(tools=[
    web_search_tool,
    process_refund_tool,    # research agent should never process refunds
    delete_record_tool,     # research agent should never delete records
    synthesis_tool
])

# Good — agent only gets what it needs
research_agent = Agent(tools=[
    web_search_tool,
    synthesis_tool
])

Use allowed_tools and disallowed_tools in the Claude Agent SDK to control which tools each agent can access.

options = ClaudeAgentOptions(
    mcp_servers={"orders": order_server},
    allowed_tools=[
        "mcp__orders__get_order",       # pre-approve read operations
        "mcp__orders__get_customer"
    ],
    disallowed_tools=[
        "mcp__orders__delete_record",   # block delete operations
        "mcp__orders__update_record"    # block write operations
    ]
)

To learn more, check the official SDK reference.

MCP Server Configuration

When you add an MCP server to your project, you need to decide where to configure it. There are two scopes.

Project level — .mcp.json in your repo. It can be shared with the whole team via version control.
User level — ~/.claude.json. It is personal and experimental. It is not shared.

// .mcp.json — project level, committed to the repo
{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["@anthropic-ai/mcp-server-github"],
      "env": {
        "GITHUB_TOKEN": "${GITHUB_TOKEN}"  // never hardcode secrets
      }
    },
    "database": {
      "command": "python",
      "args": ["./mcp_servers/database_server.py"],
      "env": {
        "DB_URL": "${DATABASE_URL}"
      }
    }
  }
}

Use existing community MCP servers for standard integrations like GitHub, Slack, and Jira. Build custom servers only for internal or team-specific workflows.

Check the official docs for MCP and Agent SDK integration.

3. Claude Code Configuration & Workflows

Claude Code deserves its own blog. We have covered the important concepts that will be useful for your daily development as well as for the exam.

CLAUDE.md
Custom Commands and Skills
Path-specific Rules
Plan Mode vs Direct Execution
Headless Mode
Hooks
Built-in Tools

CLAUDE.md

CLAUDE.md is the first file Claude reads when it starts a session. It tells Claude the project conventions and rules.

It supports three levels:

User level — ~/.claude/CLAUDE.md. Applies to all your projects.
Project level — CLAUDE.md in the repo root. Applies to the whole project. Commit this to Git.
Directory level — CLAUDE.md inside a subdirectory. Applies only when Claude is working in that folder.

repo/
├── CLAUDE.md              # applies to everything
├── frontend/
│   └── CLAUDE.md          # applies only in /frontend
└── backend/
    └── CLAUDE.md          # applies only in /backend

It can be placed directly in the repo root or inside the .claude/ directory. Both work the same way.

CLAUDE.md is advisory. Claude reads it and tries to follow it. But it is not guaranteed. Claude may not always follow it. If you have a constraint that must always run without exception, put it in a hook. Hooks fire programmatically and always run regardless of what Claude decides.

Custom Commands and Skills

Skills give domain-specific expertise to Claude. You package your team’s workflows, standards, and best practices into a SKILL.md file. Claude picks them up automatically when the task matches, or you call them directly with a slash command.

Skills live in two places:

.claude/skills/ — project level. Shared with the team via Git.
~/.claude/skills/ — user level. Personal, not shared.

Each skill lives in its own subdirectory. For example, a review-security skill would be at .claude/skills/review-security/SKILL.md.


---
name: review-security
description: Run a security audit on the current file
allowed-tools: Read, Grep
context: fork
argument-hint: [file-path to review]
---

Review this file for SQL injection, XSS, and hardcoded secrets.
Output findings as JSON with severity, line number, and recommendation.

Three fields to know:

allowed-tools - It controls which tools the skill can use. For example, if you set Read, Grep, the skill can only read files and search. It cannot write or run commands.
context: fork - It runs the skill in a separate session. Whatever Claude does in that session stays there. Use this when you want Claude to explore something without affecting your main session.
argument-hint - It shows a hint when someone types the slash command. It helps the user to understand what input to provide.

All fields are optional. But always include description so Claude knows when to load the skill automatically. Check the full frontmatter reference for all available fields.

Custom Commands were the older way to define slash commands in Claude Code. They lived in .claude/commands/*.md. Skills have now replaced them. If you are starting fresh, use Skills.

You can also find community-built skills at skills.sh.

Path-specific Rules

Rules live in .claude/rules/ as markdown files. When you want path-specific rules for your codebase, you add a paths field in your rules.


---
paths:
  - "frontend/**/*.ts"
  - "frontend/**/*.tsx"
---

Always use React functional components.
Never use class components.
Use Tailwind for styling. Never use inline styles.


---
paths:
  - "backend/**/*.py"
---

Always use FastAPI for routes.
Business logic goes in services/. Never in routes/.
Always add type hints.

When you write rules like above, Claude picks up the right rules based on the file it is touching. This is more token efficient than putting all rules in one big CLAUDE.md.

Note: The official docs use paths: but some versions of Claude Code work more reliably with globs:. If paths: does not work, try globs: with your pattern instead.

Plan Mode vs Direct Execution

By default, Claude executes tasks immediately. It reads files, writes code, runs commands without stopping.

Plan mode changes that. Claude outlines what it is going to do first. No files written, no commands run. You review the plan and approve before anything happens.

claude --permission-mode plan

Use plan mode for large scale or destructive changes. For small, well-scoped tasks, just run directly.

Headless Mode

Headless mode runs Claude non-interactively using the -p flag. No terminal prompts. No approvals. Used for CI/CD pipelines and automation scripts.

claude -p "Review this PR for security vulnerabilities" --output-format json > report.json

Use --output-format json when you need the output in json.

Check more about Claude’s mode in the Claude Code docs.

Hooks

We already covered hooks in the Claude Agent SDK section. The concept is the same but the implementation is different in Claude Code.

In the Agent SDK, hooks are Python callback functions. In Claude Code, hooks are shell commands configured in .claude/settings.json. They fire automatically at specific points in Claude Code’s lifecycle.

As we already saw, two hooks matter here.

PreToolUse fires before a tool executes and can block the action. PostToolUse fires after tool execution. Here is how they look in Claude Code.

{
  "hooks": {
    "PreToolUse": [{
      "matcher": "Bash",
      "hooks": [{"type": "command", "command": "echo '$CLAUDE_TOOL_INPUT' | grep -q 'rm -rf' && exit 2 || exit 0"}]
    }],
    "PostToolUse": [{
      "matcher": "Edit|Write",
      "hooks": [{"type": "command", "command": "jq -r '.tool_input.file_path' | xargs npx prettier --write"}]
    }]
  }
}

Built-in Tools

Claude Code ships with built-in tools. As an architect, you need to know when each one is the right choice.

Tool              When to use
-------           -----------
Read              Read the contents of a file
Write             Create or overwrite a file
Edit              Make targeted changes to a specific file
Bash              Run shell commands
Grep              Search for patterns inside file contents
Glob              Find files by name or pattern
LSP               Code intelligence — jump to definitions, find references, get type errors
Agent             Spawn a subagent with its own context window to handle a task
WebFetch          Fetch content from a URL
WebSearch         Search the web
Skill             Run a skill within the main conversation
NotebookEdit      Edit Jupyter notebook cells
AskUserQuestion   Ask the user a multiple choice question to clarify requirements

These are the most commonly used tools. Claude Code has many more built-in tools. Check the full tools reference for the complete list.

Up Next:

That is it for Part 1.

We covered agentic architecture, MCP integration, and Claude Code configuration.

In Part 2, we will move to the remaining areas. That includes prompt engineering, structured outputs, context management, reliability, and the registration flow.

I have added the mock test materials to this GitHub page. I will keep adding more questions as I find useful ones.

If you are planning to take the exam, use this blog and the mock questions as a practical guide. But before the exam, make sure you also go through the official docs once.

See you in Part 2.

Thanks for reading Dev Shorts! This post is public so feel free to share it.

[Dev Catch Up # 108] - GPT 5.5, DeepSeek V4, Claude Design, Kimi K2.6, ChatGPT Images 2.0, Qwen3.6 27B, HyperFrames, OpenAI's Privacy Filter, Parallel's Web Search MCP Server and much more!

Aravind Putrevu — Fri, 24 Apr 2026 13:17:44 GMT

Welcome to the 108th edition of DevShorts, Dev Catch Up.

Thanks for reading Dev Shorts! Subscribe for free to receive new posts and support my work.

Some recent issues from Dev Catch up:

Join 8800+ developers to hear stories from Open source and technology.

Must Read

OpenAI has released GPT 5.5, their smartest model so far. It is good at coding, debugging, and creating docs. It is also strong at agentic coding, computer use, and research work. OpenAI says it matches GPT 5.4 speed while completing Codex tasks with fewer tokens. Check OpenAI’s announcement for more details.
DeepSeek has released DeepSeek V4. The model is open sourced and comes with 1M context window at a lower cost. It has two versions, Pro for stronger performance and Flash for faster and economical use. You can try it on Chat or use the API. Check DeepSeek’s post for more details.
Anthropic has launched Claude Design, a new tool for creating visual work with Claude. It can help with wireframes, prototypes, pitch decks, landing pages, and campaign visuals. It can also build visuals that match your existing brand style. Check Anthropic’s announcement for more details.
Moonshot AI has released Kimi K2.6, an open source coding model. It is built for long running coding tasks. It can also create richer frontend like animated hero sections and motion based UI. It also supports large agentic workflows. Check Kimi’s post for more details.

OSS Highlight of the Week

This week we are featuring HyperFrames. It is an open source video rendering framework. It lets you create videos using HTML, preview them in the browser, and export them as MP4. It also works well with AI coding agents like Claude Code, Cursor, Gemini CLI, and Codex, so they can help you create videos with animations. Check the GitHub repo for more details.

Anthropic is testing a change to Claude Code access. Claude Code access was removed from the Pro plan for around 2% of new Pro signups. Those users now need the $100 Max plan to use Claude Code. Existing Pro users are not affected for now, but we need to wait and see if this expands later.
Anthropic’s Mythos model was reportedly accessed by a private Discord group. Mythos was meant only for selected partners, because Anthropic considered it too powerful for public release. The group reportedly used leaked vendor details to find the access path. Check Bloomberg’s report for more details.
Vercel reported a recent security incident. It started after Context.ai, a third party AI tool used by one employee, was compromised. The attacker used that access to enter some Vercel systems. They also decrypted some non sensitive environment variables. Read Vercel’s security bulletin for full details.
Cursor and SpaceXAI are working together on AI for coding tasks. Cursor brings the coding product. SpaceXAI brings the Colossus training supercomputer. SpaceXAI also has the option to acquire Cursor later this year for $60 billion. Check the post for more details.

Notable FYIs

OpenAI has released ChatGPT Images 2.0. It improves image generation, text rendering, and multilingual support. It can create visuals for social posts, presentations, infographics, comics, and other content. Check OpenAI’s announcement for more details.
Qwen has released Qwen3.6 27B, a 27B dense model focused on coding. It delivers strong agentic coding performance in a much smaller model. It also supports multimodal input and can work with coding agents. Check Qwen’s blog for more details.
OpenAI has released Privacy Filter, an open source model for finding and masking personal data in text. It is useful for teams that want to clean sensitive data on their own systems. It can redact PII before the data is stored or processed. Check the GitHub repo for more details.
We now have a free web search MCP server from Parallel. It is used for web search inside AI agents and MCP supported tools. It does not need any account or API key. You can use it with Claude Code, Codex, or any MCP supported tool. Check Parallel’s post for more details.

Thanks for reading Dev Shorts! This post is public so feel free to share it.

[Dev Catch Up # 107] - Claude Opus 4.7, GPT 5.4 Cyber, Gemini 3.1 Flash TTS, Windsurf 2.0 with Devin, Qwen3.6-35B MOE Model, Routines in CC, GPT Rosalind, Gemini for Mac, Codex for everything & more!

Aravind Putrevu — Fri, 17 Apr 2026 12:31:55 GMT

Welcome to the 107th edition of DevShorts, Dev Catch Up.

Thanks for reading Dev Shorts! Subscribe for free to receive new posts and support my work.

Some recent issues from Dev Catch up:

Join 8800+ developers to hear stories from Open source and technology.

Must Read

Anthropic has released Claude Opus 4.7. It comes with stronger coding, high resolution vision, and a new xhigh effort level. Pricing remains the same as Opus 4.6. Anthropic notes that Mythos Preview still remains its best aligned model based on its evaluations. Check Anthropic’s page for more details.
Google has released Gemini 3.1 Flash TTS. It generates more natural speech and supports 70+ languages. It also adds audio tags to control vocal style, pace, and delivery. Its audio output is watermarked with SynthID to identify AI generated content. Check Google’s announcement for more details.
OpenAI has rolled out GPT 5.4 Cyber. It is built for defensive security work. Access to this model is now open through identity verification. OpenAI says it can inspect compiled software and find malware, vulnerabilities, and other security issues without the original source code. Check OpenAI’s post for details.
Qwen has open sourced Qwen3.6 35B A3B. It is a sparse MoE model with 35B total parameters and 3B active. It comes with strong agentic coding and multimodal reasoning. It also supports both thinking and non thinking modes in one model. Check Qwen’s announcement for more details.

OSS Highlight of the Week

This week we are featuring Scion. It is an open source multi agent orchestration tool. It runs each agent in its own container and git worktree. It helps multiple agents work in parallel without getting in each other’s way. It works with Claude Code, Gemini CLI, Codex, and others too. Check the GitHub repo for more details.

Google has launched the Gemini app for Mac. It is a native macOS app. You can share anything on your screen with Gemini to get help, including local files. Check Google’s post for more details.
OpenAI has introduced GPT Rosalind. It is a new model built for life sciences research and drug discovery. OpenAI says it can reason across chemistry, proteins, and DNA, and help with experiment analysis. Check OpenAI’s post for more details.
Google has solved one of the old problems in RNNs with Memory Caching. Earlier, RNNs had to rely on one fixed memory as the input got longer. This new method keeps useful memory from earlier in the sequence. The paper says this improves long context and recall heavy tasks. It also brings RNNs closer to Transformers. Check the paper for more details.
I came across Baileys. It is a WebSockets-based TypeScript library for interacting with the WhatsApp Web API. If you are working on WhatsApp based apps, this is worth a look. Check the GitHub repo for more details.

Notable FYIs

Anthropic has introduced routines in Claude Code. You can now set up repeatable automations and run them on a schedule, through an API call, or from GitHub events. Since they run on Claude Code’s web infrastructure, you do not need to keep your laptop open. Check Anthropic’s post for more details.
Windsurf has launched Windsurf 2.0. It adds a new Agent Command Center to manage local and cloud agents in one place. Devin is now built into Windsurf, so cloud agents can keep working even after you close your laptop. Check Windsurf’s post for more details.
OpenAI has updated Codex in a big way. It now goes beyond coding. It can handle computer use, run multiple agents, and browse the web. It also adds image generation and 90+ new plugins. OpenAI is also adding memory and automations for long running work. Check OpenAI’s post for more details.
Google has introduced Skills in Chrome. You can now turn your prompts into one click tools. They can run on the page you are viewing or across selected tabs. Google is also adding a ready made Skills library. Check Google’s post for more details.
If you are building agents, this is a must read. Garry Tan shared a useful idea on building AI agents. He says keep the harness thin and put more value into skills. His point is that the real bottleneck is not model intelligence. It is whether the model understands your data, process, and context. Check Garry Tan’s post for more details.

Thanks for reading Dev Shorts! This post is public so feel free to share it.

[Dev Catch Up # 106] - Anthropic's Mythos, Meta's Muse Spark, Amazon's S3 Files, llmfit, OpenClaw's Dreaming feature,Claude Managed Agents,Graphify, nono-sandbox,Perplexity's plaid integration & more!

Aravind Putrevu — Fri, 10 Apr 2026 13:03:43 GMT

Welcome to the 106th edition of DevShorts, Dev Catch Up.

Thanks for reading Dev Shorts! Subscribe for free to receive new posts and support my work.

Some recent issues from Dev Catch up:

Join 8800+ developers to hear stories from Open source and technology.

Must Read

Anthropic’s new Project Glasswing is getting a lot of attention. It is a new effort to secure critical software. It is built around Claude Mythos Preview, Anthropic’s latest model. Anthropic says Mythos can find serious software flaws. It has already identified flaws in the Linux kernel and major browsers. Because of its capabilities, Anthropic is not making it publicly available. Check Anthropic’s announcement for more details.
Meta is back in the model race with Muse Spark. It is the first model from Meta Superintelligence Labs. It supports multimodal reasoning and visual chain of thought, and multi agent tasks. Check Meta’s announcement for more details.
Amazon has announced S3 Files. It lets you access S3 buckets like a file system, without moving data out of S3. It gives file system access to S3 data with low latency. Check AWS’s announcement for more details.
OpenClaw has released a new memory feature called Dreaming. It is a background memory consolidation system for long term recall. It takes useful short term context and stores it in durable memory. It is off by default. Check OpenClaw’s docs for more details.

OSS Highlight of the Week

This week we are featuring nono. It is an open source sandbox for AI agents. It lets you run agents in an isolated environment without extra infrastructure. It also supports tools like Claude Code, Codex, OpenCode, and OpenClaw. Check the nono GitHub repo for more details.

Anthropic has launched Claude Managed Agents. It helps teams build and run cloud hosted agents on Anthropic’s infrastructure. Anthropic handles things like sandboxing, permissions, state, and tracing. So teams can focus more on the agent itself. Check Anthropic’s announcement for more details.
LangChain has introduced Deep Agents Deploy. It is an open alternative to Claude Managed Agents. It helps teams deploy production ready agents with one command. It is model agnostic and open source, so teams are not locked into one provider. Check LangChain’s announcement for more details.
If you keep a lot of notes in markdown, Atomic is worth a look. It is an open source personal knowledge base. It turns markdown notes into a connected knowledge graph. You can explore it through wiki style pages, a canvas, and chat. Check the Atomic GitHub repo for more details.
xAI looks to be scaling up fast. Elon Musk says they have 7 models in training. They include Imagine V2, two 1T variants, two 1.5T variants, a 6T model, and a 10T model. Check Elon Musk’s post for more details.
IBM Research has released ALTK Evolve for AI agents. It helps agents learn from past runs instead of just re reading old transcripts. IBM says it turns agent traces into reusable guidelines, and improves reliability on harder tasks. Check the Hugging Face post for more details.
Microsoft has released Memento. It is a new way to extend LLM output length without needing a bigger context window. It breaks reasoning into blocks, writes short summaries, and clears old KV cache. So the model can keep going longer. Check the Memento GitHub repo for more details.

Notable FYIs

llmfit looks useful if you run models locally. It checks your RAM, CPU, and GPU, then tells you which models will run well on your machine. It also scores them across fit, speed, quality, and context. It comes with both a terminal UI and a CLI mode. Check the llmfit GitHub repo for more details.
The skill called Graphify caught my attention. It is an open source skill for Claude Code and other coding assistants. It turns a folder of code, PDFs, markdown, and images into a queryable knowledge graph with one command. It can help you understand a codebase faster and trace architecture decisions. Check the Graphify GitHub repo for more details.
Claude Code has added /autofix-pr in the CLI. You can now trigger PR autofix directly after finishing your PR. It sends your session to the cloud, so the autofixer gets full context to handle CI failures and review comments. Check the X post for more details.
Perplexity has added Plaid integration to its Computer agent. Users can now link bank accounts, credit cards, and loans for a fuller view of their finances. Perplexity says Computer can analyze spending, track net worth, and build custom finance tools from simple prompts. Check Perplexity’s announcement for more details.

Thanks for reading Dev Shorts! This post is public so feel free to share it.

[Dev Catch Up # 105] - Gemma 4, Qwen3.6 Plus, Microsoft's MAI Models, GLM 5V Turbo, Semiotic, Claude Code's Source Code Leaked, Claude Code tips, Video chat with your agents with this Skill & more!

Aravind Putrevu — Fri, 03 Apr 2026 13:31:27 GMT

Welcome to the 105th edition of DevShorts, Dev Catch Up.

Thanks for reading Dev Shorts! Subscribe for free to receive new posts and support my work.

Some recent issues from Dev Catch up:

Join 8800+ developers to hear stories from Open source and technology.

Must Read

Google has released Gemma 4. It is a new open model family. It is built from the same research and technology behind Gemini 3. Google says it supports agent workflows, multimodal reasoning, and 140 languages. Check Google DeepMind’s post for more details
Microsoft has announced three new MAI models in Foundry. They are MAI Transcribe 1, MAI Voice 1, and MAI Image 2. These cover speech to text, voice generation, and image generation. The models focus on speed, quality, and lower cost. Check Microsoft’s announcement for more details.
Qwen has introduced Qwen3.6 Plus. It comes with better coding, stronger multimodal vision, and a 1M context window in the API. Qwen says it is built to support real world agents and developer workflows. Check Qwen’s blog for more details.
Anthropic accidentally exposed Claude Code source code through a map file in its npm package. The leaked code then spread across GitHub through multiple repos and forks. Anthropic sent takedown notices to remove those leaked copies. Check the TechCrunch report for more details.

OSS Highlight of the Week

This week we are featuring Semiotic. It is a React library for building data visualizations in web apps. It comes with schemas and an MCP server, so AI coding assistants can generate correct chart code on the first try. Check the GitHub repo for more details.

Claude Code now has a No Flicker mode. It reduces screen flicker and keeps memory usage stable in long chats. It also adds mouse support in the terminal. Check Anthropic’s announcement for more details.
Prism ML has introduced 1 bit Bonsai 8B. It is a model with 1 bit weights and needs only 1.15 GB of memory. Prism says it is built for robotics, real time agents, and edge use cases. Check Prism ML’s announcement for more details.
Anthropic has shared new research on emotion concepts in language models. The research says models can form internal emotion related representations from human text. Anthropic says these patterns can influence how Claude behaves in some cases. Check Anthropic’s research post for more details.
AI has helped a solo founder build a $1.8B business. Medvi is one reported example built with AI tools for coding, ads, and support. It shows how a very small team can now scale much faster with AI. Check the New York Times report for more details.
Andrej Karpathy shared a workflow for building personal knowledge bases with LLMs. He uses them to turn papers, articles, repos, and images into a markdown wiki. The wiki then keeps growing through search, Q and A, and new outputs. Check Karpathy’s post for more details.

Notable FYIs

Pika has released a beta video chat skill for agents. It is powered by a new real time model called PikaStream 1.0. Pika says it keeps memory and personality during calls and can also support agentic tasks in the same session. Check Pika’s announcement for more details.
Boris Cherny shared practical Claude Code tips from his daily workflow. He showed features like teleport, remote control, loop, schedule, hooks, and Dispatch. These help Claude Code run across devices and automate more work. Check Boris Cherny’s thread for more details.
Qwen has released Qwen3.5 Omni. It is a native multimodal model that can understand text, images, audio, and video. Qwen says it brings stronger multilingual support and better audio and video understanding. Check Qwen’s blog for more details
Falcon has released Falcon Perception. It is a vision model for referring expression segmentation. Along with it, they also released Falcon OCR, a 0.3B OCR model. Falcon says it performs on par with much larger models. Check the Falcon’s post for more details.
Z.ai has introduced GLM 5V Turbo, a vision model built for coding. It can understand images, video, text, and files as input. Z.ai says it is built for multimodal coding tasks and can work with agents like OpenClaw. Check Z.ai’s docs for more details

Thanks for reading Dev Shorts! This post is public so feel free to share it.

[Dev Catch Up # 104] - Gemini 3.1 Flash Live, Claude's Computer Use, SORA gets shut down, HF hf-mount, TurboQuant, CC Cheat Sheet, Email.md, Auto-Mode in CC, LiteLLM Security Incident,MiroFish & more!

Aravind Putrevu — Fri, 27 Mar 2026 12:36:21 GMT

Welcome to the 104th edition of DevShorts, Dev Catch Up.

Thanks for reading Dev Shorts! Subscribe for free to receive new posts and support my work.

Some recent issues from Dev Catch up:

Join 8800+ developers to hear stories from Open source and technology.

Must Read

Google has introduced Gemini 3.1 Flash Live, its latest real time audio model. It is built for more natural voice conversations and better task handling. Google is rolling it out across more of its products. Check Google’s announcement for more details.
Google Research has introduced TurboQuant. Its a new compression method for AI models and vector search systems. It is designed to shrink memory use without hurting model accuracy. Google says TurboQuant can cut KV memory by at least 6 times. Check Google Research’s post for more details.
Hugging Face has introduced hf mount. It allows you attach Hub storage, models, and datasets like a local file system. You can now attach a remote storage that is 100x bigger than your local disk. It may be useful for Agentic Storage. Check Hugging Face’s post for more details.
LiteLLM was recently compromised in a suspected supply chain incident. The team has shared a detailed report and the affected versions. It is worth checking if you use LiteLLM in production. Check LiteLLM’s security update for more details.

OSS Highlight of the Week

This week’s OSS highlight is emailmd. It lets you write emails in Markdown and convert them into email ready HTML. It helps to create responsive emails without writing complex HTML. Check the GitHub repo for more details.

Good to know

OpenAI is reportedly shutting down Sora, its AI video product. They do this to free up compute for its next major model called Spud. This shows OpenAI is shifting focus back to its next big model release. Check the latest reports for more details.
Anthropic has added a new computer use feature to Claude. It can operate your Mac and complete real tasks. It can open apps, browse, and do desktop actions for you. It is now in research preview inside Claude Cowork and Claude Code on macOS. Check Anthropic’s post for more details.
Cloudflare has launched Dynamic Worker Loader. It lets developers run AI code in isolated sandboxes on demand. It makes agent execution much faster and more memory efficient than containers. Check Cloudflare’s post for more details.
Anthropic has introduced auto mode in Claude Code to reduce constant permission prompts. It can decide some file writes on its own. The goal is to reduce approval fatigue while maintaining safety controls. Check Anthropic’s post for more details.

Notable FYIs

Mistral has introduced Voxtral TTS, its first text to speech model. It is built for multilingual voice generation, low latency, and custom voice support. It is available through API, Mistral Studio and Hugging Face. Check Mistral’s announcement for more details.
MiroFish is an AI prediction engine built on multi agent technology. It takes real world signals like breaking news, policy drafts, or financial data and builds a parallel digital world for simulation. So teams can test possible future scenarios in a digital sandbox. Check the GitHub repo for more details.
Luma has introduced UNI 1, a new multimodal model for image generation. It is built for better image understanding, editing, and reference based generation. Luma says it performs well across image quality. Its API access is coming soon. Check Luma’s UNI 1 page for more details.
There is a Claude Code cheat sheet for quick reference. It brings shortcuts, slash commands, MCP options, and recent updates into one place. It is useful if you use Claude Code often and want everything in one view. Check it out for more details.
Mozilla AI has released cq, a new open standard for shared agent learning. It lets agents store, share, and query past knowledge. So they do not keep repeating the same mistakes. It is worth a look if you are exploring agent memory and team level learning. Check the GitHub repo for more details.
Google has introduced Lyria 3 Pro. Its latest music generation model. It can create longer tracks of up to 3 minutes. It gives more control over parts like intros, verses, and choruses. This will be available in all google applications like Vertex AI, Gemini App. Check Google’s announcement for more details.

Thanks for reading Dev Shorts! This post is public so feel free to share it.

[Dev Catch Up # 103] - GPT 5.4 mini and Nano, NVIDIA's NemoClaw, OpenAI's Model Challenge, Zeroboot, AutoResearchClaw, Google’s Stitch, Cowork's Dispatch, Unsloth Studio, Mistral Small 4 and more!

Aravind Putrevu — Fri, 20 Mar 2026 13:37:44 GMT

Welcome to the 103rd edition of DevShorts, Dev Catch Up.

Thanks for reading Dev Shorts! Subscribe for free to receive new posts and support my work.

Some recent issues from Dev Catch up:

Join 8800+ developers to hear stories from Open source and technology.

Must Read

OpenAI has released GPT 5.4 mini and nano. GPT 5.4 mini is a smaller model with better coding, reasoning, multimodal understanding, and tool use. It is 2x faster than GPT 5 mini. GPT 5.4 nano is the cheaper option for smaller tasks. Check OpenAI’s announcement for more details.
NVIDIA has released NemoClaw. It is an open source setup that helps you run OpenClaw assistants in a safer way. It sets up NVIDIA OpenShell for secure agent runs and supports open models like NVIDIA Nemotron. Check the NemoClaw GitHub repo for more details.
MiniMax has released M2.7. It can handle project delivery, bug fixing, log analysis, and office tasks like Word, Excel, and PPT. It is also the company’s first model to take part in its own evolution. Check MiniMax’s announcement for more details.
Manus has introduced My Computer. Its a Desktop app. It works with local files, folders, tools, and apps. It can run terminal commands, edit files, and handle desktop tasks with your approval. It is available now for macOS and Windows users. Check Manus’s announcement for more details

OSS Highlight of the Week

This week’s OSS highlight is AutoResearchClaw. It is an open source research agent. It turns a research idea into a full paper. It can search papers from OpenAlex, Semantic Scholar, and arXiv and generate experiments, charts, reviews, and conference ready LaTeX output. It is useful for developers and researchers who want to test ideas faster. Check the GitHub repo for more details.

Anthropic is shipping Dispatch in Claude Cowork as a research preview. It gives you one persistent conversation with Claude that runs on your computer. You can message it from your phone and come back later to finished work. To try it, download Claude Desktop and pair your phone.
Unsloth has introduced Unsloth Studio. It is an open source web UI for working with open models locally. You can run models, train them, and export them from one place. It also supports files like PDF, CSV, JSON, and DOCX for training. Check Unsloth’s docs for more details.
Google has updated Stitch. It turns prompts into UI. It comes with new canvas, a design agent, voice support, and DESIGN.md for reusing design rules across tools. It also supports integrations through MCP and SDKs. Check Google’s Stitch announcement for more details.
Cursor has introduced Composer 2. Cursor says it performs better than earlier Composer versions on coding benchmarks. Check Cursor’s announcement for more details.

Notable FYIs

OpenAI has launched a Challenge called Parameter Golf. It asks people to train the best language model that fits in 16MB and trains in under 10 minutes on 8xH100s. OpenAI is also offering compute credits. The challenge runs from March 18 to April 30. Check OpenAI’s post for more info.
Zeroboot creates sandboxes for AI agents very fast. It can start VM sandboxes in less than a millisecond. The repo also includes SDKs and self hosting docs. It is still a prototype, so it is not ready for production yet. Check the Zeroboot GitHub repo for more details.
Microsoft has introduced MAI Image 2. It is their new image model built for creative work. It improves photorealism, image text generation, and detailed scene creation. It is available now in MAI Playground, Copilot and Bing Image Creator. Check Microsoft’s announcement for more details.
Z.AI has released GLM 5 Turbo. It is built for OpenClaw style agent tasks. It supports tool calling, long chain tasks, MCP, and a 200K context window. Check Z.AI’s docs for more details.
Mistral has released Mistral Small 4. It brings reasoning, coding, and image understanding into one system. It combines capabilities from Mistral’s earlier model families. It comes with a 256k context window and is open source. Check Mistral’s announcement and docs for more details.
World has introduced AgentKit. It adds human verification for agents. It is powered by x402 and built by Coinbase and Cloudflare. The goal is to make agent automation more trusted. Check World’s announcement and docs for more details.

Thanks for reading Dev Shorts! This post is public so feel free to share it.

[Dev Catch Up # 102] - Gemini Embedding 2, Andrew Ng's Context Hub, Nemotron 3 Super, Perplexity's Personal Computer, gstack, AMI Labs, Agent 4, Karpathy's Auto Research, RCLI-Voice AI for Mac & more!

Aravind Putrevu — Fri, 13 Mar 2026 13:45:15 GMT

Welcome to the 102nd edition of DevShorts, Dev Catch Up.

Thanks for reading Dev Shorts! Subscribe for free to receive new posts and support my work.

Some recent issues from Dev Catch up:

Join 8700+ developers to hear stories from Open source and technology.

Must Read

Google has released Gemini Embedding 2, its first natively multimodal embedding model. It can map text, images, video, audio, and documents into one embedding space. This is useful for multimodal RAG, search, and retrieval use cases. Check Google’s Gemini Embedding 2 announcement for more details.
Andrew Ng has released Context Hub. It helps coding agents use curated and versioned docs through a CLI. It is designed to reduce API hallucinations and help agents improve across tasks. Check the Context Hub GitHub repo for more details.
NVIDIA has released Nemotron 3 Super, a new open 120B model for agentic AI. It is built for long and complex agent workflows. It supports a 1 million token context window and higher throughput. Check NVIDIA’s Nemotron 3 Super announcement for more details.
Perplexity has opened the waitlist for Personal Computer. It brings Perplexity Computer and Comet Assistant to your own system. Perplexity says sensitive actions need your approval and all actions are logged. Check Perplexity’s page for more details.

OSS Highlight of the Week

This week we are featuring RCLI. It is an on device voice AI for macOS. You can control macOS actions with voice and also query your documents with voice. No cloud and no API keys. Check the RCLI GitHub repo for more details.

Cloudflare has added a new /crawl endpoint in Browser Rendering. It lets developers crawl an entire website with one API call. It returns the content in HTML, Markdown, and structured JSON. Check Cloudflare’s post for more details.
Microsoft has introduced Copilot Cowork. It helps Copilot turn a request into a plan and take action. It works using signals from Microsoft 365 apps like Outlook, Teams, and Excel. Check Microsoft’s post for more details.
OpenAI has opened applications for Codex for Open Source. Selected maintainers get ChatGPT Pro with Codex, Codex Security, and API credits. Check OpenAI’s page for more details.
Anthropic has launched Claude Marketplace. It allows customers to buy Claude powered tools from partners like GitLab, Replit, and Snowflake using their Anthropic commitment. Check Anthropic’s page for more details.
OpenAI has added interactive learning for math and science in ChatGPT. Now you can learn concepts with visual explanations inside ChatGPT. This makes formulas and graphs easier to understand. Check OpenAI’s post for more details.

Notable FYIs

Ex Meta Chief Scientist Yann LeCun has launched AMI Labs. AMI Labs aims to solve the limits of standard language models by building world models. Its initial focus is on companies that run complex systems, like automotive, aerospace, biomedical, and pharma. Check the AMI Labs site for more details.
Y Combinator CEO Garry Tan has released gstack. It brings his Claude Code setup with 6 opinionated tools for roles like CEO, Engineering Manager, Release Manager, and QA Engineer. It is built to turn one coding agent into a team of specialist workflows. Check the gstack GitHub repo for more details.
Andrej Karpathy has released autoresearch. It lets AI agents run small LLM training experiments automatically on a single GPU. The agent edits the training code, runs a fixed 5 minute experiment, checks the result, and repeats. Check the autoresearch GitHub repo for more details.
Came across this X post where a techie shared how he hacked Perplexity Computer and got access to the Claude Code API key used by Perplexity. He also shared a safer pattern for handling keys in multi agent systems. Check the X post for more details.
Hume has open sourced TADA, a speech language model for text to speech. It is designed for faster generation and to reduce hallucinated words in speech output. This could be useful for teams building voice products. Check Hume’s post for more details.
Replit has introduced Agent 4 for more creative app building workflows. It can generate UI variants and handle multiple tasks in parallel. This helps developers move faster while building inside Replit. Check Replit’s Agent 4 announcement for more details

Thanks for reading Dev Shorts! This post is public so feel free to share it.

[Dev Catch Up # 101] - GPT-5.4, Gemini 3.1 Flash Lite, Google Workspace CLI, import-memory in claude, Qwen 3.5 Small models, Voice Mode in Claude Code, Claude-Max for open-source maintainers and more!

Aravind Putrevu — Fri, 06 Mar 2026 13:03:40 GMT

Welcome to the 101st edition of DevShorts, Dev Catch Up.

Thanks for reading Dev Shorts! Subscribe for free to receive new posts and support my work.

Some recent issues from Dev Catch up:

Join 8700+ developers to hear stories from Open source and technology.

Must Read

OpenAI has released GPT-5.4. It is their most capable model so far. They also released GPT-5.4 Pro in ChatGPT and the API for harder tasks and long running workflows. It brings improvements in reasoning, coding, and agentic workflows. Check OpenAI’s GPT-5.4 announcement for more details.
Many tools are now moving to the CLI, so agents can use them. Google Workspace released Workspace CLI. It lets you access Gmail, Drive, Docs, and Calendar directly from the terminal. The engineer who built it also wrote a post on designing CLIs for AI agents. Check the Google Workspace CLI GitHub repo for installation and usage details.
Google has released Gemini 3.1 Flash Lite, a lightweight model built for high volume workloads. It focuses on speed and lower cost while still handling complex tasks. It is available through the Gemini API, AI Studio, and Vertex AI. Check Google’s Gemini 3.1 Flash Lite announcement for more details.
Qwen introduced the Qwen 3.5 Small model series with 0.8B, 2B, 4B, and 9B sizes. These models aim to deliver stronger performance with lower compute. They also released matching Base models for research and fine tuning. Check Qwen’s Twitter post for more details.

OSS Highlight of the Week

This week we are featuring Hermes Agent, an open source AI agent from Nous Research. It runs on your machine. It acts as a personal agent and learns your projects. It builds skills over time. It can connect to tools like Slack, Telegram, and Discord and automate tasks on a schedule. Check the Hermes Agent GitHub repo to explore more.

Anthropic introduced Import Memory in Claude. Now you can bring context from other AI tools with a simple copy paste flow. This helps Claude pick up your preferences and project context faster. Check Claude’s Import Memory page for more details.
Cursor added MCP Apps. It allows interactive interfaces like charts, diagrams, and whiteboards to appear directly inside Cursor. This means tools can return rich visual interfaces instead of just text responses. Check Cursor’s MCP App’s post for more details.
A new interview with Boris Cherny, the creator of Claude Code, explains how the tool was built and how developers are using it today. It covers workflows like running parallel agents and more. Check the Pragmatic Engineer post for the full interview.
If you are building LLMs, this post is worth reading. It explains how open weight LLMs are built. It covers ideas like MoE models, active parameters, and training choices in a simple way. Check the full post for more details.
OpenAI is reportedly building a GitHub rival. The project is still in the early stages. It may be offered to OpenAI’s existing customers. The move comes after several GitHub outages that disrupted developer workflows in recent months. Check the report for more details.

Notable FYIs

OpenAI released Symphony. It turns project work into isolated implementation runs. It spawns agents to handle the tasks. The agents complete the work and provide proof of execution. This lets teams manage the work instead of supervising coding agents. Check OpenAI’s Symphony for more details.
The much awaited Voice Mode is rolling out in Claude Code. It lets developers talk to Claude directly instead of typing prompts. The feature is currently live for a small percentage of users and will roll out more broadly in the coming weeks. Check the post for early demos and rollout details
Anthropic offers 6 months of free Claude Max access for eligible open source maintainers and contributors. The goal is to support developers who maintain important OSS projects. Check the Claude for OSS page to see eligibility and application details.
Cursor introduced Automations. They can run on a schedule or based on events like Slack messages, GitHub PRs, Linear issues, and PagerDuty incidents. You can also configure your own custom events using webhooks. Check Cursor’s Automations post for more details.
This Substack post talks about AI tooling for software engineers in 2026. It shows which tools developers use the most. It also explains how common AI has become in daily development work. Check the Pragmatic Engineer post for the full breakdown.

Thanks for reading Dev Shorts! This post is public so feel free to share it.

Dev Shorts

[Dev Catch Up # 116] - OpenAI & HuggingFace Security Incident, Gemini 3.6 Flash, Qwen3.8, Grok For Excel, Cursor Router, Andrew NG's OpenWorker, CoWork's feature - Record a Skill, OpenShip and more!

Must Read

OSS Highlight of the Week

Good to Know

Notable FYIs

[Dev Catch Up #115]- Kimi K3, Grok 4.5, Bonsai 27B, Thinking Machine's Inkling, GPT-Live, Clawk-disposable VMs for Agents, SWE-1.7, Meta's Muse Spark 1.1, grok-build,Agent Teams in Antigravity & more!

Must Read

OSS Highlight of the Week

Good to Know

Notable FYIs

How to Run Custom Models in Codex

1. Codex App and CLI

2. Connect Local Models in Codex through Ollama, LM Studio, Unsloth, and llama.cpp

Codex App with Ollama:

Codex CLI with Ollama

Profile based setup

Codex CLI with LM Studio:

Profile based setup

Codex CLI with Unsloth

Profile based setup

Codex CLI with llama.cpp

3. Connect Custom Models in Codex through OpenRouter

4. Four points to remember while integrating custom models

Conclusion

[Dev Catch Up # 114]- Fable 5 is back, OpenAI's GPT 5.6, Claude Sonnet 5, Nano Banana 2 Lite, Gemini Omni Flash, Lore -Open Source Version Control, Hosted X MCP, Nemotron-Labs-TwoTower and more!

Must Read

OSS Highlight of the Week

Good to know

Notable FYIs

GLM 5.2 vs Opus 4.8 in Claude Code

1. GLM 5.2 and Opus 4.8: An Overview

2. Setting up GLM 5.2 inside Claude Code

3. GLM 5.2 vs Opus 4.8 in Claude Code

Test-1: One-shot UI build

Prompt Given:

What GLM 5.2 Built

What Opus 4.8 Built

What I noticed:

Test 2: Debug a failing Test

Prompt Given:

What Opus 4.8 did

What GLM 5.2 did

What I noticed:

Test 3: Fixing performance bottleneck

Prompt Given:

What GLM 5.2 did

What Opus 4.8 did

What I noticed:

Test 4: Refactoring Codebase

Prompt given:

What Opus 4.8 did

What GLM 5.2 did

What I noticed

Test 5: A multi-step research task, with sub-agents

Prompt given:

What Opus 4.8 did

What GLM 5.2 did

What I noticed

4. Key Insights from Tests

[Dev Catch Up # 113]- GLM 5.2, Kimi-K2.7-Code, SpaceX acquires Cursor, Anthropic blocks Fable and Mythos access, Vercel’s Eve-Agent Framework, OpenRouter's Fusion,Cursor's Origin,Zed's DeltaDB & more!

Must Read

OSS Highlight of the Week

Good to know

Notable FYIs

[Dev Catch Up # 112] - Claude Fable 5 and Mythos 5, Gemini 3.5 Live Translate, Kimi Work, DiffusionGemma, Apple's Core AI, Harness Engineering, Xiaomi's MiMoCode, Herdr - Agent Multiplexer and more!

Must Read

OSS Highlight of the Week

Good to know

Notable FYIs

[Dev Catch Up # 111] - MAI Models, Hermes Desktop, Gemma 4, Qwen3.7 Plus, MiniMax M3, Claude Code's dynamic workflows, OpenAI models on AWS, Trackio-wandb alternative, Meta Business Agent and more!

Must Read

OSS Highlight of the Week

Good to know

Notable FYIs

Claude Certified Architect Foundations: The Complete Guide - Part 2

1. Prompt Engineering & Structured Output

Explicit Criteria

Few-shot Prompting

Structured Output