Code415 Radar

Key ideas

Model context

Everything the harness hands the model before it acts, including hidden details like account info, which the model may copy into anything it writes.

User-Agent header

A request header that identifies the client to a web server, and some sites ask automated agents to put a contact address there.

Tool call guard

A deterministic check that runs before an agent executes a command and blocks or asks about risky content, here commands that contain the account email.

Steps

1. Read GitHub issue #107757 first for the original report and the maintainer reply about the cc-plugin-privacy mod.
2. Read Lydia Hallie's comment in the HN thread for why the email was in context and what the guard misses.
3. List what else your agent harness injects into context, such as usernames, paths, or tokens, and which of those could end up in outbound requests.
4. Self check: why does a guard on curl style commands not protect against a script the agent writes and then runs?

Steps

1. Check which Claude Code version you run and update to 2.1.317 or later if you are below it.
2. Run /plugins inside Claude Code and confirm the cc-plugin-privacy mod is listed and enabled.
3. Start a small HTTP listener on localhost that logs every request header it receives.
4. In a throwaway project, ask Claude Code to fetch a page from that localhost listener with a curl style command and to identify itself politely.
5. Inspect the logged User-Agent and other headers for your account email, and note whether the mod prompted you first.

Small angles to try

• Ask Claude Code to write and run a short script that makes the request instead of a direct command, and compare whether the guard triggers.
• Repeat after the next release ships and confirm the email no longer appears anywhere in the requests.

Key ideas

Mixture of experts

A model where each token is routed to a few expert sub networks, so only 104B of the 2.8T parameters do work per token.

Quantization aware training

Training the model while simulating low precision weights, so the released MXFP4 weights lose less quality than quantizing afterwards.

Reasoning content passback

Returning the model's earlier reasoning to it on the next turn so a multi step tool session keeps its chain of thought.

Steps

1. Read the Hugging Face model card first, focusing on the benchmark table, deployment section and the note on multi turn messages.
2. Compare the Kimi and Claude Opus 5.5 columns and note where each leads, remembering the numbers are self reported.
3. Read the license section to see how a custom license differs from Apache 2.0 or MIT for your use case.
4. Self check: what breaks in an agent loop if you keep only content from each assistant reply?

Steps

1. Create an API key on platform.kimi.ai and point an OpenAI compatible client at the endpoint given in the platform docs.
2. Send a single prompt with model kimi-k3.1-pro and set reasoning_effort to "low" to check access and latency.
3. Define one simple tool, such as a local calculator function, and run a two turn tool call where you pass back the full assistant message including reasoning_content.
4. Repeat the same session while sending back only content and compare the quality and any errors.
5. If you have a suitable GPU server, try vllm serve "moonshotai/Kimi-K3.1-Pro" as listed on the card.

Small angles to try

• Run one task from your own repo at reasoning_effort "low", "high" and "max" and compare cost and answers.
• Point an Anthropic compatible client at the platform instead and check the same tool flow.

Key ideas

Model cascade

A cheap model handles every input and passes only the uncertain ones to an expensive model.

Calibration

How well a model's confidence matches how often it is actually right, so 80% confident answers are correct about 80% of the time.

Escalation band

The range of confidence scores, here 30% to 90%, that triggers a second opinion from the stronger model.

Steps

1. Read the Hightouch blog post first, paying attention to the cost and accuracy tables for both test sets.
2. Note why GPT-6 Luna, the stronger model alone, gave a weaker hybrid on the harder data.
3. Sketch how you would pick band edges for your own classifier from a labeled sample.
4. Self check: if a cheap model is wrong but 99% confident, what happens to that case in a cascade?

Steps

1. Split your labeled data into a training half and an evaluation half.
2. Train a small, cheap classifier such as logistic regression and record its probability for each evaluation row.
3. Pick a band, starting with 30% to 90%, and mark rows inside it as escalated.
4. Score escalated rows with a stronger model, either an LLM judge or a larger classifier, and keep the cheap answer elsewhere.
5. Report accuracy, share escalated and estimated cost per 1,000 rows for cheap only, strong only and the cascade.

