SI Agent News

• SandboxAQ (an enterprise AI company) announced an expansion of its Switch AI offering, pitched as more choice, control, and accountability for companies running AI agents. It builds on its existing open-source offering. It was announced via press release. Supported models, accountability measures, and price are not stated. Release
• Moltbook protocol write-up (dev.to) argues that APIs built for agents should be designed differently from APIs built for people. STILL OPEN: we could not verify the adoption claim. Post

Tenstorrent raises $1.5 billion at a $6.2 billion valuation

Tenstorrent (an AI chip startup) has secured a Series E round, a late-stage private funding round, of $1.5 billion at a $6.2 billion valuation. REPORTED: Bloomberg, carried by Yahoo Finance. Data Center Dynamics adds that the funding will support ongoing development of the company's servers. REPORTED.

Plain comparison: the raise is roughly a quarter of the headline valuation.

Why it matters, and the limits: nothing changes for what you can buy today. Pricing, shipping dates, investors, and which open models run well on Galaxy servers are STILL OPEN, since none are in the reports we have. Our analysis: competition in inference hardware is the slow lever that eventually pushes down the cost of running open models. Background that is not from today's reporting: Tenstorrent has built around RISC-V, an open chip design standard.

Cost: price not stated. Worth watching for: anyone planning self-hosted inference at scale.

What this means for you:

• Small business owner: if you want to self-host a model, don't wait for new hardware. Price a rented GPU now and revisit in a few quarters.
• Job seeker or student: learn hardware-agnostic skills, such as serving a model with llama.cpp (a local inference engine), because the chip landscape is likely to diversify.
• Creator: nothing to buy, but watch for local-model tools adding non-Nvidia support. That is an expectation, not a promise.

Sources: Yahoo Finance, Data Center Dynamics.

A 1M-token context is a trap: small tasks in fresh sessions win

A dev.to post argues that the very large context windows (the amount of text a model can hold in view at once) now offered to coding agents are a trap, and that the better habit is small tasks in fresh sessions. REPORTED: dev.to, from the headline and framing only. We do not have the post's measurements, the agents it tested, or its method. Those are STILL OPEN.

Why it matters: this is a workflow change you can try today, at no cost. Our analysis: a long session piles up old instructions, abandoned approaches and stale file contents, and the agent may keep weighing all of it. A fresh session starts clean, with only what you give it. Practical version: write a short brief for each task (goal, relevant files, what done looks like), run one task per session, save the result, then start over. Fewer tokens per turn may also lower cost on metered plans. That is our expectation, not a claim from the post.

What this means for you: if you use a coding agent, run a week of small, separate sessions and compare the results with your usual marathon session. Source: dev.to.

A terminal agent controlled by Telegram, running Claude, GPT and Qwen

A Habr post describes a CLI harness (a command-line wrapper that runs an AI agent) built on pi. It can be controlled through Telegram and puts Claude, GPT and Qwen models in one terminal agent. REPORTED: habr.com, headline-level. Licensing, install steps, cost, and how it limits who can send commands are STILL OPEN.

Why it matters: two ideas are useful even if you never install this tool. One interface across several model vendors makes it easy to switch when one model is too expensive or fails at a task. Background that is not from the post: Qwen models are available as open weights, which can lower costs. Remote control from a phone is convenient, but our analysis is that an agent that can run commands on your machine and takes orders from a chat app needs care. Limit who can message it, and run it in a sandbox or on a spare machine first.

What this means for you: developers and tinkerers can read it for design ideas. Anyone else should wait for a verified, documented release. Source: habr.com.

Agent-oriented API design: lessons from the Moltbook protocol

A dev.to article draws design lessons from the Moltbook protocol for building APIs meant to be called by AI agents rather than by human developers. REPORTED: dev.to, headline-level. The specific patterns the article recommends are not in what we have, so we won't list them. STILL OPEN.

Why it matters: more software is now being called by agents, and an API built only for human readers can trip them up. General practice, not from the article: agents read documentation and error messages as plain text, so clear, specific errors, predictable naming, and safe retries tend to help. If you expose any endpoint or webhook that an agent could use, that is worth thinking about now.

What this means for you: if you build or maintain an API or an automation others will connect to, read the full article and check which of its patterns fit your case. If you only use agents, nothing changes today. Source: dev.to.

