AiDevCraft retweeted
I've been exploring new ways to sandbox code written by coding agents - here's a description of the external sandbox pattern, where agents run on your Mac but execute code in a WebAssembly or QEMU or Apple Container sandbox - with demos for Claude Code, Codex and Pi blog.primeradiant.com/extern…

ALT Diagram: on your Mac, a coding agent (Claude Code, Codex or Pi) sends commands to a sandbox server on localhost, which runs them in a Linux VM. The VM exchanges files with the folders you mount, and reaches allowed hosts on the internet through a proxy with an allow-list. Those are the only two ways out of the VM.
Someone built a dating sim where you date Logs, Metrics and Traces.
Traces only shows up to 1% of your dates 😂
It runs real ClickHouse in your browser via chDB WASM. You can turn on SQL to see the checks behind the story.
I had to check. It works.
highcard.love/
Replying to @monicasarbu
It is exciting to imagine: Xata, our managed PostgreSQL team, and pg_chdb coming together to create a product with such incredible technical vision!
【PyCon JP 2026】Rediscovering DataFrames 100× Analytics Without Leaving P... youtu.be/ndmIZxi8A-M?si=12Ze… via @YouTube
AiDevCraft retweeted
出たばかりのDaVinci Resolve Studio 21.2、さっそく入れて、Claude CodeからMCPで触ってみました。
いちばん効きそうなのは、AIが自分で組んだタイムラインを「AIの目で」確かめられるようになったこと。MCPのツールが14から18に増えて、コマを画像で返してくれる道具が入りました。
静止画の長さを詰める、Text+を置く、スクリプトから書き出す、の3つも、21.1で回り道していた所が、私が試した範囲では素直に通りました。
ただ、DaVinci ResolveでAI動画編集している人は2つだけ気をつけてください。
・クリップが重なる所に置いたり動かしたりすると、「成功」と返しながら、そこにあったクリップを削ります
・無音を自動で詰める新しい関数は、今の版だと「成功」と返して、クリップごと消えました
なので置く先を空のトラックにして、結果を必ず読み戻しています。この確認を挟んでも、私が手で組むより10倍以上速くなりました(私が遅いってのはさておき)。素材の整理、波形でのタイミング合わせ、トラックへの配置。めんどくさい所を、全部やってくれます。
「センセイ、いかがでしょうか」「うむうむ、じゃあ見てみようか」って感じですよ。
自動化前提で、APIを何年も整えてきたBMDさん、さすがです。
#DaVinciResolve #ClaudeCode #MCP
DaVinci Resolve 21.2!PROLED XDRディスプレイを搭載したApple MacBook Proにおけるタッチスクリーン操作、M5 Pro/M5 Maxチップでの最大5倍速のエフェクトレンダリング、第6世代のBlackmagicカラーサイエンスLUTをサポート。今すぐダウンロード bmd.link/jp/CKYRvz
2
13
1,017
As I've mentioned in many of my @chdb_io related talks, turning an embedded database into a distributed database is undeniably a very difficult process. Conversely, taking a distributed database engine and refactoring it into a similarly production-ready embedded database is relatively much easier.
軽量Voxel水理システムの開発進捗💧
今回は、水の形状を再現する方法と、水量・運動量を正しく受け渡す仕組みの検証を進めました。
水面の向きを28候補から選ぶ方法では、近傍の形状へのフィット誤差が約7.7%低下。
ただし、一部で角の形状が悪化し、測定した局所処理の時間は約60倍に。今回の案は採用を見送りました。
計算する軸の順番を交互に変える案も、今回の条件では輸送後の誤差改善が0.1%未満にとどまり、目標には届かず。
一方、水量・運動量の受け渡しを確かめる検証は前進。
保存候補から検査用データを再構築し、全12,288面の独立検査や輸送量の上限確認などを通過しました。
現在は保存データを使った限定検証まで。今回の候補を実際の輸送処理で動かす検証は、これからです。
改善の効果、計算時間、数値の整合性。
それぞれを確かめながら、軽くて自然な水を目指して進めています。
#個人開発 #ゲーム開発 #Voxel
日々勉強660日
🤖 Made with AI
1
11
143
I was working on security updates for @brimblehq recently when I realized Falco had dropped native gVisor support.
I couldn’t find a suitable alternative, so I spent the weekend building a gVisor plugin for Falco, using Claude Code to help along the way.
If you run gVisor and care about runtime security, check it out: github.com/pipethedev/falco-…
AiDevCraft retweeted
Claude Code: "Limit reached. Resets at 3:47am"
Me: sets alarm, wakes up, window already half gone
So I built Reset. A free, open source Mac menu bar app for people who live inside Claude Code.
Know where you stand
– Menu bar pill: orange "2:46 · 42%", red when you'll run out before the reset ("38% · out 10:07"), green "ready" when a fresh window is waiting
– Exact usage straight from your Claude account, not guesses
– Weekly limit warning from 80%, so a dead week isn't a surprise
– Work + personal accounts, each with its own window and countdown
Never miss a reset
– Phone alerts queued ahead of time, so they land even with the lid shut
– Auto-start: when your window runs out, it fires a one-word haiku prompt so the next one starts while you sleep
– Stay awake mode, no extra app
Let Claude pace itself
– MCP server: Claude can check how much window is left
– Set a budget per task. At 80% Claude wraps up, at the cap it downshifts to a smaller model
– Status line in your terminal
– One click sets both up
See what it's worth
– Dashboard: your usage at API prices vs what you pay, cache savings, cost per session, per project, per MCP server
– Right-click any session to copy the command that resumes it
– A share card of your month for X
Make it yours
– 8 desktop widgets. Fuse burns down your window and tells you how much to slow down to make the reset. There's a Game Boy one too
– Mascots that get tired as you burn tokens, fall asleep at the limit and wake up at the reset
Works with Codex, Gemini CLI and Antigravity too. Nothing leaves your Mac.
Also, this is my first app, so go easy on me. Feedback and updates are built in, so if something breaks or you want a feature, tell me right from the app.
Free, MIT, macOS 14+
msfbeast.github.io/reset
Not notarized yet, so the first launch needs Privacy & Security > Open Anyway. Widgets need a source build for now (two minutes, steps in the README)
Star it if it saves you a 3am alarm, and roast it if it doesn't. All feedback welcome
hadn't logged a restaurant on Beli since February
didn't want to scroll through 8 months of camera roll so i pointed Codex at Apple Photos
what it did:
> searched Apple Photos for food and restaurant queries
> extracted capture dates, timestamps, GPS pins
> filtered out screenshots, duplicates, home cooking
> grouped 300 photos into 56 meals
> matched restaurant names using menus, plates, GPS coordinates
then built me a local backlog page with thumbnails, map links, checkboxes to clear them all
how are people still sleeping on local agents?
No GIL, Real Gains: Porting a C++ Python Extension to Free-Threaded Python 3.14 @PyData Amsterdam 2026 youtu.be/soBWS_SlqJc?si=LQ5_…
3
3
525
AiDevCraft retweeted
What does it mean to work with AI agents in a fundamentally multiplayer way?
I can review a pull request by chatting with the EXACT SAME agent that was used to develop it (which cost almost $700 lol).
I can see the code diff right there, and leave comments to the agent on it.
I can also easily pull in the human developer with an @-mention.
And I never have to check code out locally. The live app preview is running on the agent's sandbox, so I can use it if I don't trust the agent's (or the QA agent's) screenshots/videos of the feature.
Can someone tell me how I'm supposed to use the $250 cloud environment credit that Claude Code gives you?
Most of my projects are developed locally. I've got a lot of set-up debugging environments locally, along with various environment variables, keys, emulators, and large test data that can't be committed to Git (like a bunch of parquet files). I really can't figure out how to make use of those $250 tokens.
How is everyone else using them? Any inspiration or ideas would be appreciated.
1
3
464
AiDevCraft retweeted
Fuck it, still early but here goes ...
We've just released Monty v1 - a Python sandbox that starts in 1 millisecond, not 1.5 seconds.
I just ran 10k sandboxed scripts in 674ms, something that would take a cloud sandbox > 3 hours.
This removes the biggest drawback of letting agents write code. The future is fast.
Even better, it's open source, you can install it from PyPI, npm or Crates now.
Serviced platform coming soon. Please get in touch if you want to be a design partner!
Who should try it?
⚡ if you care about startup time, use Monty
⚡ if you care about long-lived sessions, use Monty - Monty can be dumped and resumed at any external function call
⚡ if you care about accessing functions in the agent/host, use Monty - Monty makes it trivial to expose local functions into the sandbox
⚡ if you care about scale, use Monty - Monty workers use as little as 2MB of memory, meaning you can run thousands of concurrent sandboxes on a single machine
⚡ if you care about security, use Monty - we've run 3 rounds of bounty program and thousands of researchers have tried to break into our sandbox, meaning it should be secure to run untrusted code
Who should avoid it?
🚫 if you like to take a coffee break while waiting for sandboxes to start, DO NOT use Monty
🚫 if you enjoy the challenge of routing API requests from sandboxes through your corporate network to access state in your agent without exposing secrets to the sandbox, DO NOT use Monty
🚫 if your agent really needs to install packages from PyPI, Monty won't help you yet (spoiler: it probably doesn't)
pydantic.dev/docs/monty/get-…
AiDevCraft retweeted
Hey guys! This is the story from StepFun Harness Team.
Let's talk about Step Code.
Step Code launched and went open source today. It's nothing fancy — just a plain CLI, the same one we use every single day. Here's the story behind it.
1. Why the logo is a duck (it's actually a pelican)
It goes back to our first usable agent model, Flash 3.5. It wasn't strong, but it was fast. The results were rough. That was the moment a simple idea hit us: what if we could make our model perform better by strengthening the harness itself?
The meme came from Pic 1 & Pic 2
2. We screwed up
At one point we dreamed up a voice-based coding CLI. We even interviewed blind users for it. Reality slapped us hard. We open-sourced this voice CLI, and it became a ghost project where PRs outnumbered both issues and stars. The only thing that survived from it is the voice mode in our CLI today.
3. So we went back to basics
We decided to build a harness we would actually use ourselves. As a model company, our most frequent use case is evaluation. As part of cutting costs, our harness aimed at one thing from day one: same smarts, fewer tokens. It did make a difference like Pic 3
4. Eval reports got out of hand
Our evaluation outputs came in all shapes and sizes — HTML reports started outnumbering our Feishu docs by a mile. So we added static site hosting, just to make sharing HTML artifacts easier. (You do need a plan for it though.)
swift-otter-ca0f.page.stepcl…
That's it. That's all.
As a v0.1.0 release, it doesn't do formal reasoning like DSH, and it's nowhere near as polished as Claude Code. It's just a tool we use every day. We'll keep throwing our own use cases at it — like drawing pelicans. 🦩
If any of this sounds interesting and you want to give it a try:
platform.stepfun.com/step-co…
Oh, and it's open source. Issues welcome:
github.com/stepfun-ai/Step-C…
Introducing Step Code v0.1.0.
Swift execution. High token efficiency. Long-horizon reliability.
Now open source under the MIT License.
Step Code handles the full development loop—from reading and editing code to running tests and shipping—from one CLI.
- 80.9% on Terminal-Bench 2.1 in evaluation
- 73.3% on Multi-Frame, our 150-task long-horizon benchmark
- One-command static site publishing with StepPage
GitHub: github.com/stepfun-ai/Step-C…
AiDevCraft retweeted
here's a prompt to improve your agent harness based on what we've learned at cursor. enjoy
# Improve this agent harness's token efficiency
You're working on an LLM agent harness: the system prompt, tool definitions, request assembly, context caching, compaction, and retrieval, and how work is split across agents. Make the agent's runs cheaper without making it worse at its job.
- Objective: lower price-weighted token cost per completed task.
- Constraint: no measurable drop in task quality.
Measure per task, not per request. Every turn resends the prefix (tools, instructions, setup, and the conversation so far), so a change that shrinks each request but adds turns can cost more. Weight tokens by billing type: output, uncached input, and cached input are priced very differently.
Work in this order: map the harness and measure the baseline, rank the opportunities, make the changes that are safe to make directly, put the rest behind flags or in proposals, then report.
Figures below come from one team's production coding agent and its multi-agent experiments. Use them to gauge magnitude, not as targets. One round of these changes (prompt trimming, tool offloading, cache layout, sparse line numbers, subagent tuning) cut that team's overall token cost about 7% with no loss in quality. The larger percentages apply only to the part of the request each change touched.
## Principles
1. Change what the harness sends, not how hard the model tries. Don't ask the model to conserve tokens. A harness that told its model to "take care to preserve tokens and not be wasteful" found it grew reluctant to take on ambitious tasks and sometimes quit, saying it wasn't supposed to waste tokens.
2. Capable models need definitions, not commands. Lists of "DO NOT", "You must", and "Important", and guards against older models' habits, can usually be replaced with plain descriptions of what each tool does. One team cut about two-thirds of its system prompt this way, and the shorter prompt worked across model families. Instruct only on what the model can't know (the product, the environment, the user's processes) and on quirks you've seen in transcripts.
3. Static context is for what most turns need. Everything else should be discoverable when needed. Less up-front context also means less confusing or contradictory information.
4. Expect removals to win. Guardrails written for weaker models, coordination steps that became bottlenecks, and prompting for behavior the model now does on its own all cost tokens.
5. Real usage decides. Evals are a fast proxy, but they skew toward hard problems and miss the real mix of requests.
## 1. Map the harness and measure the baseline
Find:
- Where requests are assembled, the system prompt, and tool schemas. If a framework or SDK builds requests, find its hooks for message order, cache control, and tool loading.
- How tool results are formatted, and how history is kept, trimmed, or summarized.
- How subagents or parallel agents are spawned, if any.
- Which models and provider APIs are used. From the provider's docs, get the prompt caching behavior (automatic or explicit breakpoints, TTL, minimum cacheable length) and the prices for output, uncached input, and cached input.
- Existing logging, token accounting, and evals.
If the harness doesn't record per-request token usage by billing type and cache hits, add that first. Everything later depends on it.
Then render a few real requests (from logs, or by running representative tasks) and count tokens per section with the model's tokenizer or the API's usage fields. Produce:
- Cost share by source × billing type. Sources: system prompt, tool definitions, skill/rule/integration descriptions, user messages, file reads, search results, command and other tool output, history, summaries, subagents.
- Static tokens per request, cache hit rate, and turns per task.
- Per tool: the share of runs that call it at least once, and its error rate.
Read the rendered requests, not just the templates. Duplication, leaked volatile values, and misordered blocks only show up there.
Rank opportunities by share of spend × fraction removable ÷ quality risk.
## 2. System prompt and injected context
Label every instruction:
- Keep: product or environment knowledge the model can't infer, fixes for quirks seen in this model's transcripts, and rules a mode depends on.
- Rewrite: commands and emphasis into plain descriptions. Reminders into constraints: "No TODOs, no partial implementations" works better than "remember to finish implementations." Vague quantities into ranges: "generate 20–100 tasks" gets far more ambitious behavior than "generate many tasks."
- Delete: things capable models do by default, guards against behavior you haven't seen from this model, text that repeats tool descriptions, and lines that could contradict a user request. Models trained to rank system instructions above user messages will side with the system prompt.
- Move: anything per-user or per-request (date, environment, repo state, lists of skills or subagents, user rules) into a user-role setup message after the cache boundary.
Audit other injected context the same way. As models improved, the team behind these figures dropped directory trees, pre-retrieved snippets, compressed copies of attached files, lint errors injected after every edit, forced expansion of short file reads, and caps on tool calls per turn. They kept small, high-value facts: OS, repo status, and open or recently viewed files.
Skip checklists for open-ended work. The model optimizes the listed items and deprioritizes everything else.
## 3. Tool definitions
Tool schemas ride along on every request. Most tools beyond the core set were each needed in under 20% of conversations, and moving them out of static context cut tool-description tokens 60%. Doing the same for integration tools (such as MCP servers), with names in context and full schemas in one folder per server that the agent can search with grep or jq, cut total tokens 46.9% in sessions that used them.
- Keep in static context: high-frequency tools (for a coding agent: read, search, edit, shell), tools the model tries to call even when they're absent, and tools a mode depends on.
- Offload the rest: leave a name or one-line pointer and make the full schema discoverable on demand. Group related tools so they load together, and put status (such as "needs re-authentication") where the agent will see it.
- Tighten what remains: describe behavior and arguments, and drop usage lectures.
- Pick the split by testing a few configurations and tracking tokens, cost, latency, tool-call errors, and task success.
## 4. Cache layout
Order each request so the reusable prefix is as long as possible:
`tool definitions → system instructions → [breakpoint] → setup message (skills, subagents, rules, environment) → [breakpoint] → conversation`
- Keep the prefix byte-identical across turns. Use deterministic tool order and serialization, put timestamps and IDs after the boundary, and don't rewrite earlier messages except when compacting.
- Use explicit breakpoints if the provider supports them. Otherwise rely on automatic prefix caching with the stable part first. Respect TTL and minimum-length rules.
- Switching models mid-conversation throws away the cache (caches are per model and provider) and hands the new model a history it didn't write. When a different model is needed, run it as a subagent with fresh context.
Explicit breakpoints plus moving per-request setup after them cut cold cache misses 20%.
## 5. Tool results and other context added during a run
- Large outputs (commands, integrations, logs): write them to a file and return the path, size, and a short tail. The agent can tail, grep, or read ranges for more. Truncating loses data, and inlining bloats every later request. Treat long-running terminal sessions the same way.
- High-volume formats: look for overhead repeated on every line or item. Numbering every 10th line of a file read instead of every line cut cache-read tokens 1.6% without hurting citation accuracy. Each number costs 3–5 tokens, and agents read tens of thousands of lines per session. Also check repeated absolute paths, verbose JSON keys, ANSI codes, progress bars, and repeated headers.
- Good retrieval saves exploration turns. Adding semantic search alongside grep raised codebase question-answering accuracy 12.5% on average and cut the iterations users needed.
- Tool errors waste tokens and leave confusing debris in context. Classify expected errors (invalid arguments, unexpected environment, provider error, timeout, user abort), treat unknown errors as harness bugs, and track rates per tool and per model. One focused effort along these lines cut unexpected tool errors 10×.
## 6. Long runs: compaction, subagents, and model mix
- Compaction: keep the summarization prompt short and the summary compact, carry forward plan state and remaining tasks, and save the full history to a file the agent can search for details the summary dropped. A model trained to self-summarize from a one-line prompt wrote ~1k-token summaries with half the compaction error of a multi-thousand-token prompt that produced 5k+ token summaries. Untrained models may need more guidance, so test how short you can go. A more expensive summarization model made a negligible difference.
- Scratchpads and running notes: rewrite them instead of appending. For repeated work in one environment, a small agent-maintained notes file with a line budget, loaded at start, is a promising way to shorten later runs.
- Subagents: fresh context keeps the parent lean, but isolation adds coordination cost (duplicate or stale work). If the model already delegates on its own, remove prompting that pushes it to. Have subagents return short handoffs: what was done, findings, concerns, and deviations. A subagent should use a different model only when the user or harness says so.
- Model mix: in large multi-agent runs, workers used at least 69% of tokens, and over 90% in most runs. A frontier planner with cheap workers matched a frontier model doing everything at about one-eighth the cost. Planner choice still changes worker spend. One planner that cost less on its own saw its workers use several times more tokens, and the run cost more overall. Measure the whole tree.
- Routing and reasoning effort: send simple turns to a cheaper model or lower effort, and upgrade only when a stronger model is clearly better. A router built this way matched or beat single frontier models on user satisfaction at 41–68% lower cost.
- Reasoning continuity: if the API returns reasoning items (including encrypted ones), pass them back on later turns and alert when they go missing. Dropping them cost one reasoning model 30% on a coding benchmark, and it burned tokens reconstructing its plan.
## 7. Fit the harness to each model
Adapt to what each model was trained on instead of forcing one shape on all of them. If you've tuned the harness for a similar model, start from that version.
- Edit format: use the one the model was trained on (for example, patch-style or search-and-replace). An unfamiliar format costs extra reasoning tokens and causes more mistakes.
- Shell or tools: shell-first models fall back to `cat` or inline scripts. Name tools after their shell equivalents (such as `rg`), and if needed add: "If a tool exists for an action, prefer to use the tool instead of shell commands (e.g. read_file over `cat`)."
- Literalness: some model families follow instructions literally and others tolerate imprecision. Some spiral on emphasized wording. Strip caps and emphasis for literal models.
- Triggers: some models ignore a tool until told when to use it. A literal trigger works: "After substantive edits, use the <lint tool> to check recently edited files for linter errors. If you've introduced any, fix them if you can easily figure out how."
- Progress updates: if a model reports progress through reasoning summaries, keep them to 1–2 sentences that note new findings or a change of tactic, and remove instructions about messaging mid-turn.
- Quirks worth a targeted line: hedging or refusing as context fills ("context anxiety"), declaring completion early, stopping to ask permission, and calling tools that don't exist.
Tie each added instruction to the transcript behavior it fixes. Re-audit when models change, since guidance one version needed can be dead weight for the next.
## 8. Validate
- Offline: run a fixed set of realistic tasks before and after, ideally drawn from real usage and phrased the way users actually write (short and ambiguous). Compare task success, tokens, cost per task, turns, and tool errors. Don't ship a change that lowers success.
- Online, if you have users: A/B test each change or small bundle. The primary metric is cost per completed task. Guardrails are task success signals, tool-call errors, latency, turns per task, and cache hit rate. For a coding agent, a good success signal is how much agent-written code survives over time. In general, check whether the user's next message moves on or reports a problem.
- Ship only when cost drops and no guardrail regresses beyond noise. Record null results.
## What to change directly and what to propose
- Change directly, each in its own revertible commit: token and cache telemetry, deterministic serialization and tool order, moving volatile content out of the cached prefix, explicit cache breakpoints, writing large outputs to files instead of truncating, passing back reasoning items that are being dropped, and fixes for recurring tool errors.
- Change behind a flag so it can be tested: system prompt edits, tool offloading, output format changes, compaction changes, and subagent prompting.
- Propose only: changes to which models run, routing, reasoning-effort defaults, or how work is split across agents.
## Traps
- Asking the model to use fewer tokens or do less.
- Truncating tool output.
- Dropping reasoning items to save input tokens.
- Volatile content in the cached prefix, or tool order that changes between requests.
- Offloading a tool the model needs on the first turn or tries to call when it's missing.
- Emphasis-heavy prompts (MUST, NEVER, IMPORTANT, all caps), especially with literal models.
- Forcing a terser output format than the model was trained on. Fewer output tokens can mean less thinking and worse results.
- Optimizing raw token counts instead of cost, per request instead of per task, or evals instead of real usage.
- Switching models mid-conversation to save money.
- Adding coordination layers that become bottlenecks.
## Report back with
1. The harness map and baseline: cost by source × billing type, with the biggest sources called out.
2. A ranked list of changes: layer, what changes, estimated savings and how you estimated them, quality risk, how to validate, and how to roll back.
3. The changes you made, including a system prompt diff with a keep, rewrite, delete, or move reason for each line.
4. A test plan for the flagged changes.
5. Gaps: anything you couldn't find or measure.
Replying to @MiaAI_lab
Maybe, for my three DGX Spark, the best setup is probably running DeepSeek v4.1 Flash on 2 of them and Qwen 3.8 Flash on the other one.🤔
1
1
160
AiDevCraft retweeted
get yourself an agent harness that cares about diagrams. I'm sick of reading walls of text!
AiDevCraft retweeted
Day 6 of posting my favorite skills / CLI tools / AI agent harness stuff:
Ponytail, a skill that makes your agent code like the most effective senior dev that respect DRY and short code as much as possible.
Around 54% less code on real agentic benchmarks, without cutting safety checks.
github.com/dietrichgebert/po…




