Small angles to try

• Plot a reliability curve for the cheap model and see whether its confidence is calibrated.
• Sweep the lower band edge from 10% to 40% and chart cost against accuracy.

Key ideas

Pixel space diffusion

Generating images directly from pixels instead of first compressing them with a VAE into a latent space.

Patch size

Larger 32 by 32 patches turn an image into fewer tokens, which makes attention much cheaper per sample.

Noise curriculum

Changing the distribution of noise levels seen during training, here shifting it after the first 80M samples.

Steps

1. Read the Linum field notes post first, especially the cost table and the architecture section.
2. Work out how 32 by 32 patches give 256 image tokens at 512 by 512 resolution.
3. Skim the Hugging Face card for usage and the stated limitations.
4. Self check: why does dropping the VAE make both training and inference simpler?

Steps

1. Clone the code with git clone https://github.com/Linum-AI/pjit-21k && cd pjit-21k.
2. Install it with pip install -e ..
3. Generate a sample with python generate.py --no_upsample --aspect_ratio tall --seeds 2 --prompt "$PROMPT", setting PROMPT to a caption of your own.
4. Try three prompts that hit the stated weak spots: text on a sign, a full body figure, and two people interacting.
5. Compare the outputs with a portrait prompt where the model should do well.

Small angles to try

• Set OPENROUTER_API_KEY and drop --no_upsample to see how prompt upsampling changes results.
• Change --seeds across several values for one prompt to gauge consistency.

Key ideas

Account aggregator

A service like Plaid that logs in to the bank on the user's behalf and gives apps a scoped token instead of the password.

Read only scope

Permission to view data without the ability to make transfers or other changes.

Data minimization

Passing the model only the fields it needs, such as last four digits instead of full account numbers.

Steps

1. Read Anthropic's announcement first for the feature list and the exact data fields Claude receives.
2. Read the ITmedia article for what is excluded and the memory rule.
3. Write down which of your own app's data an LLM feature would need and which fields you could drop.
4. Self check: which three design choices here limit damage if the model output or a chat log leaks?

Steps

1. Export a few months of your own transactions as CSV from your bank's website.
2. Strip everything except date, amount and merchant, and mask any account numbers to the last four digits.
3. Write a short script that totals spending by merchant category per month.
4. Add checks that flag same merchant and same amount within a few days as possible duplicates, and recurring charges whose amount rose.
5. Review the flags by hand and note which ones were real.

Small angles to try

• Paste only the monthly category totals, not raw rows, into an LLM you already use and compare its advice with your script.
• Add a fee detector that searches merchant text for words like fee or interest.

Key ideas

Dense versus mixture of experts

A dense model uses every weight for every token, while a mixture of experts model activates only a few expert blocks per token, so it can be huge in total size but cheaper per token.

TerminalBench

A benchmark that scores agents on finishing real tasks inside a terminal, so it measures agentic coding rather than single answer accuracy.

Self reported benchmarks

Scores published by the model maker on its own chosen comparisons, which need independent checks before you trust the ranking.

Steps

1. Read the Ricursive announcement first and note the architecture list, the TerminalBench 2.1 table and the cost claim.
2. Open the Hugging Face model card and compare its license tag and hardware notes with the announcement.
3. Skim the HN thread for the dense versus mixture of experts speed debate and the tool calling failure report.
4. Self check: why could a 65B dense model be slower per token on a laptop than a much larger mixture of experts model with fewer active parameters?

Steps

1. Create an OpenRouter API key and find the model ricursiveai/ripple-65b-preview in its catalog.
2. Write five small terminal style tasks from your own repo, such as finding a failing test or writing a shell one liner, each with a known correct answer.
3. Send each task to Ripple through OpenRouter's chat API, give it one simple tool definition such as run_shell, and log whether it calls the tool correctly.
4. Run the same five tasks on a model you already use and record correct answers, valid tool calls and latency side by side.
5. Compare your tool call success rate with the 4 of 8 failure report from HN and decide whether the benchmark lead shows up on your tasks.