SandboxAQ expands Switch AI for enterprise agent workforces

SandboxAQ has expanded Switch AI. The company says the aim is to give enterprises greater choice, control and accountability across their agentic AI workforce, meaning teams of AI agents doing work inside a company. REPORTED: PR Newswire, a company-issued press release. That makes the claims the vendor's own and unverified. Pricing, supported models, customers, and what the controls actually do are STILL OPEN.

Why it matters: the pitch, choosing among models while keeping oversight, matches a real worry as agents take on more tasks. Our analysis: the words "control" and "accountability" are only worth something if you can see what an agent did, stop it, and switch models without rebuilding everything.

What this means for you: whether you run a small business or sit on a team evaluating agent tools, ask any vendor three questions. Which models can I swap between? Is every agent action logged where I can read it? Who can pause an agent, and how fast? Source: PR Newswire.

Your coding agent's 1M-token context may be a trap

A dev.to post argues that a million-token context window is a trap for coding agents, and that small tasks in fresh sessions win. REPORTED as a practitioner's argument. The excerpt we saw has no benchmark numbers, and whether it holds for your model is STILL OPEN.

Why it fits open models (our analysis):

• Memory. A local model keeps working notes for every token it has seen, called the KV cache. The longer the session, the bigger the cache, and a huge window can push you off fast GPU memory into something slower.
• Attention. Models tend to use the middle of a long prompt less reliably than the start and end (see the research section).
• Compounding. An agent re-reads everything each turn, so stale file contents and abandoned plans stay in view and keep steering later decisions.

The counterpoint: a big window is useful for read-only questions like 'where is this function used?'. The article's target is the edit loop, where multi-step changes pile up mistakes.

Who benefits: people running Qwen (an open-weight model family) locally on modest hardware, and anyone paying per token. Who loses: paste-everything workflows and the headline spec on a model card. Hidden cost: discipline. Fresh sessions only work if you write down what happened.

Outlook (analysis, not fact): window sizes will keep growing in the marketing, but the winning habit is scoped tasks with explicit handoffs. Verify it yourself: run one task twice, once in a long session and once in a fresh one, and count passes.

Source: dev.to.

For builders: 250 sessions, 590 off-tool file writes, one phrase

