Daily AI Digest — 2026-06-22
arXiv Highlights
BrainG3N: A Dual-Purpose Tokenizer for Controllable 3D Brain MRI Generation
Problem
Latent diffusion for 3D medical imaging places contradictory demands on the tokenizer. The encoder must produce latents that retain clinically actionable signal (genotype, grade, diagnosis) so that conditioning and downstream probing work; the decoder must invert those latents into anatomically faithful voxels. Tokenizers trained end-to-end with a reconstruction objective — the standard CNN-VAE recipe inherited from natural-image latent diffusion — push the encoder toward low-level texture features and discard the semantic structure that disease-relevant tasks act on. For brain MRI, where cohorts are small, sites are heterogeneous, and clinically meaningful contrasts (e.g. IDH1 mutation, WHO grade, AD vs. HC) are subtle, this trade-off is the limiting factor for generative augmentation, counterfactual simulation, and privacy-preserving sharing.
Method
BrainG3N decouples the two objectives by training a 3D masked autoencoder (MAE) encoder first, freezing it, then training a CNN decoder on top of a low-dimensional linear projection of the encoder embeddings.
Phase 1: a fully volumetric MAE encoder is pretrained on 35,309 volumes from 18 cohorts (17,399 subjects, 200+ sites, four modalities — T1, T2, FLAIR, T1c — ten clinical categories, ages 5–98). All volumes are affine-registered to SRI24 with ANTs, skull-stripped with HD-BET, N4-corrected, yielding 160{\times}192{\times}160 volumes at 1 mm isotropic. The encoder outputs a token grid with channel dimension 1152.
Phase 2: a linear projection z' = W z maps the 1152-dim per-token embedding to d' channels, and a dedicated CNN decoder D_\phi(z') is trained to reconstruct voxels. The encoder weights are not updated. The latent that the diffusion model operates on is z', not z, so the diffusion input dimensionality is set by d'.
The key empirical knob is d'. On a 1100-volume tumor cohort (UCSF-PDGM + UPENN-GBM), the authors sweep d' \in \{32, 128, 512\}. Reconstruction PSNR/SSIM increase monotonically in d' with diminishing returns past 128. More importantly, they linear-probe the projected z' to test whether the bottleneck destroys clinical content. At d'=32, IDH1 mutation probing AUC is 0.861 vs. 0.883 from the raw 1152-dim embeddings — a 0.022 drop at less than 3% of the original dimensionality (38K vs. 1.4M latent variables). The WHO grade gap is 0.055. They adopt d'=32 for all downstream experiments, trading marginal probing accuracy for a much smaller diffusion input.
Reconstructions at d'=32 preserve cortical folding, ventricular geometry, and overall morphology across age and disease state, including an Alzheimer’s case with enlarged ventricles. This is the visual evidence that a 32-channel projection of a frozen MAE encoder is sufficient for anatomically faithful decoding.
A conditional DiT is then trained in z'-space with classifier-free guidance. Conditioning attributes include age, disease label, modality, and tumor presence.
The counterfactual panel fixes the initial noise and sweeps one attribute at a time. Age sweeps (30 → 75 at HC) produce expected ventricular enlargement and cortical thinning; the HC → AD sweep at age 75 produces additional medial-temporal atrophy; modality sweeps (T1/T2/FLAIR) change contrast without changing anatomy. The fact that disentanglement holds under fixed noise is the strongest evidence that the conditioning signal acts on the intended axes of variation rather than being absorbed by the noise.
Longitudinal forecasting
The frozen tokenizer is also evaluated as a forecasting substrate on held-out ADNI subjects: given a baseline volume and a \Delta t, predict the follow-up.
The difference maps line up spatially with real atrophy, concentrated in periventricular and medial-temporal regions, with z-score magnitudes printed per row. The forecasts are not photorealistic novel scans — they are forecasts of the same subject — which is the appropriate use of a clinically informative tokenizer.
Results summary
- 23-task linear probing: matches or exceeds SOTA (full table in appendix; abstract claim).
- Bottleneck: d'=32 retains IDH1 AUC within 0.022 of the 1152-dim encoder and WHO grade within 0.055, at 1/36 the dimensionality.
- Reconstructions remain anatomically faithful at d'=32 across modality and disease.
- Conditional DiT exhibits attribute-disentangled counterfactuals under same-noise sweeps.
Limitations and open questions
The paper reports only one bottleneck ablation (d'\in\{32,128,512\}) on a single tumor cohort; whether d'=32 remains sufficient for fine-grained tasks like cortical thickness regression or small-lesion segmentation is untested. The MAE encoder is frozen, so any clinical signal it failed to learn during Phase 1 is permanently absent from z'; this places strong weight on pretraining coverage. The decoder is deterministic given z', which means generative diversity is entirely sourced from the diffusion prior — pathology that is sub-token-resolution may be averaged out. Quantitative forecasting metrics (per-region atrophy correlation with real follow-up) are shown qualitatively in the figure but not benchmarked against established longitudinal models. Finally, harmonized preprocessing to SRI24 limits the model’s exposure to native-space variability that real deployment would encounter.
Why this matters
Decoupling the encoder and decoder objectives, with a frozen clinically-pretrained encoder and a thin linear projection feeding a CNN decoder, is a cleaner solution to the tokenizer trade-off in medical latent diffusion than yet another joint VAE objective. The result is a single 32-channel latent that supports probing, conditional generation, and longitudinal forecasting from one tokenizer — a meaningful step toward generative models that are useful clinically rather than only visually.
Source: https://arxiv.org/abs/2606.19651
Multi-Turn Reflective Masking Elicits Reasoning in Mask Diffusion Models
Mask diffusion models (MDMs) generate by progressively unmasking tokens under an absorbing Markov process: once a position is revealed, it is fixed. This breaks the natural symmetry with how humans iterate on a draft — locally re-edit a wrong region without rewriting the whole sequence. Autoregressive chain-of-thought reasoning compensates by appending reflective continuations, but every revision requires regenerating from the edit point onward. This paper argues that MDMs can recover something closer to local in-place reflection if the denoiser is allowed to re-mask its own previous outputs, and proposes Reflective Masking (RM) plus a parameter-free history mechanism (History Reference, HR) to elicit this behavior via lightweight post-training.
Method
Let x^\ast \in \mathcal{V}^N be the target, E \subseteq \{1,\dots,N\} the editable positions, and \bar{\mathcal{V}} = \mathcal{V} \cup \{\texttt{MASK}\}. Each editable position at step t takes values in \{w_i, \texttt{MASK}, x_i^\ast\}, where w_i is a task-specific wrong token. The model emits a categorical p_\theta(\cdot \mid \tilde{x}^{(t)})_i over \bar{\mathcal{V}}, and the next-step transition is deterministic per position:
\tilde{x}^{(t+1)}_i = \begin{cases} \texttt{M} & \text{if } \tilde{x}^{(t)}_i \neq \texttt{M} \text{ and } p_\theta(\texttt{M}\mid \tilde{x}^{(t)})_i > p_\theta(\tilde{x}^{(t)}_i\mid \tilde{x}^{(t)})_i \\ \tilde{x}^{(t)}_i & \text{if } \tilde{x}^{(t)}_i \neq \texttt{M} \text{ and } p_\theta(\texttt{M}\mid \tilde{x}^{(t)})_i \leq p_\theta(\tilde{x}^{(t)}_i\mid \tilde{x}^{(t)})_i \\ \arg\max_{v\in\mathcal{V}} p_\theta(v\mid \tilde{x}^{(t)})_i & \text{if } \tilde{x}^{(t)}_i = \texttt{M} \end{cases}
The decision rule is symmetric and intuitive: if the model gives more mass to MASK than to the currently displayed token, that token is judged wrong and is re-masked; otherwise it is kept; masked positions are filled with the argmax over \mathcal{V} only. This unifies three actions — keep, re-mask, reveal — under one per-position decision driven entirely by the model distribution.
Conditioning only on \tilde{x}^{(t)} produces cycles: identical states reappear and the trajectory loops. History Reference fixes this without changing the rule. Past states are embedded and aggregated into a per-position history-aware embedding that is added to the current-state embedding before being fed to the denoiser.
Because HR is parameter-free, the existing MDM backbone is untouched. To train the re-masking behavior, the authors synthesize trajectories that include both MASK corruption and wrong-token corruption w_i, then sample synthetic histories along admissible transition paths consistent with Eq. (1). The training target instructs the model to output MASK at positions currently holding a wrong token and the correct x_i^\ast elsewhere — directly teaching the keep/re-mask/reveal trichotomy.
The recipe is cheap: full training across the three benchmarks finishes in roughly 5 hours on 2×H100 80GB, in contrast to the multi-day runs typical of architecture-modifying alternatives.
Results
Evaluation spans three regimes with decreasing external supervision: instruction image editing (strong guidance), Sudoku (structured reasoning), and math/code (no guidance about the answer).
On instruction-based in-place image editing with Lumina-DiMOO as the base model, training on 85k ImgEdit examples and testing on 1.7k held-out examples, RM substantially outperforms both the vanilla base and SFT under matched setup. Edit Precision jumps from 65.81 (Lumina) and 71.84 (SFT) to 99.73; Edit Coverage from 41.68 / 48.42 to 73.02. Background preservation also improves sharply: MAE-RGB drops from 12.497 / 11.035 to 3.613, PSNR rises from 23.09 / 23.90 dB to 34.76 dB, and SSIM from 0.626 / 0.657 to 0.9744. Overall quality follows: VQAScore 71.95 / 81.61 → 85.17, user-study preference 41.8 / 53.3 → 68.2.
The mechanism is visible qualitatively: RM’s pixel-difference heat maps concentrate in the intended regions, while baselines smear modifications across the entire image. This is exactly the failure mode that motivates re-masking — selective regeneration of locally wrong tokens, with the rest of the canvas held fixed by the keep action.
The paper extends this to Sudoku (structured local correction with limited guidance) and to math/code reasoning, where the model must autonomously discover which prior tokens are wrong. HR’s role grows as supervision weakens: in image editing the instruction localizes the edit, whereas in math/code the model must rely on intermediate denoising trajectory information to know what to revisit.
Limitations and open questions
The decision rule compares only p_\theta(\texttt{MASK}) against the currently shown token’s probability; it is unclear how robust this is when the model is poorly calibrated on MASK, or when multiple correct alternatives exist with split mass. The reliance on synthetic wrong-token w_i during training means coverage of plausible error modes depends heavily on the corruption distribution. Convergence properties of the iterative process are not characterized beyond the heuristic argument that HR breaks cycles; whether the dynamical system has fixed points or only periodic orbits in pathological cases is left open. Finally, the inference cost scales with the number of reflective turns, and the paper does not report a controlled compute-matched comparison against simply running more standard denoising steps.
Why this matters
Reflective Masking gives MDMs a native test-time scaling axis — iterate to selectively revise — that AR models can only approximate by regenerating suffixes. The fact that a single per-position probability comparison plus a parameter-free history embedding suffices, with 5 hours of post-training, suggests this capability is latent in current MDM checkpoints and merely needs to be unlocked.
Source: https://arxiv.org/abs/2606.16700
PerceptionDLM: Parallel Region Perception with Multimodal Diffusion Language Models
Problem
Region-level perception — producing detailed captions for N user-specified regions in an image — is bottlenecked by autoregressive (AR) decoding. Existing systems such as DAM and GAR run one forward pass per region, y_i = f(I, R_i), so wall-clock latency grows linearly with N. For dense scenes (tens of masks), this is the dominant cost. PerceptionDLM reformulates the task as a single joint prediction \{y_i\}_{i=1}^N = f(I, \{R_i\}_{i=1}^N) executed inside one denoising diffusion process, exploiting the inherent token-parallel decoding of discrete diffusion LMs (DLMs).
Base model
PerceptionDLM-Base is a SigLIP-2 (so400m-patch16-512) + 2-layer GELU MLP connector + LLaDA-Instruct-8B stack, trained with the masked-token DLM objective restricted to the response span X_a:
\mathcal{L}_{\mathrm{PerceptionDLM_{Base}}} = -\mathbb{E}_{(X_v,X_q,X_a),t,x_t}\left[\frac{1}{t}\sum_{i\in\mathcal{M}_a}\log p_\theta(x_0^i \mid x_t, H_v, X_q)\right].
Visual embeddings H_v and instruction tokens X_q are kept clean; only X_a undergoes absorbing-state corruption. Training runs in four stages over 1M/14M/22M/15M samples (Bee-Training, LLaVA-OneVision-1.5-Instruct, Honey-Data-15M) on 32×H100s for ~3 weeks with dynamic 512×512 tiling.
On standard MLLM evaluations the base outperforms prior open-source diffusion VLMs (LLaDA-V, MMaDA, LaViDa, SDAR-VL, Dream-VL) and is competitive with Qwen2.5-VL-7B and InternVL3-8B: MMBench 85.0, ChartQA 91.6, DocVQA 89.9, MMVP 82.0, BLINK 60.3, HallusionBench 58.4. Notable jumps over LLaDA-V include ChartQA (78.3→91.6) and MathVista (52.4→65.5).
Parallel region perception
Three components convert the base into a parallel region captioner:
- Region prompting. For each of N masks the prompt is templated to include a region tag and a dedicated response slot of length 32 tokens. The model jointly attends to all N slots in one diffusion trajectory.
- RoI-aligned feature replay. For each mask R_i, region features are pooled at a 4×4 RoI grid from H_v and re-injected into the corresponding response slot. This anchors each slot to its target region’s visual content, mitigating cross-region feature leakage that plagues both AR region models and naive DLMs.
- Structured attention masking. Each region’s response tokens can attend to (a) the full visual context H_v, (b) shared instruction tokens, and (c) only its own response slot and RoI tokens — not those of other regions. This disentangles parallel generations during denoising while preserving global image context.
Training initializes from PerceptionDLM-Base, sets all parameters trainable, uses up to 6 region prompts per image, batch size 256, lr 4\times10^{-5}, one epoch on ParaCaption-5.7M (~2 days on 32×H100). Inference uses 32 denoising steps and a 32-token slot per mask.
Results
The authors construct ParaDLC-Bench by scaling DLC-Bench with multi-region prompts drawn from Objects365 V2 (54 images / 178 masks) and DaTaSeg (46 / 121), explicitly selecting spatially adjacent or semantically confusable instance combinations.
On ParaDLC-Bench (Pos / Neg / Avg / TPF / Time):
- PerceptionDLM-8B: 42.3 / 82.4 / 62.4, TPF = 2.9, 276 s.
- DAM-3B (AR): 48.1 / 87.2 / 69.2, TPF = 1, 326 s.
- GAR-8B (AR): 49.0 / 87.6 / 69.5, 479 s.
- PixelRefer-7B: 40.8 / 78.7 / 60.5, 718 s.
- LLaDA-V-8B (diffusion, best-quality setting): 24.1 / 46.3 / 35.2, 3241 s.
- Gemini-3.1-Pro: 43.6 / 81.1 / 63.7.
On the single-region DLC-Bench, PerceptionDLM scores 33.4 / 72.8 / 53.1 vs LLaDA-V 10.0 / 39.2 / 24.6 and DAM 52.3 / 82.2 / 67.3. So PerceptionDLM substantially closes the gap to specialized AR region models while running ~1.7–2.6× faster than DAM/GAR, ~12× faster than LLaDA-V, and ~2.6× faster than PixelRefer, with TPF ≈ 2.9 regions effectively processed per forward sweep. Against general-purpose frontier models (GPT-5.2, Gemini-2.5/3.1-Pro), PerceptionDLM is competitive on Avg (62.4 vs 55.2–63.7) at far lower cost per region.
Limitations and open questions
- Quality still trails dedicated AR region models (DAM/GAR average ~69 vs 62.4); the parallel attention masking trades some cross-region semantic coupling for disentanglement, which can hurt when descriptions should reference relations between regions.
- Throughput is reported at batch size 1; the AR baselines’ latency could narrow with batched region inference, though they cannot match true token-level parallelism within a single sequence.
- The model is trained with at most 6 region prompts; scaling to many tens of masks per image and the resulting attention/sequence-length cost is not analyzed.
- Inference uses a fixed 32 steps × 32 tokens per mask; adaptive length and step schedules are unexplored.
- ParaDLC-Bench has only 100 images / 299 instances; reliability of LLM-judge scores across judges is reported but the absolute scale is small.
Why this matters
This is a clean demonstration that discrete diffusion LMs offer a structural advantage over AR MLLMs for tasks that are inherently set-valued rather than sequential — multi-region captioning, multi-entity grounding, and arguably multi-question VQA — by collapsing N sequential decodes into one denoising trajectory with disentangled per-slot attention. The recipe (region prompting + RoI replay + structured masks) is a reusable template for porting other multi-target perception tasks onto DLM backbones.
Source: https://arxiv.org/abs/2606.19534
WorldLines: Benchmarking and Modeling Long-Horizon Stateful Embodied Agents
Problem
Long-term memory benchmarks for LLMs largely test dialogue retrieval and QA over chat logs, while embodied benchmarks (ALFRED, Habitat tasks) test short-horizon execution where the world state is fully visible or quickly reset. Neither setting probes what a household robot actually needs: maintaining a persistent, partially observable world state across many days, distinguishing what was directly observed from what was merely reported, handling state overwrites (an object moved twice, a timer reset), and translating that memory into state-consistent plans. WorldLines targets this gap.
Benchmark construction
A WorldLines instance is
x_i = (\mathcal{H}_{<c_i}, q_i, S_{c_i}, \mathcal{E}_i, y_i^\star, \tau_i),
where \mathcal{H}_{<c_i} is the visible history before cutoff c_i, q_i the question or task, S_{c_i} the ground-truth world state, \mathcal{E}_i an evidence chain of supporting events, y_i^\star the reference answer/plan, and \tau_i the task type. Crucially, S_{c_i} and \mathcal{E}_i are held out from the agent and used only by evaluation. Traces are grounded in Habitat/HSSD scenes with manually curated objects, receptacles, and controllable devices; a closed-loop generator produces dialogues, navigate/pick/place/open/close/set_device_state/handoff actions, execution feedback, and object/device state transitions over multiple days.
Samples are organized along eight memory targets (object_location, temporal_state, device_state, preference, routine, planning_dependency, hidden_state, social_context) and two task families: Memory QA and Embodied Task Planning. A representative QA sample shows a coffee-timer mistake on May 3 (set to 04:00) overwritten by a robot correction on May 4 (07:00); the cutoff is placed after the correction so the agent must reconstruct both events.
ObsMem method
ObsMem treats memory as an online typed-evidence process. At ingestion an observer gate decides visibility: for event o_t with observer set V_t and robot r,
\Phi(o_t)=\begin{cases}\{e_t^{\mathrm{obs}}\}\cup \mathbf{1}[\mathrm{utt}(o_t)\wedge \mathrm{actor}(o_t)\neq r]\{e_t^{\mathrm{rep}}\}, & r\in V_t,\\ \varnothing, & r\notin V_t.\end{cases}
So a directly observed action yields an observed atom; a third-party utterance about the same fact yields a reported atom — these are never merged into a single textual record. Each accepted event is then routed into three views:
- Event Track: timestamped historical evidence.
- State Track: structured facts produced by executable actions (e.g.,
laptop.location=sofa), supporting overwrite semantics. - Commitment Track: requests, reminders, schedules from utterances.
A belief view tracks the robot’s epistemic confidence (observed vs. reported, possibly contradicted). At query time, instead of a single dense retrieval over text, an evidence selector composes views based on the question type, returning up to five typed records to the answer generator.
Results
All systems share cutoff-controlled history, top-5 retrieval cap, Gemini-3.5-flash answer generation, and GPT-4o as judge (Fleiss’ \kappa=0.71 on human re-annotation, 87.5% judge–human agreement, Spearman 0.82).
On 310 Memory QA samples, ObsMem reaches Judge 0.713 / Perfect 69%, against the next-best A-mem at 0.575 / 53% and Mem0 at 0.554 / 53%. GraphMem (0.457) and MemoryOS (0.312) trail. The gap is largest on evidence-demanding metrics: Event R@5 is 0.537 for ObsMem vs. 0.378 (Mem0) and 0.355 (A-mem); StateMH-E (event-level recall in multi-hop state QA) is 0.452 vs. 0.264 (Mem0). Session Any@5 differences are smaller (0.879 vs. 0.839 for A-mem), confirming that coarse session retrieval is largely solved and the open problem is precise event-level evidence recovery under state overwrites.
Ablations on a 62-sample diagnostic subset isolate the contribution of each ObsMem component. Removing the evidence selector is most damaging (-0.264 Judge, to 0.435), followed by episode consolidation (-0.145), world-state retrieval (-0.102), and belief-view retrieval (-0.048). The Hidden Judge column — restricted to six hidden-until-observed questions — collapses to 0 without belief-view retrieval or the selector, confirming that distinguishing observed vs. reported provenance is necessary for hidden-state reasoning. Selector ablation also halves latency (5.54s vs. 8.82s), exposing a quality/cost trade-off.
Limitations
- Traces are LLM-authored via the staged prompt pipeline; while grounded in Habitat scenes and verified against annotated evidence, distributional artifacts of GPT-4o-mini generation are not characterized. (2) Evaluation relies on LLM-as-judge; despite reasonable agreement, \kappa=0.71 leaves headroom and may favor certain phrasings. (3) The 5-record context cap, while equalizing budgets, may understate baselines that benefit from larger contexts; conversely it understates ObsMem’s typed-evidence advantage at scale. (4) Embodied Task Planning numbers are not reported in the excerpt; whether ObsMem’s gains transfer fully to plan generation (as opposed to QA) remains to be substantiated. (5) ObsMem requires action-native action logs with executable semantics — applying it to purely visual perception streams would require an action/state extractor not evaluated here.
Why this matters
WorldLines reframes embodied memory as state maintenance under partial observability and overwrites, rather than dialogue retrieval, and shows that the dominant text-memory architectures (Mem0, A-mem, MemoryOS, GraphMem) plateau on precise evidence recovery (Event R@5 below 0.4) even when session-level retrieval is near-saturated. ObsMem’s gains come almost entirely from typed views and an observer gate — cheap structural priors — suggesting that for long-horizon household agents, memory schema design matters more than retrieval scale.
Source: https://arxiv.org/abs/2606.18847
GeneralVLA-2: Geometry-Aware Reconstruction and Governed Memory for Robot Planning
GeneralVLA-2 targets two failure modes in hierarchical VLA stacks that turn language + RGB-D into end-effector trajectories. First, the SAM3D-style monocular object reconstruction used in the original GeneralVLA hallucinates pose and unseen geometry — a known issue when only a single view is available, but unnecessary when calibrated multi-view RGB-D is at hand. Second, the original KnowledgeBank is a flat retrieval store: semantically similar snippets are returned and new entries are appended, with no notion of confidence, conflicts, geometric relevance, or lifecycle. Both bottlenecks degrade the quality of evidence presented to the planning agent, and therefore the reliability of the trajectories it emits.
The system-level picture is straightforward (Figure 1): when calibrated multi-view observations of the target object exist, GeoFuse-MV3D produces refined object-centric geometry; this geometry, together with retrievals from a governed KnowledgeBank, conditions a 3D-capable planning agent that emits a multi-stage end-effector path executed by the grasping/motion module.
GeoFuse-MV3D: conservative geometry-only refinement
GeoFuse-MV3D is built on top of MV-SAM3D rather than replacing it. The input is a fixed five-view set \mathcal{D}=\{(I_i, M_i, K_i, T_i)\}_{i\in\mathcal{V}_{\mathrm{in}}},\quad \mathcal{V}_{\mathrm{in}}=\{0,1,2,3,4\}, with RGB I_i, object mask M_i, intrinsics K_i, and pose T_i. MV-SAM3D yields an initial Gaussian object G_0=\{(x_0^j,\theta_0^j)\}_{j=1}^N, where x_0^j\in\mathbb{R}^3 is the Gaussian center and \theta_0^j collects opacity, scale, rotation, and SH appearance. GeoFuse-MV3D leaves \theta untouched throughout — fusion is geometry-only, so color/opacity/SH from the baseline are preserved.
The branch (Figure 2) combines two independent geometry sources, both gated by the same mask consistency criterion. Source A starts from the MV-SAM3D output, queries an external geometry-prior provider (VGGT in the implementation), and applies a lightweight appearance affine calibration so VGGT outputs are placed in the baseline’s coordinate/photometric frame. Source B is an input-view axis-compensation branch that does not call any external model and instead derives small per-axis corrections from the input views themselves. Using two sources avoids over-reliance on VGGT priors where they disagree with the actual masks.
Both sources are filtered against the input-view masks. For a candidate point p, let \mathcal{V}(p) be the set of input views into which p projects, \pi_i the projection into view i, and M_i(\pi_i(p)) the bilinearly sampled mask value. The support score is s(p)=\frac{1}{\max(|\mathcal{V}(p)|,1)}\sum_{i\in\mathcal{V}(p)} M_i(\pi_i(p)). The key design choice is what to do with low-support points. Hard deletion or opacity attenuation is the typical move in visual-hull pipelines, but this is brittle when masks are noisy and creates holes. GeoFuse-MV3D instead converts low support into a small inward geometry correction toward the object center c: p' = c + (p-c)(1-\lambda(p)), with \lambda(p) bounded by a small maximum shrink ratio. This is a soft visual-hull regularizer: it nudges weakly supported geometry toward the carving boundary without destroying mass.
After the per-point soft correction, a low-dimensional axis-wise affine a\in\mathbb{R}^{\cdot} is applied to the Gaussian centers, and the identical transform is synchronized to the mesh vertices so that downstream tools (which may consume the mesh rather than the Gaussians) remain coherent. Because the appearance parameters are never overwritten, the refinement cannot regress photometric quality through fusion artifacts.
Quantitative results on GSO-30
The reconstruction branch is evaluated on GSO-30 (Google Scanned Objects) under the official MV-SAM3D protocol: identical object list, identical input views \{0,1,2,3,4\}, identical masks, identical camera poses. Held-out rendering on views \{10,\ldots,24\} is scored with CD, PSNR, SSIM, LPIPS. Only the refinement stage differs from the baseline. Relative to MV-SAM3D, GeoFuse-MV3D reports:
- CD: -2.20\%
- LPIPS: -2.02\%
- PSNR: +2.36\%
- SSIM: +1.03\%
All four metrics improve simultaneously, which is the expected signature of a geometry-only fusion that does not trade appearance for shape. The full per-object table is deferred to Appendix A.
Governed KnowledgeBank
The second contribution upgrades the retrieval memory from a similarity-indexed append store to a governed long-term memory. Every record carries explicit metadata: a quality label produced by a verifier, a confidence score, a lifecycle state, and conflict tags pointing at records that disagree with it. Retrieval is precision-oriented: rather than returning the top-k semantically nearest snippets, the planner consumes only verified, non-conflicting, geometrically relevant entries, with conflict resolution driven by the metadata. The 3DAgent then conditions on the joint evidence — refined GeoFuse-MV3D geometry plus governed retrievals — before emitting the trajectory.
Limitations and open questions
The reconstruction gains are modest in absolute terms (a few percent on each metric) and rely on the availability of five calibrated views with reasonable masks; the paper does not characterize behavior when masks are heavily corrupted or when VGGT priors are systematically wrong on a class of objects. The soft inward correction is bounded but its bound \lambda_{\max} is a hyperparameter without a stated sensitivity analysis. On the memory side, the abstract describes the governance machinery, but the excerpt does not include manipulation-task numbers showing that governed retrieval improves planner success rates over flat retrieval — the load-bearing claim still needs that ablation.
Why this matters
This paper is a useful template for upgrading VLA stacks without retraining the planner: it inserts geometry-only, mask-verified refinement at the perception interface and adds verifier/lifecycle metadata at the memory interface, leaving the policy unchanged. The pattern — conservative corrections gated by cheap consistency checks, plus governance over what enters long-term memory — is more broadly applicable to any hierarchical agent that mixes learned priors with retrieved experience.
Source: https://arxiv.org/abs/2606.17480
SpatialAvatar-0: High-Quality 4D Head Avatar with Multi-Stage Reconstruction
Problem
4D head avatar reconstruction from one or a few portraits currently splits into two regimes that do not share representations. Feed-forward generalizable predictors (GPAvatar, GAGAvatar, Portrait4D-v2) are trained on a single dataset family with a hard-coded source count K, baking in distributional bias. Per-subject refiners (GaussianAvatars, SplattingAvatar, INSTA) run 300K–600K iterations and rely on adaptive 3DGS densification that destroys any upstream Gaussian layout produced by a predictor, so the two regimes cannot be chained end-to-end on a shared representation. The paper targets this gap directly: design a single FLAME-bound Gaussian layout that survives both a feed-forward predictor and a per-subject refiner, so the same Gaussians can be predicted, then optionally polished.
Method
The representation is fixed infrastructure rather than a contribution: one 3D Gaussian per valid pixel of a 256\times256 FLAME UV unwrap, yielding \sim 58\text{K} Gaussians per identity, each rigidly bound to its parent triangle (as in Xiang et al. 2023). The pipeline is two stages over this layout.
Stage 1 — Feed-forward generator f_\theta. f_\theta ingests K\in\{1,2,3,4\} source portraits and emits all Gaussians in one forward pass. Variable source count is handled with a parameter-free mean-pool over per-source feature tensors: during training K\sim\text{Uniform}\{1,2,3,4\}, so the same weights see monocular and multi-view contexts. This is the core architectural move that lets one network serve K=1 and K=4 without separate heads or learned aggregators.
Training proceeds in two phases on the same architecture:
- Phase 1 — monocular-temporal pretraining on CelebV-HQ, where temporal pairs from the same clip give identity-consistent supervision at large scale.
- Phase 2 — multi-view-spatial post-training on NeRSemble v2, which is much smaller but provides true multi-view geometry.
Because Phase 2’s dataset is small relative to Phase 1’s, naive fine-tuning collapses the identity prior onto NeRSemble identities. The fix is an L2-SP anchor against the Phase-1 checkpoint \theta_1:
\mathcal{L} = \mathcal{L}_{\text{photo}}(\theta) + \lambda \,\|\theta - \theta_1\|_2^2.
This keeps Phase 1’s broad identity distribution while letting Phase 2 inject multi-view geometric cues.
Stage 2 — Layout-preserving per-subject refinement. Standard 3DGS refinement uses adaptive densification/pruning, which would shatter the UV-to-Gaussian bijection from Stage 1. Instead, the refiner runs only 10\text{K} iterations (vs. 300K–600K in prior per-subject work), freezes the FLAME-binding and the Gaussian count, and replaces densification with a three-component anti-spike regularization on scale, opacity, and color gradients (the standard failure modes that densification normally hides). The Gaussian indices, their parent triangles, and the UV map are byte-for-byte preserved, so Stage 1’s predicted Gaussians and Stage 2’s refined Gaussians are the same tensor with the same semantics.
Results
The evaluation protocol is constructed to avoid in-domain leakage: VFHQ and HDTF appear in no supervised training stage, so they form a strict cross-domain zero-shot probe. CelebV-HQ held-out slices are reserved for ablations, and the SplattingAvatar dataset (last 350 frames per clip held out) is used for per-subject evaluation. HDTF follows the 19-clip split from Chu et al. 2024.
Qualitatively, the feed-forward comparison (Fig. 2) shows the method tracking identity-bound high-frequency detail — hair strands, specularities around the eyes, teeth — better than GAGAvatar and GPAvatar at the same source budget; CVTHead and Portrait4D-v2 are the closest competitors but lose detail under extreme expression. The quantitative tables (Tabs. 1–2 in the paper) are referenced for VFHQ/HDTF numbers; the abstract is truncated in the provided excerpt and stops before the headline numbers, so concrete PSNR/LPIPS deltas cannot be cited here verbatim.
In the per-subject regime (Fig. 3), “Ours+S3” — feed-forward initialization plus 10K-iter refinement — is compared against GeoAvatar, GaussianAvatars, SplattingAvatar, INSTA, and FlashAvatar, all of which use \geq 30\times more refinement iterations. The 10K budget being competitive with 300K–600K-iter baselines is the central efficiency claim of Stage 2.
Limitations and open questions
- The feed-forward aggregator is a parameter-free mean-pool. This is robust but discards source-conditional weighting; it is unclear whether view-dependent attention would help at K=4 without reintroducing the K-specific overfitting the paper avoids.
- L2-SP is a coarse anchor. It prevents collapse but also limits how much Phase 2 can correct Phase-1 geometric biases inherited from monocular data (e.g., depth ambiguity on hair and ears).
- Freezing Gaussian count to \sim 58\text{K} caps the achievable detail ceiling; regions that 3DGS would normally densify (eyelashes, teeth edges) must be expressed by reshaping existing Gaussians.
- The provided excerpt does not include numeric tables, so the magnitude of the gap to Portrait4D-v2 on HDTF and to GaussianAvatars on SplattingAvatar cannot be assessed from the abstract alone.
- Both phases assume FLAME tracking is reliable; failures in expression fitting propagate directly into the UV-bound Gaussians.
Why this matters
The contribution is less about a new renderer and more about making the feed-forward and per-subject 3DGS avatar regimes share a single representation, so a predicted avatar can be polished in 10K iterations without throwing away the predictor’s geometry. If the numbers in the full tables hold, this collapses a long-standing bifurcation in head-avatar pipelines and gives a clean substrate for downstream 4D editing and animation.
Source: https://arxiv.org/abs/2606.15659
Hacker News Signals
(How to Write a (Lisp) Interpreter (In Python)) (2010)
Peter Norvig’s classic tutorial on implementing a Scheme subset (“Lispy”) in ~90 lines of Python. The implementation covers the full eval/apply loop: a parse function that tokenizes and builds nested Python lists as the AST, an Env class (subclassing dict) for lexical scoping with an outer-environment chain, and a eval function with cases for symbols (variable lookup), literals, if, define, lambda, begin, and procedure application. lambda constructs a Procedure object that closes over its defining environment, enabling proper lexical scope. The interpreter handles tail calls implicitly via Python’s call stack rather than trampolining, which means deep recursion hits CPython’s limit. Arithmetic and list primitives are seeded into the global environment by mapping Python builtins directly. The tutorial is a direct implementation of the eval/apply cycle from SICP without the metacircular abstraction layer, making it concrete and immediately runnable. A follow-up “Lispy2” adds proper tail calls, macros, and call/cc. The enduring relevance: it is one of the clearest demonstrations that a working interpreter for a real language is not a large engineering project but a direct encoding of operational semantics. Still used in university courses and onboarding exercises for compiler engineers.
Source: https://norvig.com/lispy.html
Sakana Fugu
Sakana AI’s Fugu is a framework for compositional neural network inference — specifically, combining multiple pretrained models at inference time without fine-tuning. The core idea is “model merging in weight space” extended to runtime: rather than averaging checkpoints offline (as in model soup / TIES-merging), Fugu routes activations or weight contributions dynamically. The technical mechanism involves computing task-specific combination coefficients over a library of base models conditioned on the input, which is closer to mixture-of-experts routing applied across distinct model checkpoints than within a single model’s layers. The framing positions this as reducing the cost of specialization: instead of fine-tuning a new model per task, you compose existing ones. Published benchmarks show competitive performance on held-out tasks relative to task-specific fine-tunes, with the composition overhead being a small linear combination pass. Open questions include how the routing coefficients are learned (a separate meta-network or gradient-free search), how this scales when the base model library grows large, and whether the approach is sensitive to architecture mismatches between candidate models. The name “Fugu” is a reference to the Japanese pufferfish, continuing Sakana’s fish-themed nomenclature. The release appears to include a model card and inference code, with the underlying research framed around reducing redundant compute across organizations that each fine-tune from the same base.
Source: https://sakana.ai/fugu/
Apertus – Open Foundation Model for Sovereign AI
Apertus presents itself as an open-weights foundation model aimed at “sovereign AI” deployments — organizations that require full control over model weights, training data lineage, and inference infrastructure without dependency on US hyperscaler APIs. The technical substance centers on a few concrete claims: full open weights (not just open for research), disclosed training data composition, and support for on-premise deployment. The model appears to target European public-sector and enterprise use cases where data residency and auditability requirements make closed API models legally or operationally infeasible under GDPR and emerging EU AI Act obligations. Architecturally, the model is described as a transformer-based LLM; specific parameter counts and training compute are not prominently disclosed on the landing page, which is a red flag for reproducibility. The “sovereign” framing is technically meaningful in a narrow sense: open weights allow air-gapped deployment, weight inspection, and fine-tuning without vendor lock-in, which is distinct from a governance or geopolitical claim. The main technical differentiator being advertised over existing open-weights models (Llama, Mistral, Qwen) is European training data composition and compliance documentation. Whether the model achieves competitive benchmark performance against those alternatives is not clearly established from the public materials. This space is crowded; the interesting engineering question is whether purpose-built compliance tooling around open-weights LLMs (audit trails, data provenance, differential privacy attestations) can constitute a real moat.
Source: https://apertvs.ai/
Good Results Fine-Tuning a Local LLM Like Qwen 3:0.6B to Categorize Questions
A practical walkthrough of supervised fine-tuning (SFT) on Qwen3-0.6B for a multi-class text classification task. The approach: construct a labeled dataset of questions mapped to categories, format as instruction-tuning examples (system prompt + user question + assistant label), and run SFT using a standard LoRA setup via Unsloth or similar. At 0.6B parameters, the model fits comfortably in CPU RAM or minimal VRAM, making the workflow accessible without a GPU cluster. The post reports that classification accuracy on held-out examples reaches a useful threshold after a modest number of gradient steps on a few hundred to low thousands of labeled examples — consistent with the well-established result that SFT on small domain-specific datasets transfers well when the base model already has relevant priors and the output space is constrained (a small fixed label set vs. open-ended generation). Key technical observations: (1) the instruction format matters more than hyperparameter tuning at this scale; (2) the 0.6B model underperforms larger models on ambiguous categories but is adequate for high-signal distinctions; (3) inference latency on CPU is acceptable for asynchronous categorization pipelines. The broader point is that fine-tuning sub-billion parameter models for classification is now a routine engineering task, not a research project — the tooling (Unsloth, llama.cpp, Ollama) has reduced the friction to roughly the same level as sklearn for classical text classification, with the advantage that no feature engineering is needed.
Source: https://www.teachmecoolstuff.com/viewarticle/fine-tuning-a-local-llm-to-categorize-questions
Excessive Nil Pointer Checks in Go
A diagnosis of a common Go code smell: defensive if x == nil { return } guards proliferating throughout a codebase beyond what is actually necessary for correctness. The author distinguishes three categories: (1) checks that are genuinely necessary because a nil receiver or pointer would cause a panic; (2) checks that paper over a design flaw where nil should never occur at that call site in a correctly functioning program; (3) checks added out of uncertainty that accumulate into noise. The technical argument is that category 2 and 3 checks are harmful because they suppress panics that would otherwise surface bugs early, and because they force callers to reason about a nil case that the API contract does not intend to expose. This is structurally similar to the null-safety debate in other language communities. Go’s lack of an Option type or non-nullable reference types (unlike Rust’s T vs Option<T> or Kotlin’s T vs T?) means the type system cannot enforce the distinction, so it falls to convention and code review. The post recommends auditing nil checks against whether nil is a documented, intended state for that value; if not, either eliminate the check and let the panic fire during testing, or restructure the API to make nil unrepresentable (e.g., return a struct rather than a pointer, use the sentinel object pattern). The comments on HN are substantive, with discussion of whether this is a language design limitation that requires mitigation via linters or whether it reflects correct usage of Go’s type system.
Source: https://konradreiche.com/blog/excessive-nil-pointer-checks-in-go/
Lisp in the Rust Type System
A Rust library that encodes a Lisp interpreter entirely in Rust’s type system — computation happens at compile time via trait resolution, not at runtime. The implementation represents Lisp values as Rust types: cons cells become generic structs Cons<H, T>, nil is a unit type, and symbols are zero-sized marker types. Evaluation is driven by implementing a Eval trait with associated type output; the compiler resolves the trait bounds recursively, performing the Lisp evaluation during type-checking. This is a variant of the well-known “type-level programming” technique exploiting the fact that Rust’s trait solver is Turing-complete (modulo recursion limits). The practical ceiling is the compiler’s recursion limit (#![recursion_limit = "..."]), which can be raised but creates compilation time blow-up. The encoding closely mirrors the structure of a metacircular evaluator: Eval<Env> dispatches on whether the type is a symbol (env lookup via trait), a literal (identity), a cons cell whose head is Quote (returns tail unevaluated), or a general application (evaluates head to a function type, then applies). Lambda abstraction is encoded as a type that, when Apply’d to an argument type, substitutes into a body type and re-evaluates. Error cases produce trait-not-implemented compiler errors. The project is primarily a demonstration of type system expressiveness, but similar techniques underlie legitimate compile-time computation in embedded Rust (e.g., const generics, typenum for physical units).
Source: https://github.com/playX18/lisp-in-types/
Deno Desktop
Deno’s new Desktop mode exposes a native windowing and UI API on top of the existing Deno runtime, allowing JavaScript/TypeScript programs to create OS-native windows, menus, and dialogs without bundling a full Chromium instance (the Electron model). The technical architecture uses a thin Rust layer wrapping platform windowing APIs — likely winit for event loop and window management and wry or a similar WebView crate for optional HTML rendering in windows — exposing these as Deno ops callable from JavaScript. This is the same stack Tauri uses, which is the obvious comparison point. The key distinction from Electron is memory footprint: by not shipping V8+Chromium together, the runtime overhead is substantially lower. The key distinction from Tauri is that Deno Desktop targets Deno’s existing ecosystem rather than a Rust-first backend model; the JS runtime is the primary application layer, not a thin frontend over a Rust core. The API surface includes Deno.desktop.createWindow(), event listeners for window lifecycle, and integration with Deno’s permission model so desktop apps inherit the same capability-based security sandbox. A notable open question is rendering: native widget rendering is notoriously platform-inconsistent, and the WebView fallback path reintroduces engine variance (WebKit on macOS, WebView2 on Windows). The HN discussion is substantive on the Tauri comparison and on whether the JS-first model simplifies or complicates the development experience relative to existing options.
Source: https://docs.deno.com/runtime/desktop/
Make PDFs Look Scanned (CLI or in the Browser via WASM)
A CLI tool and browser-based utility that applies a pipeline of image degradation transforms to PDF pages to simulate the appearance of a physical scan. The processing pipeline runs on each page rendered as a raster image and includes: slight random rotation per page (simulating paper misalignment), Gaussian blur (lens/focus imperfection), brightness/contrast variation, addition of Gaussian noise (sensor grain), optional coffee stain or fold overlays, and JPEG compression at reduced quality (scanner compression artifacts). The browser version compiles the same pipeline to WebAssembly via Emscripten or wasm-pack, allowing client-side processing without a server round-trip — important for the obvious use case where users do not want to upload documents to a third-party service. The implementation uses a combination of OpenCV (for geometric transforms and blur) or Pillow/PIL equivalents, with the PDF rendering handled by a library like PyMuPDF or pdf2image. Each transform is parameterized, allowing control over degradation intensity. The WASM build is technically interesting because it requires bundling the PDF rendering library (which has native dependencies) into the WASM target, which is non-trivial; the repo likely uses a pre-rendered raster intermediate to avoid this. Legitimate use cases include testing OCR pipelines on degraded inputs, archival simulation for document management systems, and generating training data for document restoration models. The HN comments predictably include discussion of document fraud, but the technical content is an applied image processing pipeline.
Noteworthy New Repositories
Soul-AILab/SoulX-Transcriber
An end-to-end pipeline for multi-speaker transcription that jointly resolves three interdependent sub-problems: speaker diarization (who), temporal segmentation (when), and ASR (what). Most production pipelines chain these separately, accumulating error at each handoff; SoulX-Transcriber models them jointly to reduce diarization-word-assignment mismatch. The architecture combines a speaker embedding module with a sequence-to-sequence ASR backbone, coordinated so that speaker identity conditions the transcript generation rather than being applied as a post-hoc label. The framework handles overlapping speech and variable speaker counts, which are the two failure modes that cascade worst through serial pipelines. Practically useful for meeting transcription, podcast indexing, and legal/medical dictation where speaker attribution is as important as word accuracy. The repo includes preprocessing utilities for common audio formats, evaluation scripts against standard diarization metrics (DER, WER per speaker), and example configs for fine-tuning on domain-specific corpora. Requires a CUDA-capable GPU for inference at reasonable speed.
Source: https://github.com/Soul-AILab/SoulX-Transcriber
Totoro-jam/battle-tested-patterns
A curated, source-linked catalog of design and implementation patterns extracted from real production codebases — React, the Linux kernel, Go’s standard library, Chromium, and others. The distinguishing feature over generic pattern books is that every entry points to an actual commit or file in a live repo, so the reader sees the pattern in its full industrial context rather than a toy illustration. Coverage spans frontend state management idioms (React), kernel synchronization primitives and memory management tricks (Linux), Go concurrency patterns (goroutine lifecycle management, context propagation), and browser engine architecture decisions (Chromium). Each pattern entry includes multi-language examples where the concept translates across runtimes, and runnable exercises so concepts can be verified hands-on. This is most valuable for engineers who learn by reading production code but find navigating large codebases to locate the relevant snippet high-friction. The repo essentially pre-indexes that search.
Source: https://github.com/Totoro-jam/battle-tested-patterns
yaroslav/kino
A Ruby web server targeting Ruby 4.0’s Ractor concurrency primitive, designed around a split-runtime architecture. The network layer is implemented in Rust using Tokio (async I/O runtime) and Hyper (HTTP/1.1 and HTTP/2), which handles connection accept, TLS, and request parsing with near-zero GIL contention. Parsed requests are handed off to Ruby Ractor workers, each running in true parallel (Ractors are Ruby’s actor-model isolation units that bypass the GVL). A threaded fallback mode is provided for compatibility with Rack middleware that is not yet Ractor-safe, since Ractor’s strict object-sharing restrictions break most gems that rely on global mutable state. The server exposes a standard Rack 3 interface, so existing applications are drop-in compatible to the extent their dependencies are Ractor-clean. The architecture is a direct response to Ruby’s historical inability to exploit multicore hardware; Kino is an early concrete test of whether the Ractor model is viable for I/O-bound production workloads. Of interest to Ruby performance engineers and anyone tracking the Ruby 4.0 concurrency story.
Source: https://github.com/yaroslav/kino
opengeos/geolibre-rust
A WebAssembly compilation target for Whitebox Geospatial’s next-generation toolset plus new GeoLibre-specific tools, built to run client-side in the GeoLibre browser environment. The toolchain compiles Rust geospatial algorithms to WASI (WebAssembly System Interface), enabling raster and vector processing — terrain analysis, hydrological modeling, LiDAR derivatives — to execute in-browser without a server round-trip. WASI is used rather than plain Emscripten WASM to get filesystem abstraction and better portability across WASM runtimes. The Rust origin of the underlying Whitebox tools means the WASM binaries are compact and the computational hot paths benefit from Rust’s zero-cost abstractions. Geospatial workloads are traditionally server-side because of binary size and compute cost; running them at the edge or in the browser matters for offline-capable GIS applications, data privacy scenarios, and reducing backend infrastructure. The repo includes build scripts, WASI-compatible shims, and integration glue for the GeoLibre JS frontend.
Source: https://github.com/opengeos/geolibre-rust
vedika-io/xalen-ephemeris
A pure-Rust library for computing planetary positions across nine astrological traditions: Vedic (Jyotish), Western tropical, Chinese, and six additional systems. The computational core implements the Swiss Ephemeris algorithms — numerical integration over JPL DE series planetary tables — in safe Rust with no C FFI dependency, which is the main differentiator from wrappers around libswe. Supporting nine traditions requires handling distinct reference frames: sidereal zodiacs with various ayanamsa corrections (Lahiri, Krishnamurti, Raman) for Vedic systems, tropical ecliptic coordinates for Western, and lunisolar calendar arithmetic for Chinese. The library exposes a unified query API that accepts a Julian date and a tradition identifier, returning planetary longitudes, house cusps, and aspect tables in that tradition’s coordinate system. Pure Rust enables compilation to WASM for browser deployment and to embedded targets. The breadth of tradition support is unusual; most open-source ephemeris libraries handle one or two systems. Useful for developers building astrology applications who need correctness guarantees and cross-tradition parity without managing C library dependencies.
Source: https://github.com/vedika-io/xalen-ephemeris
Albert-Weasker/niubi_guard
An automated detection and response system targeting GitHub repository abuse patterns — spam repositories, fake star campaigns, dependency confusion attacks, malicious package publishing, and coordinated inauthentic behavior. The detection pipeline applies heuristics and ML classifiers over GitHub API metadata: repository creation velocity per account, star acquisition rate curves (distinguishing organic growth from burst-purchased stars), fork graph topology, and commit authorship anomalies. The response layer can file automated abuse reports or trigger alerting pipelines. This is a practically relevant problem: the npm/PyPI/GitHub ecosystem has seen repeated supply chain attacks exploiting the appearance of legitimacy that star counts and fork numbers confer. The repo is open-source, which allows the detection logic to be audited and adapted — important since defenders need to update heuristics as abuse tactics evolve. Integration hooks for CI pipelines would let organizations monitor dependencies they consume. Most directly applicable to security teams maintaining open-source package registries or large dependency graphs.
Source: https://github.com/Albert-Weasker/niubi_guard
eli-labz/Third-Eye
A production-grade OSINT aggregation platform providing unified situational awareness across multiple intelligence domains: social media monitoring, infrastructure enumeration, geospatial signal correlation, document and image analysis, and dark-web indexing. The architecture separates collection modules (per-source scrapers and API clients) from an analysis layer that normalizes heterogeneous data into a common entity graph, enabling cross-domain correlation — linking, for example, a username to an IP range to a physical location extracted from image EXIF data. Graph-based entity resolution allows analysts to surface relationships that would be invisible inspecting any single data source. The platform targets security operations, threat intelligence, investigative journalism, and red team reconnaissance use cases. “Production-grade” here implies persistent storage backends, rate-limit-aware collection scheduling, and an API or UI layer for analyst interaction rather than a collection of ad-hoc scripts. OSINT tooling at this integration level is typically either commercial or fragmented; a consolidated open-source platform lowers the barrier for smaller security teams.
Source: https://github.com/eli-labz/Third-Eye
dongshuyan/compass-skills
COMPASS (司南) is a skills operating system for AI agents — a structured layer that sits between a task specification and agent execution, managing how capabilities are selected, composed, and personalized for a given user or context. The core abstraction is a “Skill,” a modular unit encapsulating a prompt strategy, tool invocation pattern, and context schema, analogous to a function with metadata about its preconditions and effects. A central task controller dispatches incoming requests by matching them to skills via semantic routing, then orchestrates multi-skill chains when composite tasks require it. Personalization is first-class: the system maintains per-user preference profiles that bias skill selection and parameterize skill execution, addressing the gap between generic agent behavior and user-aligned behavior. This targets the common failure mode in LLM agent frameworks where capability exists but routing and alignment to individual user intent is brittle. The bilingual documentation (Chinese/English) and the “Personal Alignment” framing suggest a focus on consumer-facing agent products. Relevant for anyone building agent orchestration layers who needs more structured skill management than raw tool-calling APIs provide.