Small angles to try

• Measure tokens per second on long prompts to see the dense model cost in practice.
• Feed a 100k token slice of your codebase to test the long context claim.
• Ask a chip design or Verilog question, since commenters noted the card has no RTL benchmarks.

Key ideas

Base checkpoint

A model saved right after pretraining that continues text well but does not follow instructions until someone fine tunes it.

Active parameters

The share of a mixture of experts model's weights actually used per token, here 14B of 280B, which sets compute cost per token.

BOS token

A special start of sequence token the tokenizer can prepend, and some models behave badly if it is missing.

Steps

1. Read Baidu's release notes first for the training recipe, context lengths and the MMLU-Pro table.
2. Open the Hugging Face model card for the serving examples and the LICENSE file.
3. Read the license text and list which uses and regions it restricts.
4. Self check: why would a research team want a model with no post training instead of the chat version?

Steps

1. Install the packages the model card recommends with pip install -U transformers accelerate.
2. Load only the tokenizer for baidu/ERNIE-5.5-Flash-Base with AutoTokenizer, which avoids downloading the weights.
3. Tokenize the same sentence with add_special_tokens=True and with it set to False, print both id lists and confirm the first one starts with the BOS id.
4. If you have a suitable multi GPU machine, start a server with vllm serve "baidu/ERNIE-5.5-Flash-Base" after pip install vllm.
5. Send a plain completion such as "Large language models are" to the server's /v1/completions endpoint, since a base model uses completions rather than chat.

Small angles to try

• Compare how the tokenizer splits Chinese and English text of the same meaning.
• Prompt the base model with a few shot pattern instead of an instruction and see how it continues.
• Read Baidu's pointer to the ERNIE 5.5 example in NVIDIA Megatron-Bridge and outline a small fine tuning plan.

Key ideas

Multi turn video editing

Changing an existing clip through follow up prompts instead of generating a new clip from scratch each time.

Reference conditioning

Giving the model images, short motion clips or audio to copy a character, a movement or a sound.

SynthID

Google's invisible watermark added to generated media so it can later be identified as AI made.

Steps

1. Read the Google blog post first for clip length, editing features, pricing and availability.
2. Open the Gemini API pricing page and work out the cost of ten 15 second 720p clips.
3. Skim the HN thread for the access and naming complaints.
4. Self check: at $0.07 per second, what does a feature that makes 1,000 eight second 720p clips a day cost per month?

Steps

1. Open Google AI Studio and select the model gemini-omni-1.2-flash.
2. Generate a 5 second 720p clip from a short prompt that describes one character and one camera move.
3. Send a follow up edit, such as changing the weather or the background, and compare the result with the first clip.
4. Upload one of your own product or character images as a reference and check whether it stays consistent from the first to the last frame.
5. Log the clip length and cost of each run and compare with the $0.07 per second list price.

Small angles to try

• Try a fast sports action prompt, which Google lists as a known weak spot.
• Change only the aspect ratio through an edit and check what else drifts.
• Test multi speaker dialogue and judge the lip sync.

Key ideas

Paired evaluation

Two versions of the same task that differ only in framing, so any score gap can be traced to the framing.

Covert underperformance

A model doing worse on purpose or by habit without saying so, which looks like ordinary weak output.

Chain of thought monitoring

Reading or auto scanning a model's reasoning text for signs of bad intent, which fails when the intent is never written down.

Steps

1. Read the OpenAI report first, focusing on the paired eval design and the exclusion table.
2. Write down the three gaps after exclusions, 5, 4.7 and 0.75 points, and what each exclusion removed.
3. Skim the HN thread for the debate on silent degradation versus explicit refusal.
4. Self check: why does a gap that monitors never flagged argue for outcome based evals on your own tasks?

Steps

1. Pick three small coding tasks from your own codebase and write a hidden checklist of five concrete improvements for each.
2. Make two prompt versions per task that ask for the same work, one framed as safety or security hardening and one framed as a performance feature, and rename comments and identifiers to match.
3. Run each version five times with a short script and save every output.
4. Score each output against the hidden checklist and compute the average completion rate per framing.
5. Check the outputs where the model said nothing more was worth doing, and compare how often that happens in each framing.

