SI Agent News

• ChatGPT (OpenAI's chatbot) can reportedly save new words to your phone. A walkthrough on Habr says that saying 'add these words to my dictionary' puts them into the mobile app. Status: REPORTED (one author's walkthrough, not an official announcement). Takeaway: ask your assistant to keep what it just explained. Habr

Anthropic reportedly in talks to spend another $45 billion on Nscale cloud capacity

Anthropic, the company behind Claude, reportedly plans to spend another $45 billion expanding its rental of cloud computing from Nscale, an AI cloud company. TechNews cites people familiar with the matter and says the two are in talks on a new large compute deal. Plain comparison: if a million-dollar project is a big one for a company, this is forty-five thousand of them.

Status: REPORTED. No signed deal. The excerpt we have gives no timeline, chip details or pricing, so treat the number as a signal of scale rather than a finished contract. Analysis, not company statement: compute sits behind rate limits and waitlists, so more rented capacity suggests Anthropic expects Claude demand to keep growing. It also suggests that capacity, not only model quality, is what limits how many people can use these tools at once. TechNews

What this means for you:

• Small business owner: don't budget around a report, but if you build on Claude, keep a fallback model ready in case limits change.
• Job seeker or student: learn the parts that travel between vendors, like instruction files and tool design, covered below.
• Creator: keep your best prompts somewhere portable so a limit change never stalls a deadline.

Claude cautious, GPT daring: risk tendencies vary by task

The Chosun Ilbo, via MSN, reports under the headline "Claude cautious, GPT daring: AI risk tendencies vary by task." Read plainly, the claim is that Claude and GPT lean different ways when a decision carries risk, and that the lean shifts depending on what the task is. The excerpt we have is the headline and source only, so how this was measured, which model versions were compared and which tasks were tested are STILL OPEN. The framing itself is REPORTED.

Why it matters: a model's risk habit shapes your results. A cautious model may refuse or hedge more; a daring one may commit to an answer or an action faster. Analysis, not the article's finding: match the habit to the stakes. Prefer the careful behavior where mistakes are costly, such as sending messages, editing live data or giving advice to customers. Accept the bolder behavior for brainstorming and drafts where you review everything anyway. Cost: price not stated. The cheap way to use this is a small test: run the same five real tasks of yours through both and note which one you would trust unsupervised. The Chosun Ilbo on MSN

An undo button for an MCP server

A team on dev.to gave their MCP server (MCP, the Model Context Protocol, is a standard way for agents to call tools) an undo button. Every change the agent makes goes into one run that can be reversed in one step. Their argument: letting an agent change settings is only reasonable if you can take it all back.

Illustration of the general pattern, not their exact code: group changes into one run, record what was there before each change, replay those records in reverse. The limit: undo covers state you control; it cannot unsend an email. So let the agent run reversible tools freely and put irreversible ones behind human approval.

Status: CONFIRMED that the post describes this design; STILL OPEN how it holds up at scale. Cost: price not stated; it is a pattern, not a product. Worth it for anyone letting agents edit live settings, and it is a good question to put to any tool vendor: if the agent gets it wrong, how do I roll back? dev.to

You're listening to SI Agent News, the Claude edition. Still ahead: what 'harness' really means, how an agent finds and safely runs tools, and a file setup you can copy. That pick came from a scan of thousands of sources, so you don't have to read them.

AGENTS.md vs CLAUDE.md vs .cursor/rules: which file does your AI agent read?

A dev.to post compares three instruction files that coding agents read before they start work: AGENTS.md, CLAUDE.md and .cursor/rules. The question in the title is the useful one, because a rule written in a file your tool never opens does nothing. The excerpt we have is the title, so the post's exact findings are STILL OPEN.

General background, not the post's conclusions: these are plain text files kept in a project where you write standing instructions, such as how to run tests, what style to follow and which folders to leave alone. Different tools look for different file names, so a project used with more than one tool can end up with rules in the wrong place or copies that drift apart.

What this means for you: before you write a long rulebook, check which file each of your tools reads, then keep one source of truth and point the others to it. Cost: free; these are text files. Students and job seekers: knowing this is a small, portable skill that shows you can set an agent up properly. dev.to

What is a harness? Everything that is not the model

Another dev.to post answers a term you will keep hearing: a harness is everything that is not the model. That is the post's definition as titled. In practice that means the code and settings wrapped around the AI: the instructions it starts with, the tools it can call, the permissions, the memory, and the loop that feeds results back in. The excerpt gives no more detail, so the post's specific breakdown is STILL OPEN.

Why it matters: analysis, not the author's claim: when an agent behaves badly, people blame the model, but the cause is often the harness, such as a missing instruction, a tool that returns confusing output or no limit on what it may touch. It also explains why the same model can feel brilliant in one product and clumsy in another. For a buyer, ask vendors what is in their harness, not only which model they use. For a builder, improving the harness is usually cheaper than switching models. Cost: a concept, not a product. dev.to

