Edition 2026-11-18 latest · digest built 2026-11-18T12:04:22+00:00 · ⚙ ollama:deepseek-v4.1-flash:cloud

Agent Sandboxes Go External: Laptop Gemma 4 Tuning and Once-Only K=V Caches

Today's practical AI work centers on containing coding agents and making local models cheaper to run and adapt. New recipes cover laptop-scale QLoRA for domain code, exact KV-cache savings for Gemma 4 serving, and agent-skill maintenance that prevents stale behavior. The research also gives teams better ways to tune tool-calling agents, compress RAG contexts, and judge model productivity without trusting benchmark scores alone.

Local Serving and Fine-Tuning

The strongest hands-on items are about running and adapting open models without a cluster. Gemma 4 edge models get a concrete QLoRA-on-laptop recipe with deterministic checkers and OpenVINO int8 deployment, while Gemma 4 serving gets an exact KV-cache layout that can cut memory without changing attention kernels. Ambient SFT adds a practical fine-tuning trick for small datasets: match a frozen base model's high-temperature predictions to reduce overfitting.

Agent Operations

Agent work is shifting from demos to operational discipline. External sandboxes make local-model execution safer, JET trains repository agents to stop over-exploring, and DR. GREENS turns energy-smell repair into a reusable coding-agent skill. Another paper shows agent skills can silently rot after environment changes, so skill libraries need versioning, regression tests, and selective pruning.

Retrieval, Docs, and Evaluation

Retrieval and multi-agent context work got more evidence-based. StitchRAG compresses retrieved passages while preserving evidence anchors, a deployed multi-agent system targets stale documentation using tickets and code-doc discrepancies, and debate memory performs better when contradictions are preserved instead of collapsed. Finally, one paper warns that higher coding benchmark scores did not translate into more completed work, and another shows agent self-improvement stalls when evaluation noise hides real improvements.