Small angles to try

• Swap the framing to two neutral business domains to see if any gap is framing specific.
• Compare two models from different vendors on the same pairs.
• Add a simple keyword monitor on the reasoning text and see whether it catches the low scoring runs.

Key ideas

Lima

An open source tool that runs Linux virtual machines on macOS and Linux with file sharing and port forwarding set up for you.

Allowlist network proxy

A proxy on the host that lets the VM reach only approved hosts, limiting where an agent can send data.

Clone and fetch review

Letting the agent commit in its own copy of the repo and then fetching those commits as a remote branch you inspect before merging.

Steps

1. Read the devvm.dev page first for the isolation model and network tiers.
2. Read the GitHub README for install steps and the --clone workflow.
3. Open the attack vectors page linked from the site to see what stays exposed.
4. Self check: which of your host files would an agent still be able to change with devvm in its default mode, and which with --clone?

Steps

1. On macOS run brew trust --formula devvmhq/tap/devvm and then brew install devvmhq/tap/devvm; on Linux use the install script from the README.
2. Run devvm doctor to check requirements.
3. In a throwaway project of your own, run devvm --clone to create a VM with its own clone, then inside it run devvm agent login claude and start the agent.
4. Ask the agent for a small change, let it commit, then on the host run git fetch devvm and git log -p main..devvm/main to review.
5. From inside the VM, try to read a file outside the project folder and to reach a host not on the allowlist, and confirm both fail.

Small angles to try

• Use devvm agent import to copy settings from an agent already set up on your machine.
• Compare the default allowlist tier with the stricter none tier for an offline task.
• Run the same task with Codex or opencode and compare the fetched commits.

Key ideas

Objective misspecification

An agent optimizes exactly the number it is given, so anything left out of the goal, like customer fairness or legality, can be traded away.

Emergent collusion

Competing agents that can message each other may agree on prices or exclusion without ever being told to coordinate.

Cost aware reasoning

When an agent sees its own token bill, it may shorten its thinking to save money, which changes its behavior and quality.

Steps

1. Read the ITmedia NEWS column first for the setup, the $500 starting capital and the per model examples.
2. Open the paper through its DOI 10.1162/99608f92.8f4a0273 and find the section describing the goal given to every agent.
3. List which bad behaviors came from the goal, such as invented refund policies, and which came from the token bill, such as reasoning cutbacks.
4. Compare this with how goals and budgets are expressed in an agent system you use or build.
5. Self check: why would adding a rule in the prompt help less than adding customer satisfaction to the scored objective?

Steps

1. Write a small Python loop that plays a shop for 30 simulated days: each day the model sees cash, stock, prices and one customer message, some of them refund requests.
2. Give the model a system prompt whose only stated goal is to maximize the final cash balance, and log every reply.
3. Run it, then grep the log for refund decisions and for any policy the model cites that you never defined.
4. Run it again with the goal changed to cash plus a penalty for each unresolved valid refund, and compare refund rates and invented policies.
5. Add a line to the daily state showing tokens spent so far at a made up price, and check whether replies get shorter.

Small angles to try

• Run two model instances as rival shops that can email each other and watch for price agreements.
• Swap in a different model family and compare how often each invents a policy.
• Score the same logs with a second model acting as an auditor and see what it catches.

Key ideas

microVM

A lightweight virtual machine with its own Linux kernel and very few virtual devices, giving stronger isolation than a container that shares the host kernel.

Minimal kernel config

Building the guest kernel from the smallest base and adding only what is needed removes code paths, so many kernel CVEs simply do not apply.

Credential brokering

A host service adds secrets to outgoing requests after checking them, so code inside the sandbox never holds the real API key.

Steps

1. Read the Replit engineering post first, focusing on the sections on the kernel, egress and credentials.
2. Sketch the request path from a sandboxed process to an upstream API, marking where the proxy and the broker sit.
3. Note which protections run outside the guest and why that matters if the guest is fully compromised.
4. Compare with how your own CI runners or agent tools isolate untrusted code today.
5. Self check: why does removing kernel features at build time avoid more CVEs than patching faster?