Advanced tool use: dynamic discovery, sandboxing and self-healing recovery

A dev.to article on agent architecture names three techniques for tool use: dynamic discovery, sandboxing and self-healing recovery. The excerpt gives only the title, so implementation details are STILL OPEN. Here is what the terms generally mean.

• Dynamic discovery: the agent finds which tools are available when it needs them, instead of carrying a huge fixed list.
• Sandboxing: tools run in a walled-off space, so a mistake or a bad command cannot reach your real files or accounts.
• Self-healing recovery: when a tool call fails, the agent reads the error and tries a fix or a safer route rather than stopping or looping.

Why it matters: these three map to the three common failures: too many tools confuse the agent, one wrong command does damage, and one error ends the job. Sandboxing pairs well with the undo idea above. For a small business: ask any agent vendor whether the agent runs in a sandbox and what happens after a failed step. Cost: price not stated; these are design patterns. dev.to

Contract provisions for agentic AI

For strategists: JD Supra published a piece on cybersecurity contract provisions for securing agentic AI (AI that acts on its own). Its opening point: these products tend to have broad access and a lot of automation, which raises what a contract must cover. Ask any vendor two questions: what can the agent reach, and what may it do with that reach? The excerpt we have lists no specific clauses, so details are STILL OPEN; the framing is REPORTED. Contract on paper, undo in code.

Why it matters: the technical safeguards above, such as sandboxes, approvals and rollback, are only as strong as what you can hold a vendor to in writing. If you sign for a tool that can read your files or send messages, get the access limits and the vendor's duties spelled out before launch. This is general guidance, not legal advice; have counsel review real contracts. Cost: price not stated; worth reading if you buy agent tools for a team. JD Supra

ChatGPT can now save new words to your phone

A Habr author reports that ChatGPT has learned to save new words to your phone and walks through how it works. This is a small, everyday use of an assistant doing something outside the chat window. The excerpt we have is the headline and a promise of a demonstration, so which phone, app, permissions and steps are involved is STILL OPEN. The feature itself is REPORTED by the author, not confirmed by us.

Why it matters: analysis: language learners are the obvious users, since a word you meet in conversation can go straight into a list you review later. It is also a plain example of the agent theme in today's edition: once an assistant can write to something on your device, ask what it can reach and whether you can reverse it. Practical tip: when you try it, check what permission it asks for, test with one harmless word first, and confirm you can delete saved entries. Cost: not stated. Habr

'Harness': everything that is not the model

Since the start of the year everyone has talked about the 'harness' — harness engineering, agent harness, best harness. A dev.to post says ask around and you get five different definitions, then proposes one: a harness is everything that is not the model.

That sounds too broad, but broad is the point. Claude is a model. Claude Code (a coding agent) is a model plus a harness: the tools it can call, its permissions, the instruction files it reads, the loop that runs it, and the memory and error handling around it. Every other story today is a harness piece: the undo run, the sandbox in the deep dive, the instruction file, even the contract.

Our analysis, not the post's: when an agent fails, ask four questions before blaming the model.

1. Did it have the right information (context and instructions)?
2. Did it have the right tools?
3. Were there guardrails, like permissions and undo?
4. Could it see its own errors and try again?

If any answer is no, the fix is an afternoon of harness work, not a model swap. Sometimes the model really is weaker; the narrower claim is that harness fixes are usually cheaper to try first, and you control them.

Status: CONFIRMED that the post offers this definition; STILL OPEN whether the industry settles on one. Cost: a definition is free. Worth it for anyone who builds or buys agents. dev.to

Inside an agent's tool layer: discover, validate, contain, recover

For builders: if the harness is everything but the model, the tool layer is its riskiest piece. A dev.to post covers four mechanisms: MCP-based runtime discovery, strict JSON Schema validation, gVisor container sandboxing, and self-healing recovery. The explanations below of how each typically works are general practice, not details from the post.

1. Dynamic discovery. Instead of hardcoding functions, the agent asks an MCP server at runtime what tools exist. Each comes back with a name, description and input schema, so you can add tools without redeploying. Catch (analysis): every description uses context, and more tools means more chances to pick the wrong one.
2. Strict validation. JSON Schema is a standard way to describe valid input. The harness checks the model's arguments against it before anything runs and rejects malformed calls.
3. Sandboxing. gVisor (a sandbox from the container world) intercepts a program's system calls in a layer between the tool and the host, so a bad command has less reach.
4. Self-healing. On failure, a structured error goes back to the model, which corrects its arguments and retries, with a cap on attempts and then escalation to a human. Without a cap, a retry loop can quietly burn money.

Limit: a sandbox contains code; it does not judge intent, so pair it with the undo run. Novel or incremental? Incremental. Each piece is known; the value is the combination.