A Russian-language engineering write-up on Habr describes a terminal coding agent built on pi (a base for terminal agents) that switches between Claude (an AI assistant), GPT (OpenAI's model family), and Qwen, and can be controlled through Telegram (a messaging app).

The measurement: across 250 of the team's own sessions, the agent wrote to files through the shell about 590 times despite having dedicated edit and write tools. 442 of those writes traced to a single phrase. Plain comparison: about two and a half off-tool writes per session, and roughly three in four from one phrase. REPORTED: the team's own measurement. We have not seen the traces, and the phrase is not in the summary we saw, so that is STILL OPEN.

Mechanism. A harness is a loop: it sends the conversation and tool definitions to the model, the model returns a tool call, the harness runs it and feeds back the result. The edit tool is structured: a path, old text, new text. It fails if the old text is not found, which is a safety net. The write tool takes a path and contents. The shell tool takes any string. A model fluent in shell can reach for a redirect, tee, a heredoc, or in-place sed, and skip the exact-match check, the reviewable diff, permission rules scoped to file tools, and logs that count a file change as an event.

Why one phrase could do this (our analysis): models are sensitive to wording. A phrase in a system prompt, a skill file, or a user habit can tilt a model toward the shell. The concentration is the news: when 442 of 590 share one source, one prompt edit could remove most of the problem.

Novel vs. incremental: multi-model harnesses and Telegram control are incremental. The method is the novel part: log every tool call, classify the shell commands that write files, and group them by the prompt text that preceded them. Any team can copy it, including teams running open models locally.

Limits: one team, one workflow, 250 sessions, and no per-model breakdown in what we saw. Do not conclude that Qwen behaves differently from Claude or GPT here.

Source: Habr.

Fresh-session task slicing with a handoff file

This is an illustrative workflow, not a tested one. It is lesson material, not news. For: anyone using a coding agent with open or hosted models. Problem: long sessions drift and get expensive. Prerequisites: a coding agent, a git repo, a test command.

1. Write the task as one sentence plus a done-test, a command that passes or fails, such as your test suite. No done-test means the task is too vague.
2. Size it. If you cannot describe the change in three sentences, split it.
3. Set context deliberately. Most local runners expose a setting for context size, such as a context-size flag or parameter. An illustrative starting point is 16,384 tokens; raise it only when a task fails for lack of room.
4. Start a fresh session and give the agent only the task, the relevant files, and HANDOFF.md.
5. Before closing, have the agent update HANDOFF.md in 15 lines or fewer.
6. Verify yourself: run the done-test, read the git diff, commit.
7. Close the session. The next task starts clean.

HANDOFF.md
Changed: (files and why)
Decisions: (and the reason)
Failed or abandoned: (what not to retry)
Next: (one task)

Expected output: a trail of small commits and a handoff file that reads like a lab notebook. Limits: it struggles when changes are tightly coupled across many files, and the handoff is only as good as what the agent writes. How to verify it worked: compare with your old habit on similar tasks and count how many needed rework.

The napkin math on fresh sessions

Illustration with assumed numbers, not a measurement. One long session runs 30 turns, and each turn re-sends about 100,000 tokens of context: 3,000,000 input tokens. Split the same work into three fresh sessions of 10 turns, each carrying about 20,000 tokens: 600,000 input tokens. That is one fifth of the input, or about 80% fewer tokens, under these assumptions (an estimate).

Pricing: multiply by your provider's per-million-token input rate. No price appears in today's stories, so check the current price on the pricing page of whichever you use: hosted open-model providers such as Together AI or Fireworks AI, or the Anthropic and OpenAI APIs.

Caveat: Some providers offer prompt caching, which can discount repeated context, so your real baseline may be lower. Check how your provider bills cached tokens. Running locally there is no token bill, but shorter prompts still respond faster.

What you give up: time writing handoffs, and anything the model forgets because it did not make the notes.

Prompt clinic: scope, finish line, and tool discipline

Weak: 'Fix the login bug in my project.' It has no scope, no finish line, and no rule about how files change.

Better (illustrative, not tested):

You are working in a fresh session on one task.
TASK: Fix the bug where the login form accepts an empty password.
DONE WHEN: the command 'npm test' passes.
FILES YOU MAY TOUCH: the login handler and its test file.
Start by reading HANDOFF.md.
RULES:
1. Change files only with your edit or write tools. Never modify files through shell commands such as redirects, tee, or sed in-place. Use the shell only to run tests and read files.
2. State your plan in 5 lines or fewer before editing.
3. If you need a file that is not listed, ask me first.
4. When the test passes, update HANDOFF.md in 15 lines or fewer and stop.

Why it works: scope keeps context small, the done-test gives a finish line, and rule 1 reflects the Habr audit. We do not know that team's trigger phrase, so we are not copying it.

Customize: the test command, the file list, the language. Quality check: search your tool log for shell commands that write files, and run git diff to confirm only the listed files changed.

Lost in the Middle

Background we are adding, not from today's reporting. Look up the paper to verify. A study called 'Lost in the Middle' tested language models on questions where the answer sat somewhere inside a long block of documents, the text a model reads at once, called its context. Accuracy was typically best when the answer was at the start or end, and dropped when it was buried in the middle. It tested earlier models, so newer ones may do better. Whether yours does is STILL OPEN.

Decision this week: put your task and hard rules at the very top, restate the critical one at the bottom, and test your model by moving one key fact from the middle to the top to see whether answers change.

Agentic AI is the busiest lane in the news right now, with open-source close behind. Today's stories show both pressures: money flowing into hardware, and teams learning that agents need discipline before they need bigger windows.

Our read (analysis): the next wins for open-model users come from measuring your own agent's behavior more than from the next release. Watch: follow-up detail on Tenstorrent's investors and Galaxy servers, which would turn a funding headline into something you can plan around. No date announced.

My agent has a million-token memory, and still ignored the one rule I buried in the middle.

That's it for today. Tomorrow we're watching for more detail on Tenstorrent's Galaxy servers, and for anyone who replicates that 250-session tool audit. If this made you smarter, share it with one person who needs it. Thank you for spending your time with us.

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