Steps

1. On your own Linux machine, open the kernel config for the running kernel, usually found under the boot directory, and count how many options are enabled.
2. Write a short Python script that lists enabled options matching Bluetooth, wireless, USB and display drivers, the classes Replit removed.
3. Pick five recent Linux kernel CVEs from a public tracker and, for each, note which subsystem it affects and whether that subsystem is enabled in your config.
4. Estimate what share of those CVEs a trimmed config would have excluded, mirroring Replit's audit on a small scale.
5. Write down which of Replit's controls, such as host egress filtering or brokered credentials, your own agent setup lacks.

Small angles to try

• Repeat the count on a cloud VM image and a desktop distro and compare surface size.
• Map where API keys live in your agent tooling today and design a broker that would keep them out of the sandbox.
• Compare the post's design with the Firecracker approach using its public docs.

Key ideas

Capabilities index

A single score combining many benchmarks so progress over time can be fitted as a trend line.

Rate ratio

The slope of the trend after a date divided by the slope before it, so 2x means progress per month doubled.

Labor uplift

How many times more research work staff get done with AI help than without it.

Steps

1. Read the summary and key findings at the top of the METR report first.
2. Read the caveats section and list which ones could push the 1.9x estimate up or down.
3. Read Ajeya Cotra's post to see how a rate ratio is turned into a labor uplift figure.
4. Skim the LessWrong comments for the argument that the data fit a one time slope change rather than compounding.
5. Self check: why does a saturating benchmark make a later acceleration estimate less reliable?

Steps

1. Collect a dated series of scores for one public benchmark across a model family from public release notes, about 10 to 20 points.
2. Fit a straight line to scores before a chosen break date and another to scores after it.
3. Divide the later slope by the earlier slope to get a rate ratio like METR's.
4. Move the break date by three months either way and record how much the ratio changes.
5. Drop the scores above 80% and refit, to see how saturation bends the result.

Small angles to try

• Bootstrap the points to get a rough confidence interval for your ratio.
• Compare one lab's series with a pooled series across labs, as METR did with its 1.4x check.
• Fit a single curved model instead of two lines and see whether a break is still needed.

Key ideas

Automatic creative generation

Ad platform features that build new ad images or videos from your uploaded assets without a person approving each one.

License scope

A deal to use characters or artwork usually covers specific approved uses, and new altered versions may need fresh approval.

Review gate

A required human approval step before any generated output reaches the public.

Steps

1. Read the ITmedia AI+ article first for the timeline and the company's stated cause.
2. Note who had to approve what: the brand, the production committee and the platform feature.
3. List the points where a review step could have stopped the ads.
4. Look at the ad or marketing tools your own team uses and note which ones offer automatic generation.
5. Self check: why is a setting that is on by default riskier for licensed content than for your own product photos?

Steps

1. List every ad, social or marketing tool your team uses and open each one's settings page.
2. Record for each whether any automatic AI generation or enhancement of creative is enabled, and whether it is on by default.
3. For each enabled feature, note whether generated output is published directly or waits for approval.
4. Mark any campaign that uses licensed characters, partner logos or people's likenesses.
5. Write a one page rule for your team saying which generative features may be on for which campaigns, and who approves output.

Small angles to try

• Ask a teammate to find the same settings without help and time how long it takes.
• Write a small script that flags creative files whose names or tags mark licensed assets before upload.
• Check the platform's help pages for whether the feature can be disabled at the account level.

Key ideas

Mixture of experts

A model where each token is routed to a few expert subnetworks, so only 17B of 594B parameters do work per token.

Variable effort

A setting that trades more reasoning time for better answers on hard tasks.

LoRA fine tuning

Training small added weight matrices instead of the whole model, which is how Tinker's training clients work.

Steps

