Daily AI Digest — 2026-08-20
arXiv Highlights
Zetta ζ: An Efficient Closed-Loop Embodied Harness for Self-Evolving Physical Intelligence
Problem
Agentic harnesses wrapping frozen VLA policies have become the default way to extend end-to-end manipulation models to long-horizon tasks. In practice these harnesses are open-loop at execution time: they decompose a task into a fixed skill sequence, dispatch it, and only reflect after the episode terminates. The mismatch is fundamental — physical contact events unfold at tens of Hz, while large multimodal reasoning models operate at seconds-per-call latency, so post-hoc reflection cannot intervene when a grasp slips or an object shifts. Zetta targets the missing piece: how to add closed-loop critique and recovery without retraining \pi, and how to have the harness itself evolve during deployment.
Method
Zetta separates responsibilities into fixed runtime components and evolvable ones. The action policy a_t = \pi(s_t, g; \theta) has \nabla\theta = 0, and the Orchestrator Agent \mathcal{A}_{orch} (a frozen multimodal reasoner) is likewise invariant — it only adjudicates mode transitions on real-time evidence. What evolves is an “Evolvable Harness” \mathcal{H} = (C, R, T): code-based Critics that fire at action frequency, Recovery skills invoked when a critic trips, and Tools/perception primitives.
Three loops run at separated timescales:
- Action-frequency governance. Critics C are cheap Python predicates over perception outputs (contact, pose, gripper state) that run every control step and can preempt \pi to hand control to a recovery R_i.
- Rollout-level proposal. When a rollout fails, offline Evolutionary Agents cluster failure trajectories by signature, pick a medoid seed, and propose new critic/recovery code.
- Validation-gated skill updates. Proposed skills are re-executed on the development seeds; only those that convert failures into successes without regressing prior seeds are admitted into \mathcal{H}.
The dual-agent structure — online Orchestrator for adjudication, offline Evolutionary Agents for optimization — is what makes deployment-time evolution tractable: the online loop never has to call the slow reasoner in the inner control loop, because the fast critics have already been distilled into code by the offline loop.
Z-Infra
The evolutionary loop is bandwidth-hungry: many concurrent rollouts, heterogeneous simulators (CPU MuJoCo/robosuite for LIBERO-Pro and RoboCasa, but also MJX, ManiSkill, Isaac Lab), and GPU-hosted VLA inference. Z-Infra exposes a session-based interface (reset, policy_step, perception, primitives) and routes calls through a Control Plane to Env Workers and Rollout Workers.
The decoupling is the point: agent logic is written once, and CPU-bound simulation instances are multiplexed independently from GPU-bound policy inference, so a small 8×RTX 4090 cluster can sustain enough parallel rollouts to feed the offline evolutionary loop.
Results
Base policies are \pi_{0.5} on LIBERO-Pro and GR00T N1.5 on RoboCasa; neither is fine-tuned. Evaluation uses strictly held-out seeds: on RoboCasa, 50 seeds are used for development/evolution, and a disjoint 50 seeds for final report. Failure clusters produced during evolution are diagnosed at their medoid seed only.
Reported headline numbers: - LIBERO-Pro success: 90.8%. - RoboCasa success: 93.6%. - Inference speedup: 11.1× over the baseline agentic pipeline. - Success continues to scale monotonically with self-exploration budget (more rounds → higher held-out success). - Learned critic/recovery skills transfer zero-shot to unseen tasks that share the same failure modes.
The speedup comes from replacing per-step LLM calls with code critics; the accuracy gain comes from the online recovery pathway plus accumulated skills. Because \theta is frozen, all improvement is attributable to \mathcal{H} — a clean ablation of “harness capacity” against “policy capacity.”
Limitations and open questions
- Critics are code over perception primitives, so failure modes that are not observable through the current tool set T cannot be diagnosed; expansion of T is manual.
- The evolutionary agent’s proposals rely on an LLM that itself might miss subtle contact-dynamics failures; the paper reports success rates but not proposal acceptance rates or false-positive critic firings.
- Development uses 50 seeds per task on RoboCasa; whether the induced critic library overfits to the seed distribution despite the held-out protocol is worth probing on longer-tail distributions.
- All experiments are in simulation (MuJoCo/robosuite). The claim that the design is “hardware-decoupled” is architectural — real-robot latency, sensor noise, and non-resettable failures will stress the validation-gated update step.
- The base policies are two specific VLAs; whether the harness generalizes across policy families with very different failure geometries (e.g., diffusion policies vs. autoregressive VLAs) is not shown.
Why this matters
Zetta is a concrete demonstration that deployment-time capability growth can come entirely from the harness — code-level critics and recoveries synthesized offline, dispatched at control frequency online — while the underlying VLA stays frozen. The 11.1× inference speedup alongside 90.8%/93.6% success rates suggests that “make the agent loop faster and self-modifying” may be a more tractable path to reliable manipulation than another round of policy fine-tuning.
Source: https://arxiv.org/abs/2608.16590
Co-RL: Unsupervised Reasoning Emerges from Diverse Cohort in Multi-agent RL
Problem
Self-rewarding RL for reasoning — where a model uses its own majority vote (TTRL), confidence (Intuitor), or entropy (RENT) as a pseudo-reward — is attractive because it eliminates the need for verifiable ground-truth labels. But it is structurally unstable: the pseudo-label is a function of the same rollout distribution being optimized, so any systematic error is reinforced rather than corrected. Empirically this manifests as reward collapse, length degeneration, and homogenization. The paper asks how to construct an independent learning signal without any labels, and shows that a cohort of independently parameterized agents cross-supervising each other is sufficient.
Method
Co-RL trains N policies \{\pi_{\theta_n}\}_{n=1}^N with no shared parameters or gradients. For unlabeled prompt x, each agent samples K rollouts y_n^k and extracts answers a_n^k = g(y_n^k). Agent n’s pseudo-label is drawn from a designated peer (index n-1, cyclic):
\hat{a}_{-n}(x) \in \arg\max_b \sum_{j=1}^{K} \mathbf{1}[a_{n-1}^j = b].
The reward for agent n’s k-th response is r_n^k = \mathbf{1}[a_n^k = \hat{a}_{-n}(x)]. Each agent then runs GRPO with group-normalized advantages against its cross-agent reward:
\mathcal{J}_{\text{Co-RL}}(\boldsymbol\theta) = \frac{1}{N}\sum_{n=1}^N \mathcal{J}_{\text{GRPO}}(\theta_n; \{y_n^k, r_n^k\}_{k=1}^K).
The critical constraint is that agent n contributes nothing to \hat{a}_{-n}. Diversity of the cohort is orthogonally strengthened by mixing model families (Qwen, Llama, InternVL, Gemma), model sizes, and rephrased copies of prompts, all of which reduce correlated errors between peer supervisors.
Theoretical dynamics
The paper’s Proposition 1 is the clean version of why this works. Reducing to a binary correct/incorrect outcome with p_n = \Pr(a=a^\star \mid x) and K odd, self-rewarding evolves as
\dot{p} = \eta\, p(1-p)\, \mathbb{E}_{C\sim\text{Bin}(K,p)}\!\left[\operatorname{sign}(C - K/2)\,\frac{\sqrt{C(K-C)}}{K}\right],
where the \operatorname{sign} term depends on p itself — the update reinforces whichever answer is currently the majority. Under Co-RL,
\dot{p}_n = \eta_n\, p_n(1-p_n)\, \mathbb{E}[\operatorname{sign}(Z_{-n} - 1/2)]\, \mathbb{E}_{C_n}\!\left[\frac{\sqrt{C_n(K-C_n)}}{K}\right],
with Z_{-n} = \mathbf{1}[\hat{a}_{-n}(x)=a^\star] determined solely by the peer. So the sign of the update for agent n decouples from p_n: if the peer is more often correct than not on x, agent n is pulled toward a^\star even when its own majority is wrong. In the two-agent case this reduces to the coupled system
\dot{p}_A = q_K(p_A)\phi_K(p_B), \quad \dot{p}_B = q_K(p_B)\phi_K(p_A),
with \phi_K(p) = 2V_K(p)-1 the signed majority-vote direction. The fixed points at p_A, p_B \in \{0,1\} persist, but the basin of attraction for the correct fixed point strictly enlarges whenever the two agents’ errors are not perfectly correlated — exactly the co-training argument of Blum and Mitchell, imported into GRPO.
Experimental setup and results
Language models are trained on MATH levels 3–5 and evaluated on GSM8K, MATH-500, AMC, HumanEval, MBPP, LiveCodeBench, and GPQA. VLMs are trained on MMR1-Math and multimodal-open-r1 and evaluated on MathVision, MathVerse, MathVista, and We-Math. Configurations follow Co-rewarding (lr 3\times 10^{-6}, batch 128, K=12, 3072-token cap, 2 epochs) for text and R1-V (lr 1\times 10^{-6}, K=8, 1024-token cap) for VLMs. Baselines cover TTRL, Intuitor, RENT, Co-rewarding-II (self-rewarding), MAPoRL and CoMAS (multi-agent), and GRPO with ground-truth rewards as an oracle upper bound. Gemma-3 requires a token-level importance-sampling correction because rollout and policy distributions drift.
The abstract and ablations report that (i) diversity across model families/sizes/rephrasings monotonically improves Co-RL performance, and (ii) training dynamics remain stable where self-rewarding baselines collapse. In the ablation, self-rewarding runs display reward variance collapse and completion-length degeneration on multiple text backbones, while Co-RL preserves reward variance and completion length across training; VLM agents maintain partial disagreement while the accuracy of their exchanged pseudo-labels rises monotonically — the diagnostic signature predicted by Proposition 1 (informative Z_{-n} persists).
Limitations and open questions
The theoretical analysis is confined to a binary-outcome reduction on a fixed prompt with clipping and KL dropped; the multi-answer regime with a real answer-extraction g(\cdot) is only argued informally. The reward is \{0,1\} agreement with a peer’s majority vote, which discards partial-credit and process-level signal and is uninformative when peers agree on a wrong answer (a correlated-error mode diversity mitigates but does not eliminate). Compute scales linearly in cohort size N, and the paper’s runs cap at N=2 on 8×H100. The cyclic supervision graph is a design choice; whether denser voting graphs (all-vs-all, tournament) further reduce error correlation is not studied. Finally, “reasoning” here still bottoms out in answer-string agreement, so there is no guarantee against the cohort converging on shared confident errors on genuinely hard prompts where no agent has signal.
Why this matters
Co-RL gives a principled, label-free training signal whose stability is derived rather than empirical: decoupling the supervisor from the optimized policy is what breaks the self-confirming fixed points of TTRL-style self-rewarding. As RL for reasoning pushes past domains where humans can verify outputs, cohort disagreement — not a single agent’s introspection — is a plausible substitute for ground truth.
Source: https://arxiv.org/abs/2608.17253
SPADE: Self-Play in Adaptive Synthetic Executable Environments
Problem
RLVR pipelines for LLM reasoning agents are bottlenecked by their environment pool. Hand-curated benchmarks, statically synthesized datasets, and frozen-verifier setups all fix the task distribution, so as the learner improves the training signal saturates. SPADE addresses this by making the environment distribution itself a learned, adaptive object: a single LLM \pi_\theta alternately generates executable environments and learns to solve them, driven by a regret signal that keeps generated tasks near the agent’s capability frontier.
Method
SPADE casts curriculum generation as self-play between two roles of the same parameters \theta, selected by system prompt:
- Environment Designer \pi_D: emits a Python program implementing OpenAI Gym-style
reset()/step(), encoding transition T(s'\mid s,a) and reward R(s,a) instep(). It also emits a privileged hint h (partial solution sketch or structural cue). - Reasoning Agent \pi_A: interacts with the environment e via multi-turn actions.
Because environments are arbitrary Python, single-turn QA (reset() → step(answer) → terminal reward) and long-horizon agentic tool-use collapse into one interface. The designer conditions on (i) an environment memory M containing high-regret seeds and too-easy/too-hard negatives and (ii) grounding documents from a pretraining corpus C.
The designer reward is hint-based regret:
r_D(e) \;=\; \mathbb{E}_{\pi_A}[R(e \mid h)] - \mathbb{E}_{\pi_A}[R(e)]
Maximizing r_D pushes the designer toward environments where the hint materially helps — i.e., feasible but not yet solved. Both roles share \theta and are updated with GRPO (Shao et al. 2024). Per cycle, the RA plays each environment 16 \times k times without the hint and 16 times with it; regret uses matched no-hint/hint averages at the same regeneration step. The designer update is delayed by k rollouts (with truncated importance sampling) and there is a regret floor to stabilize the alternating optimization. Candidate environments are gated by a syntactic/executability validator before entering the pool.
The curriculum that emerges is qualitatively non-trivial: over a single 30B-A3B run, generated environments shift from short reset-then-answer tasks to state-gated multi-turn MDPs.
Results
Backbones: Qwen3-4B-Instruct-2507, Qwen3-8B (thinking on), Qwen3-30B-A3B-Instruct-2507. Training: 400 rollouts × 24 environments, held-out benchmarks throughout.
Games setting (30B-A3B). Suite average of 58.3, +8.1 over base and +5.3 over the strongest fixed-environment RLVE baseline. Every held-out category improves except competition math, which is preserved (AIME’25/’26 62.8/74.4 vs. base 61.5/73.5). GPQA-Diamond 75.8 vs. 70.4, LiveCodeBench-v6 47.3 vs. 43.2, Reasoning-Gym Math 63.3 vs. 45.0, Algorithmic 32.1 vs. 18.0, Cognitive 37.7 vs. 23.0, Logic 72.8 vs. 67.0. Gains transfer despite the designer never training on any held-out task.
Tool-use setting (30B-A3B). ACEBench-Agent +13.9 (its stateful DB + tool-schema + multi-call structure most closely mirrors generated environments), BFCL v4 multi-turn +5.7 (+10.3 at 4B), \tau^2-bench +3.6. SPADE at 30B leads dedicated data-synthesis systems on both BFCL v4 multi-turn and ACEBench-Agent.
Scaling. Gain over base grows monotonically with size: +5.2 (4B), +5.7 (8B), +8.1 (30B-A3B). Matched-budget Fixed-env GRPO plateaus at ~+1.2 across all sizes — static pools become a fixed signal that larger models fit and stop learning from. The regret estimate stays positive only at 30B-A3B; at 4B/8B the finite-sample estimator dips negative for long stretches, yet gains still materialize.
Ablations (Table 3, games, 30B-A3B). - Full SPADE: 58.3. - w/o environment memory: 53.2. - w/o corpus grounding: 53.5. - Frozen self-designer w/o memory: 40.5 — 9.7 points below the untrained base. Freezing the co-adaptation collapses training. - Frozen GPT-5.5 designer with corpus + memory: 53.0, recovering only ~35% of SPADE’s +8.1 and failing to improve LiveCodeBench-v6 (42.6 vs. 43.2 base).
Partial variants also peak early and then fade (no-corpus near step 111, GPT-5.5 designer near step 175), while full SPADE holds late in training. Curriculum breadth matters as well: a two-skill curriculum reaches only 53.7 vs. 58.3 for the six-skill version, so most of the gain is from diversity rather than any single game family.
Limitations and open questions
- The regret estimator is high-variance: at 4B/8B its empirical value is negative for long training stretches, so the designer is optimizing a noisy signal; the fact that gains still appear suggests robustness but also that the mechanism is not fully understood.
- Ablation controls change multiple factors simultaneously (freezing the designer while also removing memory or swapping models), so isolating the causal contribution of gradient updates to the designer alone is not clean.
- Executable-code environments require a validator, and the paper does not quantify reward-hacking or degenerate environments filtered out at scale.
- No results on models outside the Qwen3 family, and no comparison of what happens when \pi_D and \pi_A are decoupled into separate parameter sets — the shared-\theta design is a choice, not an ablated one.
- Hint quality is generated by the same model that gets rewarded for the induced regret; the possibility of the designer gaming the hint channel (writing hints that trivialize its own environments) is not directly measured.
Why this matters
SPADE operationalizes an AI-GA-style claim — that open-ended improvement needs an open-ended task space — into a concrete GRPO recipe where “environment” is just Python code and “curriculum” is a regret-maximizing policy. The result that fixed-environment RL flatlines at +1.2 across scales while adaptive self-play scales to +8.1 at 30B is the kind of empirical wedge that makes environment generation, not data collection, the next scarce resource in RL post-training.
Source: https://arxiv.org/abs/2608.19197
Training Leaves Traces: Centered Residual Signatures for Language Model Lineage Verification
Problem
Open-weight checkpoints are routinely fine-tuned, LoRA-merged, pruned, quantized, and redistributed with little or no provenance metadata. The question the paper addresses is whether, given two compatible checkpoints A and B (same depth L, width d, residual architecture), one can decide from weights alone whether they share a weight-level ancestor — with no access to training data, activations, or forward passes. The verifier must return a symmetric Related/Unrelated decision and, critically, must not confuse behavioral similarity (e.g., a distilled student trained from scratch) with weight ancestry. This is the correct separation for supply-chain auditing: distillation copies function, not weights.
Method
The core observation is structural. A residual block computes x_{\ell+1} = x_\ell + F_\ell(x_\ell). If the branch F_\ell is a sequence of linear maps W_1,\ldots,W_K interleaved with nonlinearities, one forms the branch product
M_\ell = W_K W_{K-1} \cdots W_1 \in \mathbb{R}^{d\times d}.
Because M_\ell maps the residual stream back into its own coordinate basis, diagonal entries are meaningful: identity and traceless matrices are orthogonal under the Frobenius inner product, and every branch product decomposes as
M_\ell = \tfrac{\mathrm{tr}(M_\ell)}{d} I + E_\ell,\qquad \mathrm{tr}(E_\ell)=0.
The scalar signature is the normalized trace concentration,
s(M) = \frac{|\mathrm{tr}(M)|}{\|M\|_F},
which measures the fraction of the matrix energy aligned with I (up to \sqrt d). Training drives energy into the identity component: the correct pair score approaches \sqrt d as \|E\|_F \to 0, while mismatched projections satisfy \mathbb{E}[s]\approx 1/\sqrt d, giving a margin that grows with width.
The lineage score is built by (i) extracting the architecture-appropriate MLP branch product at each block (factorizations for GELU vs. SwiGLU differ only in which factors compose; see the paper’s Appendix A.2), (ii) forming the block-pairing matrix s(i,j) between the branch products of A and B, and (iii) centering — removing the trace-aligned identity component that all descendants of residual training share, and comparing only the checkpoint-specific residual E_\ell. Without centering, all trained residual models look alike; the identity component is a training-regime signature, not a lineage signature. The final score is symmetrized and calibrated against a small pool of independent checkpoints, and Hungarian matching on s(i,j) recovers block correspondence.
The unpaired-vs-paired margin scales with d, and the block-diagonal structure is preserved across model scale.
Results
Block pairing via s(i,j) reaches 100% accuracy on the canonical MLP path for GPT-2, BERT, LLaMA-2, Mistral, Qwen2.5, and DeepSeek-R1, against a random-initialization baseline of \leq 4\% (Table 2). AUROC is 1.00 for all six families (BERT 0.97). This establishes the trace-concentration phenomenon as a family-agnostic property of trained residual stacks.
On the controlled lineage benchmarks — 52 MLP pairs (L=16, d=48) and 45 GPT-2 pairs (30M params, L=6, d=384, TinyStories) — the centered residual signature achieves AUROC = 1.00 on both, with Gap-Z = +53.0 (MLP) and +31.0 (GPT-2). Weight cosine is competitive on the clean benchmark (Gap-Z = +76.3 MLP, +30.7 GPT-2), and aligned Frobenius reaches AUROC = 1.00 but collapses on GPT-2 in effect size (Gap-Z=+3.9). Singular value distance falls to AUROC 0.73 on GPT-2. Activation-based methods (SVCCA, CKA) require forward passes and underperform on GPT-2 (0.99 and 0.86 AUROC). IPGuard, a decision-boundary method, is worst on MLP (AUROC 0.70, Gap-Z=-3.5). Critically, distilled students — behaviorally similar to their teachers — are correctly classified as unrelated, which is the discrimination that behavioral methods cannot make in principle.
Under “checkpoint laundering” (function-preserving weight transformations designed to defeat naive weight comparison), the paper reports that weight cosine and aligned Frobenius lose margin or fail while the centered score is unchanged, and runs 76\times faster than the nearest robust baseline on GPT-2. On a LLaMA-2 case study across public checkpoints, the method correctly identifies 3 related and 7 unrelated models.
Limitations
The verifier assumes compatible architectures (same L, d, residual factorization); cross-architecture lineage is out of scope. The score is symmetric — directional attribution (who is the ancestor) requires metadata. Calibration uses few independent roots (3 in the GPT-2 benchmark), so Gap-Z values are approximate and thresholds set from small pools risk spurious precision. Linear model merges produce partial lineage that the binary Related/Unrelated framing does not cleanly express. The laundering experiments are constructed by the authors; adaptive adversaries targeting the centered signature specifically (e.g., basis rotations that preserve function while destroying block-diagonal alignment) are not evaluated in the reported sections. Finally, the reliance on branch-product diagonals means non-residual or heavily rewired architectures may need bespoke factorizations.
Why this matters
Provenance verification for open-weight models has been either cryptographic (requires prior signing) or behavioral (confounded by distillation). A data-free, white-box, forward-pass-free signature that separates weight ancestry from output mimicry — and survives quantization, pruning, and LoRA merging — is a concrete tool for supply-chain audit of the current model ecosystem, and the trace-concentration phenomenon itself is a testable empirical regularity of residual training worth explaining theoretically.
Source: https://arxiv.org/abs/2608.14929
SkillGate: Training In-Policy Skill Selection in Long-Horizon Agents
Problem: selector credit starvation
Modern agent frameworks (Claude Code, OpenHands, and similar) increasingly rely on skills — instruction files, typically a few thousand tokens each, that the agent reads on demand mid-episode. Public libraries now hold thousands of them. Choosing which skill to read is therefore a policy decision made inside the trajectory, but standard outcome-rewarded RL fails to train it. The paper identifies the failure mechanism structurally and names it selector credit starvation: under a broadcast, sequence-level GRPO advantage, the handful of tokens that write the chosen skill’s name receive a vanishing fraction of the loss, and the sign they inherit is increasingly wrong as horizons grow. A correct choice gets punished whenever downstream execution fails — even though selecting the right skill is often the single most valuable decision in the trajectory. The authors verify all three properties (share vanishing, sign flipping, magnitude drop) grow monotonically with horizon on real training artifacts.
Setup: the standard mixed slate
For each task, the agent is shown K=16 candidate skills. Each skill s=(\mathrm{name}(s),\mathrm{desc}(s),\mathrm{body}(s)) is exposed by name and one-line description; the body is only revealed if the agent chooses to read the file. The slate contains one oracle s^\star verified to solve the task, five misleading hard negatives (topically adjacent, functionally wrong), five relevant bystanders, and five irrelevant bystanders sampled from a 2,045-skill public library. Nothing is enforced — the agent may read zero, one, or many; reading is an ordinary tool call. Trials run under a 30-turn / 850-second budget.
Method: two disjoint credit channels
SkillGate keeps the rollout, reward, and optimizer unchanged; it only re-routes where advantages are allowed to land on tokens. Trained tokens are partitioned along read-action spans:
- Selection tokens \bigcup_{a \in A(\tau)} I(a): the identity tokens naming the read skill. These are the selection decision.
- Execution tokens: every assistant token outside all read-call spans C(a) — reasoning, other tool calls, work.
- The tool-call wrapper (call span minus identity span) and skill bodies (which arrive as observations) are trained by neither channel.
Each partition gets its own advantage. The task channel uses the standard group-normalized GRPO advantage over n rollouts per prompt,
A^{\mathrm{task}}(\tau) = \frac{R(\tau) - \mu_G}{\sigma_G + \epsilon},
broadcast onto execution tokens only, with the entire read-call span excised. The selection channel scores each read action a by an action-local, group-centered utility:
u(a) = \begin{cases} 1, & |A(\tau_a)| = 1 \text{ and } a \text{ reads } s^\star, \\ 0, & \text{otherwise,} \end{cases} \quad A^{\mathrm{sel}}(a) = u(a) - \frac{1}{|A(G)|} \sum_{a' \in A(G)} u(a').
Three design properties fall out of Eq. (1). First, the baseline is over actions not trajectories, so a promiscuous sibling that reads four candidates lowers everyone’s baseline — this prices in slate-sweeping. Second, \sum_a A^{\mathrm{sel}}(a) = 0 by construction, so the channel exerts no pressure for or against reading in general, only over which name to write. Third, it is self-limiting: if all rollouts in a group either miss the oracle or all cleanly read it, utilities tie and A^{\mathrm{sel}} \equiv 0 — signal appears only where the group disagrees. No standard-deviation normalization is applied to A^{\mathrm{sel}} because action counts are small and dividing by their spread would inflate noise. Both channels’ token weights sum to N before a mixing coefficient \lambda is applied, and both enter a single GRPO update.
The single-read constraint in u(a) is the key anti-gaming primitive: reading the oracle plus three others scores zero, as does reading the oracle twice. The policy cannot buy selection credit by reading everything.
Evaluation protocol
Five agentic benchmarks — Claw-Eval, SkillsBench, SETA, SWE, and Terminal-Bench 2.0 — under the K=16 mixed slate. Training uses 491 tasks disjoint from Claw-Eval; crucially, training and evaluation oracle identities are disjoint, so gains cannot be attributed to memorizing name-to-task associations. Task outcome is reported on a 385-trial protocol (4 repeats × 56 non-Claw tasks + 1 × 161 Claw-Eval tasks). Read-behavior statistics share the same denominator; finer per-trial attributions use a 280-trial subset (70 tasks × 4 repeats).
Limitations and open questions
The utility function depends on a known oracle s^\star per task, which requires curated training data — the method is a supervised-selector-through-RL rather than a fully unsupervised skill discoverer. The single-read gate makes u(a) binary and hard, so intermediate cases (reading the oracle plus one relevant bystander for context) receive no credit, potentially foreclosing compositional strategies that are genuinely optimal. The self-silencing property means groups with uniformly good or uniformly bad selection contribute nothing to the selector channel, which may slow learning near convergence or on trivially hard tasks. The excerpt does not disclose the mixing coefficient \lambda, ablations against alternatives such as return decomposition or per-action baselines, or headline numbers versus the outcome-only GRPO baseline — these will determine how large the practical gap actually is.
Why this matters
Selector credit starvation is a general pathology of any long-horizon agent where a small number of tokens gate a large downstream execution, and SkillGate’s remedy — partition the token support and route disjoint advantages — is a clean template applicable well beyond skill files (tool choice, subagent dispatch, retrieval query formation). The identification of the failure mode is arguably more portable than the specific fix.
Source: https://arxiv.org/abs/2608.18852
SemaPLC: A Project-Grounded, Verification-Gated Agent Harness for PLC Code Generation
Problem and motivation
Programmable logic controllers (PLCs) execute the control logic of physical plants; incorrect code has physical consequences. LLM-based PLC code generation has so far been evaluated on isolated program organization units (POUs) with weak oracles — typically compile success plus, occasionally, self-generated property checks. Two failure modes escape this: (i) generated logic that compiles as an isolated POU but does not integrate into a full IEC 61131-3 project (missing variables, resource conflicts, task binding), and (ii) logic that satisfies syntactic or self-derived properties but diverges semantically from the specification when actually executed on a runtime. SemaPLC targets both by making external verification — specification audit, integrated compilation, and live-runtime trace comparison — the sole completion criterion, rather than the model’s own judgment.
Method
SemaPLC is an agent harness sitting on a generic event-driven tool-use core (ReAct-style) accessed via a chat-completion interface. On top it adds five components: an agent core (plan/edit/interpret), project/task grounding, a PLC skill library, verification processes, and a completion gate. Environment access is mediated by a single Model Context Protocol tool server exposing syntax checking, compilation, deployment, runtime status/logs, live variable read/force, trace sampling, and scripted behavior checks.
The core loop (Algorithm 1) is a verification-gated repair loop. Given requirement R and context X (a POU interface or an existing project), the harness grounds \Gamma \leftarrow \textsc{Ground}(X) and generates L \leftarrow \textsc{Generate}(R, \Gamma). Verdicts \mathcal{V} start empty. At each iteration, every check c \in K without a valid verdict is re-run, and \mathcal{V}[c] is set only if the log entry e_c confirms the verdict — an “earned claims” rule that prevents the model from asserting success without an external log line. If \mathcal{V} satisfies the track-specific completion criteria, the harness accepts L; otherwise failed checks with remaining retries feed \textsc{Repair}(L, \{e_c\}). Crucially, any edit invalidates prior verdicts (\mathcal{V} \leftarrow \emptyset), forcing re-verification of all checks, not just the one that failed. The loop terminates on completion, on exhaustion of the retry set F = \emptyset, or on interaction budget B.
The function-track metric follows Agents4PLC: with V_f the fraction of held-out properties model-checked as satisfied,
\text{VerifiedPass}(L_f) = \mathbb{1}[V_f \geq 0.80],
where inconclusive verdicts (unsupported constructs, translation failures, timeouts) count as failures and generation failures remain in the denominator. The judge is external and never queried by the harness. The project track adds three orthogonal metrics evaluated over 65 tasks: integrated-project compilation, static behavior (assertion oracle), and dynamic behavior — the last measured by deploying both generated and reference logic to a live PLC runtime and comparing executed traces.
Results
On the 117-task function track, SemaPLC attains the highest strict verified pass rate on all seven backbones. Mean is 72.6%, 8.8 points above the strongest baseline Agents4PLC at 63.9%. On the strongest backbone GPT-5.5 it reaches 82.1% vs 79.5%. Cross-model dispersion collapses: SemaPLC’s worst backbone (67.5%) exceeds every baseline’s mean, and its scores span 14.6 points versus 25–31 for baselines. Comparing full harness to bare backbones, every model gains 8.5 to 33.3 points, with the weakest models gaining the most (MiniMax-M2.7 +29.9, DeepSeek-V4-Flash +33.3). Bare compile rates rise from a 85.5% mean to 99.2%, and the cross-model spread shrinks from 37.6 to 14.6 points — consistent with the harness acting as a model-agnostic reliability layer rather than a prompt tuned to one backbone.
On the project-context track (Table 2), the three layers diverge sharply. Integrated compilation is largely saturated for strong models (SemaPLC mean 89.4% vs Agents4PLC 71.2%, AutoPLC 81.5%), and static behavior scores cluster in the 70s–80s (SemaPLC mean 81.6% vs 71.7–75.7 for baselines). Dynamic behavior is the discriminating layer: SemaPLC mean 52.2% versus 22.4 (LLM4PLC), 31.4 (AutoPLC), 30.3 (Agents4PLC). The worst-case backbone under dynamic behavior improves from 3.0–4.5% (baselines) to 31.3% (SemaPLC). The 30–50 point gap between static and dynamic scores across all methods indicates that assertion oracles substantially overestimate correctness relative to trace-level runtime equivalence — the reference-versus-candidate trace comparison catches semantic divergences that property-based checking does not.
Limitations and open questions
The paper attributes gains to “the harness as a whole” and defers decomposition to a layer ablation under RQ3; the relative contributions of specification audit, integrated compilation, and runtime trace comparison are not cleanly separated in the reported numbers. Dynamic behavior tops out around 65% even for GPT-5.5, so trace-equivalence to reference logic remains hard, and the trace-comparison oracle is itself sensitive to tolerance choices not detailed here. The 0.80 verified-pass threshold is inherited from Agents4PLC; sensitivity to that cutoff is not reported. Interaction cost (RQ4) is invoked but the trade-off between budget B, retry limit r, and pass rate is not quantified in the excerpted sections. Finally, dependence on a working MCP tool layer (compiler, live runtime, forcing infrastructure) limits transfer to closed vendor stacks.
Why this matters
Making external verification — specifically live-runtime trace comparison — the gating criterion, rather than model self-judgment or self-derived properties, converts LLM PLC-code generation from a plausibility exercise into something closer to a verified synthesis pipeline. The 22-point mean gap on dynamic behavior and the 30+ point gains for weak backbones suggest that for domains with cheap executable oracles, harness-side verification is a stronger lever than backbone scale.
Source: https://arxiv.org/abs/2608.18565
OmniScientist: An Omni-Modal Omni-Discipline AI Scientist
Problem
Existing autonomous “AI scientist” pipelines (Sakana’s AI Scientist, agentic Kaggle systems, etc.) close the surface loop from hypothesis to writeup but operate almost exclusively over text, code, and precomputed tabular summaries. The authors argue this is a structural, not incidental, limitation: much of the evidence that carries a scientific conclusion — the local spatial arrangement in a pathology tile, cross-channel phase in a three-component seismogram, temporal ordering in a migration trajectory — does not survive serialization into a caption or an unordered feature vector. Once these relations are stripped upstream, no amount of downstream reasoning recovers them, and the space of admissible research questions shrinks accordingly.
The paper formalizes this with a taxonomy of four discipline-independent evidence families, organized by the reasoning paradigm they demand rather than by tensor shape: perceptual (images, micrographs, spectra, waveforms, 3-D structure), symbolic (documents, formulae, sequences, knowledge graphs), quantitative-statistical (tables, distributions, tests), and procedural / dynamic (trajectories, simulations, agent traces). Current systems cover the middle two; the perceptual and procedural families are largely inaccessible to them.
Method
OmniScientist is a deterministic three-stage pipeline — Ideation → Experiment → Writeup — sitting on top of a shared perception layer that any stage can call.
The perception layer is the mechanically interesting piece. Rather than eagerly rendering artifacts into images and dumping them into a VLM, it organizes access hierarchically: (family → modality → registered tool). The default path is native numeric: for a signal, extract FFT peaks, trend breakpoints, autocorrelation structure directly from the array; for a table, read column statistics without plotting. Visual rendering is invoked only when the pending question is inherently spatial or topological, and it is budget-constrained per run to enforce targeted inspection. The task context, not a hardcoded rule, decides whether numeric features, visual features, or both are surfaced. Critically, the perception backbone is pinned to a single model (Claude Sonnet 5) across all experiments while the reasoning backbone is swapped, so any variation in score is attributable to the reasoner rather than to differential grounding.
The three agents operate under explicit code-enforced checks:
- Ideation observes materials, searches literature, and must emit falsifiable hypotheses; a novelty screen runs in code against retrieved literature.
- Experiment designs tests, runs code, inspects results, and emits an execution record containing stdout, figures, saved arrays, and configs — a provenance object rather than a natural-language summary.
- Writeup selects and grounds claims only against entries in the execution record; numerical traceability is enforced by matching reported numbers to record entries.
These are labeled idea check, rigour check, and claim check respectively, and together they replace the more common LLM-as-judge self-critique loop with mechanical constraints.
Figure 4 is the strongest evidence for the framing: across cases like seismology (a three-channel waveform where the agent flags a specific arrival), pathology tiles, 3-D CAD, and audio, the pipeline points to a local cue in the raw record and then derives a verified quantitative finding from it — e.g., that 21.7% of samples labeled as noise in a seismic dataset are in fact real events.
Results
Evaluation covers 36 cases across 5 discipline families and all 4 evidence families. Two out-of-family judges (deepseek-v4-flash, gemini-2.5-flash-lite) score completed runs on a composite metric.
The headline table (Table 4) reports both dispatch-to-completion rate and mean composite score for successful runs:
- Claude Sonnet 5: 36/36 completed, mean 6.5.
- GLM 5.2: 17/18 completed, mean 6.7 (highest score, but on half the suite).
- Kimi K2.7: 6/9 completed, mean 6.5.
- GPT 5.6: 9/10 completed, mean 5.7.
- Qwen3.5 122B: 30/34 completed, mean 5.4; 27B: 32/36 at 5.3; 9B collapses to 18/32 at 4.1.
- Gemma-4 31B: 32/36 at 5.0; 26B: 25/34 at 4.3.
Two observations follow. First, only Sonnet 5 completes the full suite, so mean scores on partial coverage are not directly comparable — GLM’s 6.7 is on cases it did not fail out of. Second, the open-weight families show a sharp capability cliff below roughly 30B active parameters: completion rate, not score, is where small models break, consistent with the pipeline’s requirement that the reasoner drive tool calls into the perception layer reliably.
Limitations and open questions
The evaluation depends on LLM judges, and while they are drawn from families outside the systems under test, composite scores are not calibrated against domain-expert review. The 36-case suite is broad by modality but shallow per discipline, so it demonstrates coverage rather than depth of contribution. The claim-check mechanism prevents ungrounded assertions but does not prevent the agent from choosing the wrong test on the right data. The perception layer is pinned to Claude Sonnet 5 throughout, which entangles the “omni-modal” claim with a specific proprietary model; whether the same tool interface generalizes when perception is served by, e.g., Qwen-VL, is not measured. Finally, arxiv id 2608.13558 sits outside the current arXiv numbering, suggesting either a placeholder or a post-dated identifier — worth confirming.
Why this matters
The paper’s substantive contribution is not another agent loop but the argument that the interface between evidence and agent is where scientific reasoning is silently truncated, and a working demonstration that native numeric plus budgeted visual access to raw artifacts recovers findings (e.g., 21.7% mislabeled seismic noise) that a caption-or-vector interface cannot express. That reframing — from “cover the workflow” to “preserve the relations” — is the right axis for measuring AI-scientist systems.
Source: https://arxiv.org/abs/2608.13558
Hacker News Signals
Mathematics in the age of AI
A position/survey paper from Terence Tao and collaborators examining how AI tools — primarily large language models and formal proof assistants — are reshaping mathematical practice. The paper distinguishes three regimes: (1) AI as a search/autocomplete tool for routine steps in formalization (Lean, Coq, Isabelle), (2) AI as a conjecture generator via pattern matching over large corpora, and (3) the harder question of whether AI can contribute genuine conceptual novelty. The paper is careful to separate the well-defined task of proof verification (decidable, mechanical) from proof discovery (where current LLMs fail on novel hard problems despite surface fluency). A concrete argument made is that the Lean ecosystem, combined with Mathlib, creates a machine-readable corpus large enough to fine-tune models on correct mathematical reasoning steps — sidestepping the hallucination problem by making correctness checkable. The paper also discusses the feedback loop: AI tools lowering the cost of formalization could accelerate Mathlib growth, which improves training data quality. Limitations acknowledged include the fact that most frontier mathematical work involves conceptual leaps that do not decompose into sequences of verified lemmas, and that current LLMs show poor performance on problems requiring genuinely novel definitions. The open question the paper poses most sharply is whether the bottleneck is data, architecture, or something more fundamental about the nature of mathematical creativity. Worth reading for the taxonomy of what “AI-assisted mathematics” actually means operationally versus the popular narrative.
Source: https://arxiv.org/abs/2608.16753
Geolocating a random island using geometry and CUDA programming
A detailed OSINT walkthrough that turns a geolocation puzzle into a computational geometry and GPU programming exercise. The author is given an aerial image of an unnamed island and must identify it. After ruling out shape-matching by eye, the approach becomes algorithmic: extract the island contour from the image, compute a normalized shape descriptor (moment invariants, aspect ratio, convexity), then match against a database of island polygons derived from OpenStreetMap coastline data. The interesting engineering part is the brute-force matching: there are on the order of hundreds of thousands of island polygons globally, and for each candidate the author computes a Procrustes-style alignment (translate to centroid, normalize scale, find minimum rotation distance) — an O(N) scan with non-trivial per-candidate cost. This is parallelized on GPU using CUDA: each thread handles one candidate polygon, computing the shape similarity score independently. The author walks through the CUDA kernel structure, memory layout (polygon vertices stored in a flat array with an offset table), and why shared memory is not helpful here due to irregular polygon sizes. Additional constraints narrow the candidate set before GPU search: island area estimated from shadow geometry and sun angle, latitude band inferred from vegetation type in the image. The final match is confirmed by cross-referencing satellite imagery. The post is a good demonstration that OSINT problems can be reduced to well-defined algorithmic problems, and that GPU parallelism applies naturally to brute-force search over independent candidates even when the underlying data is geometrically irregular.
Source: https://yassa9.github.io/osint/gralhix-004/
AI-Generated GitHub Copilot “Autofix” Allowed Compromise of Snowflake’s Jira
A red-team report from Wiz describing a CI/CD attack chain against Snowflake’s internal Jira instance that exploited a GitHub Copilot Autofix suggestion. The technical sequence: a GitHub Actions workflow had a secret scanning policy violation flagged by GitHub’s code scanning. Copilot Autofix generated a remediation PR that, instead of removing the secret, moved it into a GitHub Actions secret variable but simultaneously introduced a command-injection vulnerability in the workflow YAML — the fix interpolated a user-controlled input directly into a run: step without quoting. An attacker with the ability to open a PR (public repo or compromised contributor account) could trigger the workflow with a crafted branch name containing shell metacharacters, achieving arbitrary code execution in the runner context. From the runner, the attack pivots to the internal Jira instance via credentials available in the runner environment. The report emphasizes that the vulnerability was not in Copilot per se but in the pattern of auto-merging AI-generated security fixes without human review — the Autofix suggestion passed automated checks because no static analyzer flagged the injection in the YAML context. The technical lesson is that YAML-based CI workflows have a well-known injection class (${{ github.event.pull_request.head.ref }} and similar) that LLMs routinely miss because the injection vector is context-dependent and not syntactically obvious. The broader concern is that AI-generated code tends to be reviewed less carefully precisely when it is framed as a security fix.
Source: https://www.wiz.io/blog/red-agent-snowflake-copilot-cicd-bug
A third world engineer responds to “RISC-V: They should have known better”
A rebuttal to a post arguing that RISC-V’s design choices (particularly the modular ISA, compressed extension, and lack of mandatory features) make it poorly suited for real embedded systems. The author, writing from a resource-constrained development context, pushes back on several specific technical claims. On the modularity critique: the argument that the optional extension model creates fragmentation is countered by pointing out that ARM Cortex-M has the same problem in practice (Cortex-M0 vs M4 vs M7 software portability is already a solved-by-convention problem, not a solved-by-ISA problem). On the compressed instruction (RVC) critique: the original post argued that 16-bit encodings complicate toolchains; the rebuttal notes that RVC reduces code size significantly on microcontrollers where flash is the binding constraint, and that the toolchain complexity is absorbed by GCC/LLVM, not application developers. The most technically substantive section addresses interrupt latency and the lack of mandatory hardware multiply: the author concedes that RISC-V implementations without M-extension have poor performance on DSP workloads but argues this is a procurement/selection problem, not an ISA design flaw. The rebuttal also raises the cost argument directly — RISC-V MCUs are available at price points that make them accessible to engineers in markets where a $2 vs $0.50 MCU cost difference materially affects project feasibility. The post does not engage much with the formal specification quality or the debug infrastructure (JTAG/RISC-V debug spec) criticisms from the original, which remain the stronger technical objections.
Source: https://rvembedded.com/blog_post/12/
Unsloth Dynamic 3.0 GGUFs
Unsloth’s Dynamic 3.0 GGUF format introduces per-layer, per-tensor mixed-precision quantization that goes beyond the static bitwidth assignments in standard GGUF. The core idea: rather than quantizing all transformer layers to the same bit depth, a calibration pass identifies which layers are most sensitive to quantization error (typically the first and last few layers, attention projections, and embedding tables) and assigns higher bitwidths to those tensors while aggressively quantizing less-sensitive feed-forward layers. The sensitivity metric used is a KL divergence between the output distributions of the full-precision and quantized layer on a calibration dataset. This is not novel in principle (GPTQ and AWQ do similar things) but the contribution is integrating it into the GGUF/llama.cpp ecosystem, which previously only supported homogeneous per-file quantization levels (Q4_K_M, Q5_K_S, etc.). The result is models where the effective average bits-per-weight is lower than a standard Q4 model but perplexity is comparable to Q5 or Q6, because the bits are redistributed to where they matter. Reported numbers: on Llama-3.1-8B, Dynamic 3.0 at ~3.8 bpw achieves perplexity close to standard Q5_K_M (5 bpw) on Wikitext-2. The format is backward-compatible with llama.cpp once the metadata is parsed correctly. The main limitation is that calibration is dataset-dependent — the optimal mixed-precision assignment for a coding-focused model differs from a general-purpose one — and Unsloth’s released GGUFs use a single general calibration set.
Source: https://unsloth.ai/docs/basics/dynamic-3.0-ggufs
Ornith-1.5: From Self-Scaffolding to Self-Improvement
Ornith-1.5 is a small-lab release describing an agent system where the model iteratively rewrites its own inference scaffolding (prompt templates, tool-use wrappers, chain-of-thought structure) based on task performance feedback, then uses the improved scaffolding to generate training data for the next model version. The loop is: (1) run current model on a benchmark task set with the current scaffold, (2) for failures, use a critic model to identify whether the error is in the scaffold logic or the model weights, (3) if scaffold: rewrite scaffold and re-evaluate, (4) collect (input, output) pairs from successful runs under the improved scaffold, (5) fine-tune next model version on this data. The self-scaffolding component is the less-standard part: the scaffold rewriter is a separate prompted LLM call that takes the current scaffold code and failure traces as input and produces a modified scaffold. There is a risk of reward hacking here — the scaffold can be rewritten to make tasks appear easier — and the paper addresses this only partially by holding out a test set that the scaffold rewriter never sees. The quantitative results show improvement on their internal agentic benchmark (task completion rate +12% over 1.0) but the benchmark is not public and comparisons to other agent frameworks are absent. The self-improvement loop is conceptually related to STaR and related self-play methods, but applied to scaffolding rather than reasoning traces. Main open question: whether scaffold improvements generalize across task distributions or overfit to the calibration task set.
Source: https://ornith.ai/ornith_1_5.html
Bun 1.4 Rust rewrite is not looking good?
A critical analysis of Bun’s ongoing partial rewrite from Zig to Rust, written by an outside observer tracking the project’s public development. The technical concerns raised are concrete. First, the rewrite is incremental rather than complete: Bun’s core hot paths (the JS engine integration with JavaScriptCore, the bundler parser, the HTTP layer) remain in Zig, and the Rust portions are being added for new subsystems. This creates an FFI boundary between Zig and Rust that is both a performance concern (crossing the boundary requires careful ABI management, no zero-cost) and a maintenance concern (two build systems, two memory models, manual unsafe blocks at the seam). Second, the author points to specific GitHub issues and PRs where the Rust FFI layer has introduced subtle memory safety violations at the boundary — the safety guarantees Rust provides internally do not extend across the Zig/Rust interface, which requires unsafe on the Rust side anyway. Third, velocity: the Rust subsystems appear to be developed by a smaller subset of the Bun team, and PRs are merging slower than the Zig-side work. The author is not arguing Rust is the wrong choice in principle, but that rewriting performance-critical infrastructure incrementally in a second language, when the first language (Zig) already provides manual memory management, creates complexity without a clear payoff unless the Rust ecosystem libraries (tokio, etc.) are being leveraged for the rewritten subsystems — and the post argues they are not being used consistently.
Source: https://tipiirai.com/writing/bun-rust-rewrite-worries
Go 1.27
Go 1.27 ships several changes worth noting. The most significant is the stabilization of the generic type aliases feature (previously experimental): type aliases can now carry type parameters, resolving a long-standing gap where type Alias[T any] = SomeGenericType[T] was not legal. This matters for large codebases that use type aliases for API compatibility — the previous workaround was a wrapper struct, which breaks interface satisfaction. The second notable change is improved profile-guided optimization (PGO): 1.27 extends PGO to cover more inlining decisions and adds devirtualization of interface calls in PGO mode, where the compiler can speculate on the concrete type behind an interface if profiling data shows a dominant type. This is standard in JVM JIT compilers but novel for an AOT compiler; benchmarks show 2-5% throughput improvement on interface-heavy workloads. The runtime adds a new weak package providing weak references — pointers that do not prevent GC collection — useful for implementing caches without finalizer hacks. The testing package gains T.Context(), returning a context that is cancelled when the test ends, replacing the boilerplate pattern of ctx, cancel := context.WithCancel(context.Background()); t.Cleanup(cancel). Tool changes: go test can now filter by doc comment content with -run-doc, and the linker has reduced binary sizes for programs that import net or crypto/tls by eliminating dead code more aggressively via improved reachability analysis.
Source: https://go.dev/blog/go1.27
Noteworthy New Repositories
Kylin010/tcpfit
A data-driven TCP tuning tool that derives per-machine parameters from empirical measurement rather than applying static heuristics. The core idea is straightforward but underused in practice: measure the actual Bandwidth-Delay Product (BDP) of each host’s network path and identify the exact inflection point of any traffic shaper or policer on that path. From these measurements, tcpfit computes appropriate values for tcp_rmem/tcp_wmem buffer sizes, congestion window initialization, and related sysctls. This avoids the common failure mode where operators copy kernel parameter sets from blog posts tuned for hardware they do not own. The tooling runs active probes to estimate RTT under load and saturates the path to find where the shaper kicks in, then fits buffer recommendations to the measured BDP (BDP = bandwidth \times RTT). Particularly useful in cloud environments where the effective network path changes per instance type or placement group. The implementation is shell/Python and targets Linux; the repo includes test scripts and example output for several common instance types. Engineers running latency-sensitive services or high-throughput data pipelines who have hit throughput ceilings without obvious CPU or NIC bottlenecks are the primary audience.
Source: https://github.com/Kylin010/tcpfit
ShawnPana/phone-harness
A harness layer that exposes Android (and partially iOS) device control to LLM-based agents. The architecture wraps ADB commands and the Android Accessibility Service into a structured action space — tap, swipe, type, scroll, back, screenshot — that an agent can call via a function-calling or tool-use API. Screenshots are captured, optionally downscaled, and passed as vision inputs; the agent then emits action tokens that the harness translates into device events. The repo includes prompt scaffolding for task decomposition, a simple replay/record mechanism for supervised demonstration collection, and hooks to swap in different VLM backends (GPT-4o, Gemini, local models via Ollama). Unlike full GUI-automation frameworks like Appium, phone-harness is explicitly oriented toward agentic, open-ended task execution rather than scripted test sequences. It is thin by design: the harness does not implement its own planner, so users compose it with any agent loop they already have. Relevant for researchers working on mobile GUI agents, automated QA pipelines that need natural-language-driven test generation, or anyone building personal-assistant applications that require real device interaction beyond what emulators or web APIs expose.
Source: https://github.com/ShawnPana/phone-harness
Spielewoy/autoprompt-skill
A packaged skill for coding agents that addresses prompt fragility in multi-step code generation. The core claim is a 45% reduction in task failure rate on agentic coding benchmarks. Mechanically, autoprompt-skill intercepts the agent’s prompt construction step and applies a lightweight classifier to detect under-specified or ambiguous instruction patterns, then rewrites or expands them before the LLM call. It also maintains a structured context window — tracking which files have been read, which edits have been applied, and which tests have been run — so that later steps in a multi-turn session do not lose grounding. The skill is designed as a drop-in module compatible with common agent frameworks (LangChain, AutoGen, custom loops) via a thin adapter interface. The implementation is Python; the repo ships a benchmark harness reproducing the reported numbers using HumanEval-style multi-step tasks. The 45% figure should be interpreted relative to the baseline agent and task set described in the repo’s eval scripts, not as a universal claim. Most useful for teams running coding agents on long-horizon tasks (multi-file refactors, test generation pipelines) where prompt drift across turns is the dominant failure mode rather than raw model capability.
Source: https://github.com/Spielewoy/autoprompt-skill
SuchanMadhikarmi/kubernetes-zero-to-production
A structured, production-oriented Kubernetes curriculum comprising 47 lessons and over 35 hands-on labs. Unlike documentation-style references, the repo is sequenced as a learning path: it starts from control plane internals and moves through namespaces, RBAC, networking (CNI, Services, Ingress, NetworkPolicies), storage (PV/PVC, StorageClasses), workload controllers, Helm, GitOps patterns, observability, and hardening. Each lesson directory contains manifest files that can be applied directly against a local cluster (minikube, kind, k3s) or a managed provider. Architecture diagrams are included inline to clarify concepts like pod scheduling, etcd quorum, and service mesh data planes. The repo also includes a cheat sheet collection covering kubectl command patterns, and a section specifically targeting CKA/CKAD/CKS certification objectives alongside general interview question banks. The interview prep content covers both conceptual questions and debugging scenarios (pod stuck in CrashLoopBackOff, OOMKilled, scheduling failures). Engineers transitioning from application development into platform/SRE roles, or those preparing for Kubernetes certifications, will find the lab-first structure more actionable than reading official docs linearly.
Source: https://github.com/SuchanMadhikarmi/kubernetes-zero-to-production
guillaumemeyer/watermarks-remover
A multi-format tool targeting AI provenance signals embedded in content by commercial generation systems. It operates on three distinct layers. First, Unicode text hygiene: removes zero-width characters, homoglyph substitutions, and non-printing codepoints used by systems like SynthID-Text to encode statistical watermarks in token selection. Second, statistical rewrite hooks: applies paraphrase rewrites intended to disrupt distributional watermarking schemes that rely on green/red token list biases (as in the Kirchenbauer et al. scheme). Third, metadata stripping: removes C2PA (Coalition for Content Provenance and Authenticity) manifests and standard EXIF/XMP metadata from PNG, JPEG, SVG, PDF, DOCX, HTML, and Markdown files. The C2PA removal is technically non-trivial because C2PA embeds cryptographically signed provenance chains; the tool strips the payload but cannot forge a valid replacement signature. This is a research and auditing tool with obvious dual-use implications. Its technical value is as a reference implementation showing exactly where and how these provenance mechanisms attach to content, which is useful for researchers evaluating watermark robustness. The statistical rewrite component’s effectiveness depends heavily on the specific watermarking scheme in use.
Source: https://github.com/guillaumemeyer/watermarks-remover
0xsline/awesome-deepseek-harness
A curated ecosystem index for the DeepSeek Harness (DSH) framework, aggregating plugins, infrastructure tools, and integration patterns from the dsh-external/hub organization and repos tagged with the dsh-plugin GitHub topic. DSH is a plugin-based execution harness for DeepSeek models that standardizes how tools, retrieval backends, and agent scaffolding attach to the model’s function-calling interface. This repo functions as an annotated registry: entries are grouped by category (RAG connectors, code execution sandboxes, memory backends, monitoring/tracing integrations, UI frontends) and each entry includes a short description of the plugin’s interface contract and any known compatibility constraints by DSH version. The value is discoverability — the DSH plugin ecosystem is fragmented across many small repos, and this list reduces the cost of finding a maintained implementation for a given integration need. It is comparable in purpose to awesome-langchain or the LlamaHub index but scoped to DSH. Engineers building production systems on DeepSeek models who want to avoid reimplementing standard plumbing (vector store connectors, tool schemas, structured output parsers) are the primary audience.
Source: https://github.com/0xsline/awesome-deepseek-harness
Electricitysheep/dsh-handbook
A bilingual (Chinese and English PDF) technical handbook for the DeepSeek Harness (DSH) framework, covering the full operational lifecycle from installation to advanced use cases. The content is structured as a practitioner manual: installation and environment setup, plugin development (the plugin API, schema definitions, lifecycle hooks), performance tuning (batching, KV cache configuration, quantization choices and their latency/quality tradeoffs), and real-world case studies. A notable section presents empirical comparisons of multi-agent configurations where multiple DeepSeek model instances collaborate on tasks — the handbook reports measured throughput and task completion metrics across different agent topology choices (pipeline vs. broadcast vs. hierarchical). This distinguishes it from generic LLM deployment guides by grounding recommendations in actual DSH-specific behavior. The handbook is delivered as static PDFs alongside markdown source, making it usable offline and easy to search. Practitioners deploying DSH in production who need both a getting-started path and a reference for non-obvious tuning decisions — particularly around multi-agent coordination overhead — will find it more immediately useful than reading source code or scattered GitHub issues.
Source: https://github.com/Electricitysheep/dsh-handbook
bawadou/ai-data-extractor
A utility for extracting and exporting conversation histories from AI coding assistant tools that store data in proprietary local formats. Supported tools include Claude Code, Cursor, Windsurf, Aider, and Cline/Roo Code. Each assistant persists chat history differently — SQLite databases, JSON blobs, JSONL logs, or custom binary formats in platform-specific application data directories. The extractor implements a per-tool parser for each format, normalizes the output to a common schema (turn role, timestamp, message content, attached code context, tool calls/results), and writes to standard formats (JSON, CSV, Markdown). This is practically useful for: auditing what context was sent to external APIs (privacy and compliance use cases), building personal fine-tuning datasets from accumulated coding sessions, migrating histories between tools, and analysing patterns in one’s own coding assistant usage. The implementation is Python with no cloud dependencies — all processing is local. The repo includes format documentation for each supported tool’s storage schema, which is itself a useful reference independent of the extraction code. Teams with compliance requirements around what developer queries are retained locally versus transmitted, and researchers wanting to study real coding assistant interaction data, are the primary users.