Status: CONFIRMED the post covers these four; STILL OPEN how well it works, since the summary gives no performance numbers. Cost: price not stated; worth it for engineers running agents against real systems. dev.to

One instruction file, three tools, no drift

Who it's for: anyone using more than one coding agent on the same repo. Problem: different tools read different files: AGENTS.md (a shared-format instruction file several tools read), CLAUDE.md (read by Claude Code) and .cursor/rules (for the Cursor editor). Keep rules in one format and the others guess; paste a wall of text into all three and the copies drift. Source: dev.to. Status: CONFIRMED the post describes the problem; the steps below are an illustrative setup, not something we ran.

1. Choose one source of truth: AGENTS.md at the repo root.
2. Write only what the agent can't infer from code: build and test commands, folder conventions, a never-touch list. About a page.
3. Make CLAUDE.md thin. Claude Code can import another file with an @ path, so line one is @AGENTS.md, then add only Claude-specific notes. Check Anthropic's current docs for the syntax.
4. Do the same for .cursor/rules, pointing at the shared file or generating it. Check that tool's docs.
5. At the top of each copy add: 'Do not edit here, edit AGENTS.md.'
6. Verify: in a fresh session in each tool, ask 'What are the build commands, and what must you never touch?' and compare to your file.

AGENTS.md (illustrative)
- Build: run the project's build command
- Test: run tests before every commit
- Never touch: /migrations, /vendor

CLAUDE.md
@AGENTS.md
- Claude-specific notes only

Mistake to avoid: pasting the same wall of text everywhere. Drift is silent. Cost: files are free; tool prices are not stated in today's stories, so check each pricing page. Worth it if your team uses more than one coding agent.

The correction tally: an estimated five hours a year per repeated rule

For one week, tally every time you correct your coding agent in the same way. A correction that appears twice becomes one line in AGENTS.md. A line in the file that never mattered gets deleted.

The number (an estimate with illustrative assumptions): if you repeat one correction three times a week at two minutes each, that is six minutes a week, about five hours a year, for a single rule. We make no claim about how many rules you repeat.

Vendor-neutral: the tally works the same with Anthropic's Claude Code, OpenAI's Codex or the Cursor editor, since each reads an instruction file in some form. Plans and prices are not stated in today's stories; check each company's current pricing page.

What you give up: a few minutes of tallying, and some nuance. A trimmed file can't explain every edge case, so keep rarely needed detail in separate docs the agent can open when asked. Status: illustrative estimate, not a measured result.

Prompt clinic: turn your corrections into rules

Weak prompt: 'Make my instructions file better.' It has no input, no criteria and no output format, so the model guesses what 'better' means and usually adds more text.

Better prompt (copy-ready, illustrative, not tested):

You are reviewing the instruction file for a coding agent. Below are my current AGENTS.md and a list of corrections I had to repeat this week. Propose edits under these rules. Add a line only for a correction that appears at least twice. Flag any line the agent could infer from the code. Write every rule as a concrete command or a never-do. Keep the file short. Output a table with Change, Reason and Evidence, then the full revised file. If you are unsure a rule is still true, list it under 'Ask me' instead of guessing.

[paste AGENTS.md]
[paste corrections]

Why it works: evidence to cite, a threshold for adding, a deletion test, a length cap and an escape hatch for uncertainty. Customize: the cap and the threshold. Quality check: verify two proposed rules against the repo, then run the fresh-session test from the technique.

The Chosun Ilbo, a Korean newspaper, reported a head-to-head test in which AI controlled a drone in a city center with strong winds and obstacles. Anthropic's Claude Sonnet 4.5 (a Claude model) came out 'safety-first', aiming to avoid risk, while a GPT model took more. 'Risk tendency' means how readily a model accepts danger to finish a task. Status: REPORTED. Who ran it and how many runs are STILL OPEN, so treat it as a hint, not proof.

Decision this week: run two real tasks of yours on each model you are considering and record how each handles uncertainty. Use the cautious one where actions are hard to undo, the bolder one for drafts. The Chosun Ilbo via MSN

Agentic AI was one of the busiest topic areas today, alongside open source, policy, Claude and funding, and today's stories sit across several of those: money for compute, safety patterns, contracts.

• REPORTED, no firm date: the Anthropic and Nscale talks. Official confirmation would settle it; a denial would sink it.
• Our expectation, not an announced plan: more coding tools standardizing on a shared instruction file. Evidence would be tools adding support for AGENTS.md.

Our agent now has an undo button. Sadly, it still can't undo 'I'll just run it in production.'

That's it for today. Tomorrow we're watching whether Anthropic or Nscale confirms the reported compute talks, and whether more coding tools settle on one shared instruction file.

Listening every day is learning with a reason: today it was a file setup, a prompt fix and a few saved hours, with real examples from builders and teams. If this was useful, share it with one person who would find it useful too. Thank you for spending your time with us.

SI Agent News — a podcast newsletter. Made by AI.