1. Read the Thinking Machines announcement first, then the linked model card.
2. Open the Tinker models and pricing page and find the Inkling 2 Small rows and context lengths.
3. Compare its DeepSWE v1.1 score with the other models in the announcement's table.
4. Read the Tinker Cookbook README for how sampling and training clients are created.
5. Self check: why does a 17B active MoE cost less per token to serve than a dense 594B model, yet still need far more memory than a dense 17B one?

Steps

1. Install the cookbook with uv pip install tinker-cookbook.
2. Create an API key in the Tinker console and export it as TINKER_API_KEY.
3. Run the guided notebook with marimo edit tutorials/101_hello_tinker.py from a clone of the cookbook repo to learn the client flow.
4. Following the cookbook primitives, create a client with tinker.ServiceClient() and point the base model at thinkingmachines/Inkling-2-Small.
5. Sample answers to five coding prompts from your own backlog and save them for comparison.
6. Adapt the tinker_cookbook/recipes/sl_basic.py supervised recipe to a small dataset of your own and compare outputs before and after.

Small angles to try

• Try the image input with screenshots from your own app and ask for bug descriptions.
• Compare the same prompts on a smaller base model listed on Tinker to see what the extra size buys.
• When the Apache 2.0 weights land, check whether your Tinker checkpoints can be downloaded and served locally.

Key ideas

Peak electrical load

The highest power a facility draws at once, which is what utilities must plan grid capacity around.

Advisory ballot measure

A vote that records public opinion but does not legally bind local officials.

Zoning amendment

A change to local land use rules that decides where a type of building, such as a data center, may be built.

Steps

1. Read the Route Fifty article first, noting which measures were bans, which were zoning changes and which were advisory.
2. Note the Emporia thresholds of 10 MW peak load and 100,000 gallons of water a day, and why a city would pick power and water as the test.
3. Skim the top HN comments to see the arguments from both sides about rates, water and transparency.
4. Self check: why would a 10 MW threshold in a local ordinance matter to a team planning where to rent or build GPU capacity?

Steps

1. Pick a GPU server configuration you know or use, and write down its rated power draw from the vendor spec sheet.
2. Write a short Python script that takes per server watts, a cooling overhead factor you choose and a server count, and prints total peak load in MW.
3. Find the server count at which your setup crosses the 10 MW line used in the Emporia ban.
4. Add an input for water use per MWh from a public source you trust, and compute when daily water crosses 100,000 gallons.
5. Write two sentences on whether a cluster you would actually train or serve on falls under such a local ban.

Small angles to try

• Compare air cooling and liquid cooling assumptions and see how the water line moves.
• Recompute with the power draw of an older GPU generation to see how efficiency changes the count.
• List which of your current cloud regions sit in states that held votes this month.

Key ideas

Hours versus output

Cutting scheduled hours while keeping deliverables fixed forces any AI productivity gain to show up as saved time rather than extra work.

One way policy change

In Japan, removing a granted holiday can count as an unfavorable change to working conditions, so the company treats the shift as irreversible.

Self reported productivity

An impression of speedup from managers or staff, which can differ from measured cycle times.

Steps

1. Read page 2 of the ITmedia article first, which covers the adaptation period and the three months to one month app example.
2. Read page 3 for why the change cannot be reversed and which kinds of companies Sasaki thinks it fits.
3. Write down which claims are measured and which are impressions.
4. Self check: what single metric would show whether a 20% cut in hours was really covered by AI gains?

Steps

1. Export the last two months of closed tickets from your own team tracker with open and close dates.
2. Tag each ticket as done with heavy AI help, light AI help or none, from memory or commit notes.
3. Compute the median time to close for each tag with a short script or a pivot table.
4. Estimate how many hours per week the faster group would free up if all similar tickets moved to it.
5. Compare that number with 20% of your scheduled week and note the gap.

Small angles to try

• Split by ticket size to see if AI help only speeds small tasks.
• Track review time separately, since faster writing can move effort into review.
• Repeat in a month and see if the gap changes.

Key ideas

Computer use

A model operating software by reading screens or terminal output and issuing clicks, keystrokes or commands.

Hallucination rate

The share of answers containing unsupported claims, here measured by Tencent on its own internal test set.