Today's findings

  1. #1 External Sandboxes for Coding Agentstool

    Run agent-written code in a disposable external sandbox so prompt injection or a bad local model cannot touch your machine.

    Why it matters: Coding agents and local models are increasingly allowed to execute commands; a single injected instruction can exfiltrate secrets or damage a workstation.

    How to apply: Put agent shells inside a VM or container with no host secrets, restricted network, and disposable filesystem; test local-model workflows through the sandbox before granting repo or cloud credentials.

    agentssandboxinglocal-llmsecurity

    Read more: External sandboxes for coding agents

  2. #2 Laptop QLoRA Fine-Tuning for Gemma 4 Edge Modelspaper

    A 66-example checked dataset plus LoRA or QLoRA on a laptop iGPU can materially improve small Gemma models on domain-specific MATLAB code.

    Fine-tuning recipe
    Adapting small Gemma models without a GPU cluster
    66
    checker-verified examples — the entire training set for domain MATLAB code
    material pass-rate lift on domain tasks
    Laptop iGPU
    LoRA / QLoRA adapter training, fully local
    int8
    exported via OpenVINO for edge deployment
    held-out
    checker suite confirms the gain
    Small deterministic-checked data + local adapters = practical domain adaptation for edge models.

    Why it matters: It shows a realistic path to adapt an open small model to your own code conventions without a GPU cluster.

    How to apply: Curate a small set of deterministic-checked examples, train LoRA or QLoRA adapters on the iGPU, export int8 through OpenVINO, and keep a held-out checker suite to measure pass-rate gains.

    fine-tuningqloralocal-llmopenvino

    Read more: Fine-Tuning Gemma 4 Edge Models for MATLAB Signal-Processing Code with SFT and QLoRA on a Laptop iGPU · Fine-Tuning Gemma 4 Edge Models for MATLAB Signal-Processing Code with SFT and QLoRA on a Laptop iGPU · Fine-Tuning Gemma 4 Edge Models for MATLAB Signal-Processing Code with SFT and QLoRA on a Laptop iGPU

  3. #3 Store Gemma 4 K=V Cache Once in vLLMtechnique

    Gemma 4 global attention lets a serving engine store one 640-value row instead of separate key and value caches, with bit-identical outputs in a vLLM prototype.

    Gemma 4 · KV cache
    Store the KV cache once, not twice
    Standard serving
    • Key cache: 640-value row
    • Value cache: 640-value row
    Gemma 4 K=V share
    • One shared K=V row: 640 values
    • Bit-identical outputs
    Verified bit-identical in a vLLM prototype; frees concurrency or context headroom on local 31B serving.

    Why it matters: KV-cache memory is a hard limit on local 31B serving; exact savings can raise concurrency or context length without changing attention kernels.

    How to apply: Prototype the overlapping strided-view cache layout in your vLLM fork, verify bit-identical logits against the standard cache, and benchmark memory and throughput at your target batch size.

    inferencekv-cachevllmgemma

    Read more: Storing the Gemma 4 K=V Cache Once: Exact Global-KV Memory Savings in a Paged Serving Engine with Unchanged Attention Kernels · Storing the Gemma 4 K=V Cache Once: Exact Global-KV Memory Savings in a Paged Serving Engine with Unchanged Attention Kernels

  4. #4 JET Fine-Tunes Tool-Calling Agents to Stop Over-Exploringpaper

    Just-Enough Exploration Tuning trains repository QA agents to answer once evidence is sufficient instead of burning extra tool calls.

    JET · Just-Enough Exploration Tuning
    The just-enough stopping point for tool agents
    Answer too early Over-explore Sufficient evidence — answer now
    JET tunes agents to stop the moment evidence suffices — extra tool calls buy latency and cost, not accuracy.

    Why it matters: Over-exploration is a direct latency and cost leak in coding agents, and standard SFT on expert trajectories can teach the bad habit.

    How to apply: Label the point of sufficient evidence in agent trajectories, fine-tune with JET-style losses that reward stopping there, and track tool-call count alongside answer accuracy.

    agentsfine-tuningtool-userag

    Read more: JET: Just-Enough Exploration Tuning for Efficient Tool-Calling Agents in Repository-Level Question Answering

  5. #5 DR. GREENS Agent Skill for Python Energy Smellstool

    An agent skill detects and repairs Python energy smells in the developer environment and grounds edits in a 12-smell taxonomy.

    Agent skill
    How DR. GREENS clears a Python energy smell
    1
    Detect
    Flags energy smells on hot Python paths
    2
    Classify
    Grounded in a 12-smell taxonomy
    3
    Repair
    Agent drafts an energy-aware patch
    4
    Verify
    Measured savings required to merge
    The merge gate — no savings, no merge
    Plugs into your coding agent; runs in CI or code review before the patch ships.

    Why it matters: Energy inefficiency is a production cost and sustainability issue, and shifting checks into coding agents catches it before merge.

    How to apply: Add the skill to your coding-agent setup, run it on hot Python paths in CI or review, and require measured savings or a clear smell classification before accepting the patch.

    agentscodingenergypython

    Read more: Identifying and Repairing Energy Smells with Agent Skills

  6. #6 When Agent Skills Go Stale, Test and Prune Thempaper

    Reused agent skills can lose more than 10 percentage points of task performance after environment changes, even if success looks stable.

    Why it matters: Skill libraries and persistent memories are often treated as assets, but stale environment-specific state can silently degrade agents and increase execution cost.

    How to apply: Version skills with the environment assumptions they encode, run regression tests after tool or API changes, and selectively evict or rewrite stale skill state instead of reusing everything.

    agentsmaintenanceevaluationmemory

    Read more: When Agent Skills Go Stale: Runtime Behavior and Selective Maintenance in Evolving Environments

  7. #7 Ambient SFT Uses a Frozen Teacher to Stretch Small Datasetspaper

    Ambient SFT augments fine-tuning by matching a frozen pre-trained model's high-temperature predictions, reducing overfitting on small SFT sets.

    Why it matters: Teams rarely have large, clean post-training datasets; this offers a way to preserve model tails while adapting to a target task.

    How to apply: Keep a frozen copy of the base model, add a coarse temperature-matching loss against its predictions during SFT, and compare forgetting on held-out general prompts against plain fine-tuning.

    fine-tuningsftdata-efficiency

    Read more: Ambient LLMs: Data-Efficient Supervised Fine-tuning via Temperature Matching · Ambient LLMs: Data-Efficient Supervised Fine-tuning via Temperature Matching · Ambient LLMs: Data-Efficient Supervised Fine-tuning via Temperature Matching

  8. #8 StitchRAG Compresses Retrieved Context Without Losing Evidencepaper

    StitchRAG builds compact RAG contexts with diffusion-based passage stitching and per-passage compression chosen by utility.

    Why it matters: Long retrieved contexts add cost and noise; preserving anchors and evidence while shrinking context is a direct quality and latency win.

    How to apply: Extract answer candidates and query keywords as anchors, score passages by retained information versus token cost, and stitch compressed spans into the final prompt before generation.

    ragcontextcompression

    Read more: StitchRAG: Constructing Compact and Evidence-Preserving Contexts for RAG with Diffusion-Based Stitching

  9. #9 Higher Coding Benchmark Scores Did Not Mean More Work Donepaper

    A natural experiment around a Claude Fable 5 suspension found that higher SWE-Bench Pro scores did not translate into more completed work.

    Coding-model selection
    Higher score, not more work
    Trust the leaderboard
    • Top SWE-Bench Pro rank looks decisive
    • Synthetic fixes, not your backlog
    • Won on paper
    Measure your repo
    • Track merged PRs, review cycles, rework
    • Time-boxed A/B on real tasks
    • Re-test when bottlenecks shift
    A natural experiment: the higher benchmark score did not translate into more completed work.
    From a natural experiment around the Claude Fable 5 suspension.

    Why it matters: Benchmark wins can mislead model selection; teams should measure real pull-request throughput, review cycles, and rework on their own repos.

    How to apply: Run time-boxed A/B tests with your actual coding tasks, track merged PRs and review effort rather than leaderboard rank, and revisit model choices when the workflow bottleneck changes.

    coding-agentsbenchmarksproductivityclaude

    Read more: Higher-Scoring Coding Models Did Not Get More Work Done · Higher-Scoring Coding Models Did Not Get More Work Done · Higher-Scoring Coding Models Did Not Get More Work Done

  10. #10 Mind the Gap: Multi-Agent Documentation Maintenancepaper

    A deployed multi-agent system uses support tickets and code-doc discrepancies to find and repair stale documentation.

    Documentation maintenance
    The doc-drift loop
    reality movesgaps openstale contexttickets + diffshuman-gatedCode shipsDocs lagAgents ingestErrors surfaceFixes land
    Every code change reopens the gap; a maintenance agent closes it before stale docs poison the next run.

    Why it matters: LLM agents consume docs as authoritative context, so stale docs propagate bad information into future agent work.

    How to apply: Wire resolved tickets, code diffs, and doc pages into a maintenance agent; generate candidate doc fixes with evidence links, then require human review before publishing.

    agentsdocumentationmaintenance

    Read more: Mind the Gap: A Deployed Multi-Agent System for Documentation Maintenance · Mind the Gap: A Deployed Multi-Agent System for Documentation Maintenance · Mind the Gap: A Deployed Multi-Agent System for Documentation Maintenance

  11. #11 Preserve Contradictions in Multi-Agent Debate Memorypaper

    Keeping ranked conflicts and provenance in shared memory beat collapsing to a single winning fact, improving F1 and reducing poisoned-item attack success.

    Why it matters: Agent memory systems often over-resolve disagreement; preserving conflict can improve reasoning and security.

    How to apply: Store claims with provenance and confidence, pass a ranked conflict set into debate, and avoid pre-selecting one fact before agents can weigh the evidence.

    agentsmulti-agentmemorysecurity

    Read more: Surfacing Disagreement Beats Resolving It: A Gated Ablation Study of Provenance-Weighted Memory for Multi-Agent Debate · Surfacing Disagreement Beats Resolving It: A Gated Ablation Study of Provenance-Weighted Memory for Multi-Agent Debate

  12. #12 Measure Evaluation Resolution Before Evolving Agent Skillspaper

    Agent evolution often stalls because noisy evaluations cannot reliably identify which candidate artifact is actually better.

    Why it matters: Prompt, skill, and memory evolution loops waste compute if selection is dominated by evaluation noise.

    How to apply: Use repeated trials, confidence intervals, and task-level stratification before accepting self-improvement candidates; increase eval resolution where wins are small.

    agentsevaluationself-improvement

    Read more: The Resolution Hypothesis: Agent Evolution's Key Is Identifying Improvements · The Resolution Hypothesis: Agent Evolution's Key Is Identifying Improvements

Looking for topic trends and crawl volume over time? See Trends.