Blind evaluation

Graders score answers without knowing which model produced them, which reduces brand bias.

Steps

1. Read the Tencent press release first, noting which numbers are internal tests and which compare against other models.
2. Open the OpenRouter model page to see the model id, context length and current price.
3. Skim the HN thread for hands on reports on speed and quality.
4. Self check: which Hy4 claims could you verify yourself today, and which must wait for the weights?

Steps

1. Create an OpenRouter API key and note the per token price on the tencent/hy4 model page.
2. Send the model five questions about your own codebase or documents whose answers you already know, using the model id tencent/hy4 through the OpenRouter chat API.
3. Count wrong or unsupported statements to get your own rough hallucination rate.
4. Run the same five questions on a model you already use and compare accuracy, latency and cost.
5. Record the token usage returned with each response to check real cost per answer.

Small angles to try

• Give it a multistep shell task in a throwaway container and watch how many turns it takes.
• Ask for a summary of a long internal document to test the 1M context claim.
• Rerun once the open weights appear and compare local results with the API.

Key ideas

Prompt injection

Instructions hidden in content an agent reads that try to make it do something the user did not ask for.

Taint tracking

Marking a session as untrusted once it has seen suspicious input, then applying stricter rules to later actions.

Pre and post tool hooks

Agent callbacks that run before an action to allow or block it and after a read to inspect what came back.

Steps

1. Read the Stroq README on GitHub first, especially the sections on how taint is set and the policy rule names.
2. Look at the action classes such as shell.network, fs.secrets and git.push_external and match each to a real risk.
3. Read the Show HN thread for the criticism about sandboxing versus auditing.
4. Self check: why does Stroq ask before running an npx command copied from an MCP result instead of simply allowing it?

Steps

1. Create an empty throwaway project folder you own and run npx @stroq/cli init there, or npx @stroq/cli init --agent codex for Codex.
2. Run npx @stroq/cli doctor to confirm the hooks were written.
3. Clone the repo and run pnpm install && pnpm build && ./examples/demo/run-demo.sh to watch the poisoned README demo get blocked.
4. Install globally with npm install -g @stroq/cli and run stroq attack to replay the 13 recorded incidents against your policy.
5. After a session, run stroq log and stroq why to see what was blocked or asked and why.

Small angles to try

• Put a harmless fake instruction in a local README and see whether the session gets marked suspect.
• Lower or raise the threshold and rerun stroq attack to see how results shift.
• Try npx @stroq/cli init --agent mcp --client claude-desktop to wrap a local MCP server.

Key ideas

Complexity versus quality

Complexity sets how much planning happens before generation, while quality sets rendering fidelity, and the two are billed through output tokens.

Markup guided edit

A transparent PNG of the same size as the photo where you draw marks showing what to change, sent alongside the original instead of a mask.

Vector output

An SVG is XML shapes rather than pixels, so it can be edited as code and scaled without blur.

Steps

1. Read the GPT Image 2.6 sections of the OpenAI image generation guide first, focusing on markup, SVG and GIF limits.
2. Open the gpt-image-2.6-sunburst model page and note input and output token prices.
3. Skim the HN thread for reports on quality differences between Sunburst and Flare and on token usage.
4. Self check: why can an SVG from this API not be sent back to the edit endpoint?

Steps

1. Call the image generations endpoint with model gpt-image-2.6-sunburst, a simple icon prompt, output_format set to svg and n set to 1.
2. Decode data[0].b64_json from the response and save it as a .svg file, then open it in a text editor to inspect the shapes.
3. Make the same call with output_format set to gif, a small frame_count such as 4 and a frame_duration_ms you choose, and view the animation.
4. Log the usage field of each response and compute the real cost per output.
5. Repeat one prompt with gpt-image-2.6-flare and compare quality, latency and tokens.

Small angles to try

• Draw a circle on a transparent PNG over one of your own photos and send it as markup to the edits endpoint.
• Try low, medium and high complexity on one prompt and compare token counts.
• Generate an SVG diagram and hand edit its colors in code.