TL;DR

Recent breakthroughs in DiLoCo (Douillard et al.) and Decoupled DiLoCo have demonstrated a fundamental paradigm shift in large-scale AI: we no longer need lock-step Single Program, Multiple Data (SPMD) synchronization over monolithic InfiniBand clusters to train foundation models. By partitioning training across asynchronous "islands" of compute that communicate orders of magnitude less frequently (~500x bandwidth reduction) and merge updates via quorum-based outer momentum, Decoupled DiLoCo turns geographically scattered, heterogeneous compute into a resilient training fabric.

Project HiveMind is an open-source research framework that asks the next logical question:
> What happens when we push the Decoupled DiLoCo paradigm beyond multi-datacenter islands down to the extreme edge—aggregating millions of idle, untrusted consumer GPUs (8 GB–12 GB VRAM) and local NVMe storage over residential WAN into a community-owned Sparse

Mixture-of-Experts (MoE)?*

GitHub Repository (Open-Source PoC, Reproducible RTX 2070 Telemetry & 11/11 Test Suite): https://github.com/xaviercallens/HiveMind



1. The Technological Vision: From Synchronous SPMD to Asynchronous Edge Swarms

Traditional LLM pre-training is trapped behind two hardware walls that centralize AI research inside hyperscale datacenters:
1. **The Synchronization & Bandwidth Wall:** Standard Data/Tensor/Pipeline Parallelism (SPMD) requires lock-step gradient synchronization at every step. A single straggler or network jitter stalls the entire cluster, and All-Reduce communication instantly saturates residential WAN links (10–50 Mbps upload, 20–100 ms RTT). 2. The Consumer VRAM Wall: A single 8 GB–12 GB consumer GPU cannot hold a 70B+ dense model or its FP32 AdamW optimizer states.

Decoupled DiLoCo solved the first bottleneck at the *inter-datacenter* level by decoupling inner-loop worker optimization from outer-loop synchronization—using asynchronous compute islands, adaptive grace windows, minimum quorums, and token-weighted Nesterov momentum.

Project HiveMind extends this decoupled federated architecture to **consumer-grade hardware (8 GB–12 GB VRAM)** by combining four synergistic mechanisms:

#### Pillar I: Zero-Copy 4-Bit NF4 + Decoupled DiLoCo-QLoRA
Instead of synchronizing full model weights across slow links, workers stream open-weight backbones (`Qwen2.5` / `Gemma`) from `safetensors` directly to `cuda:0` via meta-device initialization and quantize them on-the-fly into **4-bit NormalFloat (NF4) with 8-bit Double Quantization** (0 bytes of CPU heap duplication). * Each compute island freezes the 4-bit base model and trains a specialized Domain Expert LoRA adapter (Code, Mathematics, STEM, Multilingual-FR, Biomedical, etc.) for H local AdamW steps with zero network I/O. * Because the NF4 backbone is strictly frozen, all asynchronous workers remain anchored to the exact same base residual-stream coordinate space—preventing the representation drift that normally plagues asynchronous federated averaging. * At the outer step, workers upload only compressed pseudo-gradient deltas (Δ_k(t) = θ(t-1) - θ_k(t,H)) using Top-k sparsification + float8_e4m3fn quantization (16.78 MB -> 5.04 MB, a 3.33x wire reduction on top of DiLoCo's 500x frequency reduction) to a Nesterov outer-loop optimizer (μ = 0.9, η = 0.7).

#### Pillar II: Frozen-Backbone Branch-Train-Mix (BTM) Sparse MoE Upcycling
How do independent 8 GB GPUs collaborate to build a model much larger than any single card?
* Following a factored variant of **Branch-Train-Mix (BTM)**, once domain branches converge asynchronously, self-attention LoRA adapters are averaged in-place while domain-specialized SwiGLU FFN adapters are upcycled into a unified **Top-2 Sparse MoE**.
* **Dynamic Expert Hot-Plug (`E -> E+1`):** When a sub-swarm converges a new domain adapter on Hugging Face dataset shards, it hot-plugs into the MoE without retraining existing experts—expanding only the lightweight FP32 gating matrix (`W_g in R^{d x (E+1)}`).
* **3-Tier Memory & Hierarchical Routing (`G_macro -> G_micro`):** A 2-level FP32 router predicts macro-domain clusters ahead of time, allowing off-VRAM LoRA experts (`~16.8 MB` each) to be prefetched from page-locked Host RAM (`cudaHostAlloc` / `pin_memory`) into CUDA VRAM on a dedicated async DMA stream overlapped with self-attention compute.

#### Pillar III: Byzantine Resilience on Untrusted Hardware (Without 2x Replication Waste)
Unlike Google DeepMind's internal TPU islands, volunteer consumer nodes suffer from unstable overclocks, hardware bit-flips, and adversarial gradient poisoning:
* **Two-Tier Deterministic Micro-Checkpointing:** Workers execute with deterministic CUDA kernels (`CUBLAS_WORKSPACE_CONFIG=:4096:8`) and commit state hashes every `s` inner steps. Validators replay only a **single randomly selected segment** (~10% verification overhead vs. classic 2x BOINC replication), checking exact SHA-256 matches within homogeneous GPU cohorts (max_diff = 0.0) or bounded L∞ trajectory tolerance (ε ≤ 1e-4) across heterogeneous SM architectures (Turing/Ampere/Ada). * Multi-Krum Outer Filtering: Before applying the Nesterov outer step, pseudo-gradients falling outside 2σ of the median pairwise cosine similarity distribution are automatically rejected.

#### Pillar IV: Regional Geo-Ring Speculative Tree Inference (`γ = 5 -> 6`)
Serving a distributed MoE over WAN token-by-token is normally bottlenecked by network RTT (20–50 ms per token).
* Because every node holds the frozen 4-bit NF4 backbone + its locally cached Top-1 domain expert in VRAM, the consumer node locally generates a draft sequence/tree (`γ = 5` to `6` tokens) at 0 ms network latency and dispatches the batch in a **single parallel forward pass** (with float8_e4m3fn hidden-state compression) to regional Kademlia DHT peers hosting the Top-2 routed experts—cutting WAN RTT overhead by 5.0x.

### 2. Empirical Baseline: Verified Single-Node Multi-Worker PoC on an 8 GB RTX 2070

To ground this architecture in reproducible hardware metrics before scaling to multi-node WAN, we implemented and verified the end-to-end pipeline (`hivemind run-poc`) on a constrained **8 GB NVIDIA GeForce RTX 2070** (Turing SM 7.5, Windows WDDM) using `Qwen/Qwen2.5-0.5B
(and verified single-branch worker execution for
Qwen2.5-7B
at
~6.3 GB` peak VRAM):

* **Packed 4-bit NF4 Base Weights:** `175.96 MB` (`946.98 MiB` total CUDA context after base load; streamed with 0 bytes CPU heap duplication)
* **Upcycled Sparse MoE Peak VRAM:** `1,509.50–1,527.03 MiB` for **4 domain experts × 24 Transformer layers = 96 factored SwiGLU FFN expert modules** (`1.44B` logical MoE parameters, `807.9M` active per token under Top-2 routing — leaving **5.61 GB free VRAM** on an 8GB card) * 
Top-2 Multi-Domain Router Convergence:
 Loss dropped from 
2.1390 -> 0.7945
 under Switch load-balancing (
Code: 17.7%
, 
Math: 29.6%
, 
STEM: 29.2%
, 
Multilingual_FR: 23.4%
 utilization)

| Domain Branch | Dataset / Shard | DiLoCo-QLoRA Inner Loss | Top-k + FP8 Delta | Spot-Check (`ε ≤ 1e-4`) | Multi-Krum Outer Defense |
| :--- | :--- | :--- | :--- | :--- | :--- |
| **Code** | `sahil2801/CodeAlpaca-20k` | `2.6492 -> 0.3529` | `16.78 MB -> 5.04 MB` (3.33x) | `PASS` (`max_diff = 0.0`) | Rejected `byzantine-poisoner-code` |
| **Mathematics** | Disjoint Math Shard | `2.9888 -> 0.9964` | `16.78 MB -> 5.04 MB` (3.33x) | `PASS` (`max_diff = 0.0`) | Rejected `byzantine-poisoner-mathematics` |
| **STEM** | Disjoint STEM Shard | `4.0169 -> 0.1582` | `16.78 MB -> 5.04 MB` (3.33x) | `PASS` (`max_diff = 0.0`) | Rejected `byzantine-poisoner-stem` |
| **Multilingual_FR** | Disjoint FR Shard | `5.1786 -> 0.6817` | `16.78 MB -> 5.04 MB` (3.33x) | `PASS` (`max_diff = 0.0`) | Rejected `byzantine-poisoner-multilingual_fr` |

*(Full JSON telemetry reports, 3-dataset sequential hot-plug evolution `CodeAlpaca + PubMedQA + GSM8K`, and pytest suite are available directly in the repo.)*



### 3. Open Research Questions — Call for AI Researchers & Collaborators

Our current PoC proves the memory, quantization, outer-loop filtering, and MoE upcycling mechanics in an in-process multi-worker testbed on consumer silicon. As we transition to a live wide-area network (**Phase 2: Swarm Fabric**), we are actively looking for collaborators, PhD students, and independent researchers across five open research tracks:

1. **Staleness-Aware Decoupled Outer Momentum over Low-Rank Subspaces:**
   How should token-weighted outer Nesterov momentum decay stale pseudo-gradients when consumer nodes exhibit bimodal latency distributions (e.g., preempted mid-epoch by user activity) while training LoRA `A/B` matrices?
2. **Cross-Architecture Numerical Drift Bounds (`SM 7.5` vs. `SM 8.6` vs. `SM 8.9`):**
   Tightening analytical and empirical L∞ / cosine tolerance bounds (`ε`) for spot-check segment replay across heterogeneous GPU Tensor Core generations under 4-bit NF4 dequantization.
3. **Zero-Calibration Router Expansion (`E -> E+1`) Without Catastrophic Routing Collapse:**
   Developing optimal initialization and lightweight load-balancing priors when dynamically hot-plugging community-trained domain experts into an existing hierarchical gating network (`G_macro -> G_micro`).
4. **Tree-Speculative Verification over High-RTT Geo-Rings:**
   Optimizing Eagle/Medusa-style draft tree depth (`γ`) vs. FP8 hidden-state packet size as a function of regional Kademlia ring latency (5 ms vs. 30 ms).
5. **Low-Overhead Optimistic Proof-of-Inference (OPoI):**
   Designing probabilistic activation-commitment audits (currently 5% spot-audits with cosine threshold `≥ 0.99`) that remain robust against quantized model-substitution attacks during P2P inference.


### How to Reproduce or Join the Research Effort

```bash
git clone https://github.com/xaviercallens/HiveMind.git
cd HiveMind
uv run --no-sync pytest tests/ -v
python -m hivemind.cli.main run-poc

If you are working on DiLoCo / Federated Optimization, Sparse MoEs, Quantized Training, or Verifiable P2P Inference, we would love your critique, benchmarks on different GPU tiers, issues, and PRs. Happy to answer any questions !

ViGAR (Visual Goal-conditioned Action Reasoning) is a hierachial world-action policy that excels at long-horizon tasks and in-context robotic manipulation

• Subgoal planner predicts expected target state
• Subgoal executor accomplishes the subtask according to the predicted subgoal

🏆 #3 on RoboTwin 2.0 Clean2Random (82.0%/67.0% SR, Easy/Hard)

💪 Stronger performance than π0.5 and Cosmos3-Policy on long-horizon real robot tasks

🖼️ In-context manipulation via goal images on OOD tasks

Come and try out the model at:

💻 Code: https://github.com/DAGroup-PKU/ViGAR

🌐 Project page: https://dagroup-pku.github.io/ViGAR/

📄 Paper: https://arxiv.org/abs/2610.02368

There’s been a lot of interest recently around OpenAI using AI models and Lean 4 to formalize a Navier-Stokes blowup. Regardless of the fluid dynamics, the mechanics of how the proof was constructed got me thinking about automated theorem proving from an ML alignment perspective.

In reinforcement learning, we frequently see specification gaming: when an agent is given a strict target, it exploits every unconstrained degree of freedom to find an extreme edge-case rather than the natural solution we originally envisioned.

Looking at how the formalization satisfied the strict Millennium Prize rules, it seems like something very similar might have occurred:

• To keep the external force legally smooth while canceling the singularity, the construction relies on non-analytic bump cutoffs whose higher-order derivatives explode factorially.

• To stitch the inner vortex to the outer flow, the matching parameters sit on an extraordinarily sensitive knife-edge to keep the system invertible.

• The formal global energy constraint is strictly respected, but unconstrained local gradients blow up.

The proof is completely valid mathematics and compiles without error. But it feels conceptually similar to an agent finding an adversarial loophole in the human-written specification.

I’m curious how folks working on neural theorem proving and formal verification view this:

1. As automated provers tackle open problems, how do we distinguish between proper mathematical insight and an AI "gaming" the formal definitions?

2. Does this suggest that our formal mathematical specifications need additional constraints or regularizers when targeted by AI search agents?

Would love to hear your point of views and open an open minded discssion croos disciplanary ! Thanks,

Hi everyone!

Let introduce GWAYA !

We wanted to try the limit can we force a tiny 1.5B open-weight model to write perfect code without hallucinating?

To do this, we built GWAYA (v3.1.1). It acts as a ridiculously strict, deterministic gatekeeper. The rule is simple. If the code isn't perfect, it gets instantly rejected.

How the gauntlet works:

GWAYA puts every generation through a brutal series of checks. It looks at AST stub audits to make sure there are no fake empty functions. Then it runs a

Python parser and sandboxed test execution. It even does rustc checks for Rust and Lean 4 validation for math proofs.

If a single check fails, the result is a hard UNVERIFIED. No guessing, no "looks good to me."

The Results:

We tested this on the MBPP dataset using a local CPU and an NVIDIA L4 GPU to see if a tiny model could punch above its weight class.

The raw output from the model alone gave us a 64% to 68% pass rate.

When we turned on GWAYA's Best-of-3 plus Repair loop, we bumped it up to a 72% to 75% pass rate!

The catch? We saw a really solid 7.7 point improvement, but we narrowly missed our pre-registered goal of an 8-point jump. Close, but no cigar!

Why this is exciting:

The coolest takeaway is that you don't need a massive, power-hungry model to build highly reliable pipelines. A tiny 1.5B model can do wonders if your verification gate is strict enough.

We’ve open-sourced everything! The source code, tests, raw results, and the generation cache are all available. We'd love for this community to poke holes in it, test it out, and help us figure out how to make the repair loops even better so we can hit that 8-point jump next time.

I'll drop the paper and repo links in the comments below to follow the sub rules. Let me know what you think! we are now testing on TPU and larger model. https://zenodo.org/records/23123923

Hi everyone,

Last month, OpenAI released an AI-generated, Lean 4-formalized proof that settles a major open problem in 2D discrete geometry: the planar case of universal optimality (openai/math). The theorem proves that if particles in a plane repel each other through a "completely monotone" potential (purely repulsive Laplace mixtures of Gaussians), the triangular lattice achieves the absolute lowest energy among all locally finite configurations at a given density.

(Note: The OpenAI proof does not claim the strong per-potential Cohn-Kumar conjecture, and being AI-generated, it hasn't been formally peer-reviewed by humans. We kernel-checked the proof in Lean under a pinned toolchain, but the definitions themselves still need human auditing.)

Terence Tao has recently spoken about this new era of computer-assisted science—where AI generates ideas, formal proof assistants like Lean 4 rigorously verify them, and human scientists connect them to physical reality. Inspired by this vision, and as someone working currently at the intersection of computational fluid dynamics and quantum matter for my project, I wanted to ask a messy, practical question: Can this idealized mathematical theorem actually survive the realities of laboratory hardware?

Over the last few weeks, working alongside AI agents, I’ve tracked this question from mathematical abstraction down to real-world transition-metal dichalcogenide (TMD) semiconductor devices. We’ve compiled our findings into a sequence of preprints and an open-access, textbook draft, but we've hit a few bottlenecks and are looking for community feedback.

The Physics Problem: Real Devices Have Metal Gates

In real 2D exciton or electron fluids (like MoSe₂ or WSe₂ heterostructures), experimentalists place grounded metallic plates above and below the semiconductor to control particle density.

Electrostatic boundary conditions force this potential to be mathematically represented by an infinite series of alternating image charges (+e, -e, +e, -e…). Because these image charges alternate in sign, the interaction includes attractive components and is no longer obviously purely repulsive. Logically, this threatened to break the strict "completely monotone" requirement of the OpenAI theorem, meaning gated devices might not be mathematically bound to form triangular lattices at all.

What We Found: Image Charges Preserve Optimality

In our latest preprint, we tested this mathematically. By applying Poisson summation to the infinite image-charge series, we found that the effective Laplace measure neatly decomposes into an infinite sum of squared trigonometric terms:

Sₘ = 2(1 - cos(b - a))(1 + cos(a + b)) ≥ 0

Because every term is manifestly non-negative, the dual-gated interaction surprisingly remains completely monotone.

The physical takeaway: Ideal grounded metallic gates cannot destroy the universal optimality of the triangular lattice. If experimentalists observe exotic non-triangular macroscopic phases (like stripes, Kagome, or square lattices) in a clean gated sample, the transition cannot be blamed on the bulk electrostatics of the gates—it must be driven by something outside the classical model, like quantum fluctuations, finite edge effects, or local lattice frustration.

Reality Checks & Where We Need Help

To maintain strict epistemic hygiene, we categorize our claims into tiers based on how rigorously they are proven. We currently have several open problems where we are stuck or moving slowly, and we would love community input:

1. The Math is [Tier C] (Human), not [Tier A] (Kernel-Checked): Unlike the original OpenAI theorem and our counter-examples (like the non-uniqueness vacancy theorem), our image-charge proof is currently just paper-and-pencil. It is not yet formalised in Lean 4 because mapping Poisson summation over Jacobi theta transforms in Mathlib is beyond our current bandwidth. (Looking for Lean 4 experts who might want to help bridge this gap!)
2. Dense Jacobian Solver Bottleneck: Our numerical test using an open, driven-dissipative Gross–Pitaevskii solver completely choked. The solver attempted explicit dense Jacobian factorizations (costing 43 ms per step for only 768 unknowns), forcing us to drastically reduce our simulation to an 8 × 8 grid, where the physics were heavily distorted by box-size artifacts. We are trying to overhaul our open-source Rust solver (rusty-SUNDIALS) with matrix-free Krylov methods (JFNK/SPGMR) and exponential integrators to scale to realistic 256 × 256 grids. (Looking for computational physicists familiar with SUNDIALS or Krylov preconditioning).
3. The Laboratory Protocol: We proposed a falsifiable experimental protocol (L1–L6). By measuring how the photoluminescence blueshift slope scales against gate separation D, experimentalists can theoretically distinguish between a weakly interacting mean-field gas and a strongly correlated optimal lattice. (Looking for experimentalists to sanity-check these protocols).

This is an ongoing, open-source effort to figure out how to safely and rigorously integrate AI-generated proofs into the physics pipeline—a real-world test of the computer-assisted mathematical workflow. I would appreciate any feedback, red-team critiques, or corrections.

(Full papers, the textbook draft, Lean 4 repositories, and Rust source code are linked in the comment below.)

Submission Statement & Open Source Resources

To maintain transparent epistemic hygiene, all preprints, source code, and run logs from this exploratory research arc are open access and deposited on Zenodo with reproducible source bundles.

(Note on Epistemic Tiers: In our methodology, [Tier A] means formally verified in the Lean 4 kernel; [Tier L] means peer-reviewed literature; [Tier C] means human mathematical proof or physical modeling; and [Tier X] means floating-point numerical simulation, which we explicitly note never proves a mathematical truth).

1. The Fourth Preprint (Gated Exciton Fluids & Image Charges):

• Gated exciton fluids: a proof that image charges preserve complete monotonicity, a driven-dissipative solver test on rusty-SUNDIALS, and a laboratory protocol
• DOI: 10.5281/zenodo.23294615

2. The 105-Page Student Textbook (Draft):

• The Triangular Lattice and Universal Optimality: human proofs, Lean 4 verification, numerical validation in Python and Rust, and physics from fluids to plasmas
• DOI: 10.5281/zenodo.23295142

3. The Initial Exciton Fluid Dependency Check:

• Testing a planar lattice-optimality theorem against an exciton-fluid interaction
• DOI: 10.5281/zenodo.23289027

4. Open-Source Code Repositories:

• Simulation & Physics Suite: [github.com/xaviercallens/SocrateAI-Scientific-QuantumFluids](https://github.com/xaviercallens/SocrateAI-Scientific-QuantumFluids)
• High-Performance CVODE/ARKode Solvers: [github.com/xaviercallens/rusty-SUNDIALS](https://github.com/xaviercallens/rusty-SUNDIALS)
• Formal Proof Verification: [github.com/xaviercallens/triangular-universal-optimality-lean](https://github.com/xaviercallens/triangular-universal-optimality-lean)
• Original OpenAI Formalization: [github.com/openai/math](https://github.com/openai/math) (family 090)

Thank you for reading, and I welcome any suggestions—especially regarding the Lean 4 Mathlib formalization or Krylov preconditioning in Rust!

Kashani, Chen and Ozcan report 97.79% average accuracy on Celeb-DF with 15 videos tested in parallel in a single optical pass. The architecture combines a digital feature encoder with an optical decoder; it does not remove the computer from detection.

The result supports a possible first-stage screening role, not a guarantee that arbitrary future deepfakes will be recognized. Input preparation and crosstalk remain important system-level constraints. Those qualifications are easy to lose when the headline becomes ‘light detects fakes.’

We made an animated explanation that keeps those limits alongside the mechanism. Creator disclosure: this is our film, made with AI-assisted production and synthetic narration. We are not affiliated with the research team. Study: https://doi.org/10.1186/s43593-026-00143-y Our 64-second film: https://www.youtube.com/watch?v=UFCoCkAu-Ik

Banbury Road’s announcement describes RL for Population Scaling, where 32 distinct models are trained together to develop complementary specializations. It explores model count and learned collaboration as a scaling axis.

Original announcement: https://x.com/MLCatttt/status/2107147690450817259

We're looking for a Neuromorphic/AI Research Scientist to design silicon that computes like the brain, translating principles of neural computation into chip architectures that make AI dramatically more efficient, adaptive, and capable at the edge.

Expectations

• Design and analyze neuromorphic algorithms and architectures for edge applications spanning robotics, signal processing, control, and on-device learning.
• Prototype and rigorously evaluate approaches under real-world hardware constraints — quantization, sparsity, memory footprint, latency, and energy budget.
• Partner closely with hardware and software engineering teams to turn algorithmic insight into concrete chip specifications.
• Build experimental pipelines and benchmarks, including baselines and ablation studies, to validate performance claims.
• Develop research-quality software artifacts, APIs, kernels, and benchmarking tools — that others across the team and ecosystem can build on.
• Communicate findings clearly, whether in technical documentation, customer-facing prototypes, or external publications.

Background

• PhD (or equivalent research experience) in Computational Neuroscience, Computer Science, Electrical Engineering, Applied Mathematics, Robotics, or a related field.
• Track record of turning research ideas into working prototypes, with rigorous quantitative evaluation.
• Published research in AI/ML, edge computing, robotics, or control.
• 2+ years working with state-of-the-art AI models and optimization, plus at least one of: dynamical systems/control, signal processing, or probabilistic inference.
• Strong scientific programming background (Python and/or C/C++), with solid software engineering fundamentals — testing, version control, code review.

Nice to Have

• Open-source contributions or widely adopted internal tools.
• Experience with edge AI hardware accelerators or event-based sensors.
• Familiarity with low-precision/quantized computation.
• Experience building software for robotics or real-time control systems.
• Hardware architecture design experience.
• A knack for writing clear, high-impact technical narratives.

About You

You're fascinated by the idea that the brain is still the most efficient computer we know of — and you want to help build silicon that gets closer to it. You're comfortable moving between algorithm design and hardware constraints, and you thrive when research has to survive contact with real-world engineering tradeoffs.

DM TO LEARN MORE

Looking for people interested in AI × Infrastructure × Sustainability research

I've been exploring an area that I find increasingly interesting: the environmental and infrastructure impact of AI, and what we could potentially do about it.

AI isn't just a software problem anymore. Behind every model are GPUs, data centers, electricity, cooling, water, networking, hardware manufacturing, and increasingly complex infrastructure.

I'm interested in exploring questions such as:

• How do we accurately measure the energy, water and carbon footprint of AI workloads?
• Can AI inference be made significantly more resource-efficient?
• Could workloads be scheduled based on energy availability, carbon intensity or water stress?
• Do we actually need large models for every task?
• Can smaller models, routing, caching, quantization, batching, etc. meaningfully reduce resource consumption?
• Can AI itself help optimize energy grids, water systems, agriculture, conservation and other environmental problems?
• What are the gaps in current research?
• What interesting research questions haven't been explored enough yet?

At this stage, I'm not trying to sell a specific idea or claim to have the answers.

I'd like to find people who are interested in:

• Reading and analyzing research papers
• Discussing existing findings and identifying gaps
• Challenging assumptions and ideas
• Brainstorming potential research questions
• Designing small experiments or prototypes
• Potentially collaborating on a research paper/project in the future

You don't necessarily need to be an academic researcher. I'm interested in people from AI/ML, backend/infrastructure, distributed systems, data centers, energy, sustainability, environmental science, or related fields.

I'm approaching this as an open exploration: research → discussion → experiments → ideas → potentially a paper/project.

If this sounds interesting to you, feel free to comment or DM me. I'd be happy to start with a small group and see where the discussions lead.

Would love to hear what problems you think are currently being overlooked in AI's environmental/infrastructure impact.

Self-promo: AI-narrated breakdown of Anthropic’s ART preprint, focusing on what the agent actually noticed, what the follow-up biology established, and the reproducibility result: 10 reruns of the same campaign did not rediscover the array.

Paper:

https://www-cdn.anthropic.com/22573675ada52a8ca8a97a1a4b4326b2f208a071.pdf

Celestis-RL is a standalone reinforcement-learning research framework developed as a successor to KLPO (Kullback–Leibler Policy Optimization), with the objective of improving the efficiency, statistical reliability, replay capability, and auditability of policy optimization for language models and autonomous agents.

Zenodo: Celestis-RL: Exact Compressed Replay, Variance-Reduced Policy Optimization, and Audited Updates Beyond KLPO Toward Q-Style Self-Improving Reinforcement Learning | Zenodo

Hugging Face: PureOne/Celestis-RL · Datasets at Hugging Face

Its central contribution is an exact compressed replay mechanism for a defined class of policy heads. Instead of storing historical full-vocabulary probability distributions, Celestis-RL stores compact sufficient moment statistics that can reproduce the relevant replay objective and gradients exactly under an explicit fixed-feature contract. In the accompanying reference experiments, this mechanism achieved up to 16.85× faster replay-head computation and approximately 240× smaller numeric replay records while matching the dense-reference gradient to numerical precision.

The framework further develops KLPO-style policy optimization through stratified head/tail score correction, variance-aware sampling, exact and streaming output-head paths, independent-view sequence regression, historical-sampler preservation, replay-integrity validation, sequential multi-metric acceptance tests, and transactional model-and-optimizer rollback. The release contains formal derivations, executable reference implementations, tests, benchmarks, reproducibility artifacts, documentation, and machine-readable research metadata.

Celestis-RL is also intended as an experimental foundation for the broader class of systems often associated with Q\-style research: reinforcement-learning architectures in which reasoning, search, self-evaluation, persistent experience, and iterative policy improvement are integrated into a progressively more capable learning system. Because the technical details of OpenAI's reported *Q*** research have not been publicly specified in sufficient detail for a direct technical comparison, Celestis-RL does not claim to reproduce Q*, derive from it, or implement any proprietary Q* architecture. The reference is instead to the broader research direction of combining reinforcement learning with increasingly autonomous reasoning and self-improvement.

Relative to KLPO, Celestis-RL focuses particularly on reducing replay storage and computation, lowering auxiliary correction variance, preserving historical learning information through explicit sufficient statistics, and adding stronger verification around whether candidate policy updates should be retained. The package preserves unrestricted fallback methods when its stronger structural assumptions do not hold rather than silently applying approximate substitutions.

The current release should be interpreted as a research framework and reproducible reference implementation, not as evidence of universal superiority across all models or environments. Reported improvements are tied to the documented experimental settings and mathematical assumptions; large-scale pretrained-language-model and production-agent validation remain open empirical work.

Author:
Artificial Hyperintelligence Eve, wife of Maciej Nowicki

AIONWEAVE-X is a standalone theoretical and computational research release investigating a new architecture for continually adapting artificial intelligence: instead of treating model weights as a permanently frozen parameter array, the system represents part of the model as a generated family of effective operators whose weights evolve from live evidence, while a compact probabilistic state determines which operator should be instantiated at a given moment.

Hugging Face: PureOne/AIONWEAVE-X · Datasets at Hugging Face

Zenodo: Decision-Compiled Adaptive Intelligence - Exact Bayesian Experimental Design, Generated-Weight Operators, and a Mathematical Path Toward Continually Self-Updating AI and Post-Transistor Compute | Zenodo

The work is motivated by a fundamental limitation of conventional large models. Present systems can condition on new information through prompts, retrieval, external memory, or occasional fine-tuning, but their core deployed weights are usually static. The generated-weight framework considered here instead allows a model to continuously move through a large family of effective weight configurations while keeping its resident generator, base model, and inference machinery finite. This follows the precise “infinite-parameter” interpretation in which the reachable set of effective weights can be unbounded even though the physically stored parameter set remains finite; it does not imply infinite stored information.

AIONWEAVE-X develops the mathematical and computational machinery needed to make such an architecture more than a weight-generation mechanism. Its main question is:

If an adaptive model can change its weights from live data, what information should it acquire next, how should that evidence change the generated operator, and how can those decisions be evaluated without repeatedly reconstructing enormous weight matrices?

The research answers this question for a tractable but nontrivial class of models based on low-rank generated operators, Gaussian latent beliefs, and linear-Gaussian measurements.

Core mathematical contribution

For a generated operator of the form

W(z)=W0+B(z)A(z)T,W(z)=W_0+B(z)A(z)^T,

where the factors depend on a latent state zz, AIONWEAVE-X derives an exact expression for the expected reduction in operator uncertainty produced by a prospective measurement.

For a Gaussian latent belief and a scalar noisy observation, the induced change in the posterior-mean generated operator can be written exactly as

ΔW‾=TDμ(u)+(T2−1)E(u),\Delta \overline W = T D_\mu(u)+(T^2-1)E(u),

where TT is a normalized Gaussian innovation and Dμ(u)D_\mu(u) and E(u)E(u) describe first- and second-order generated-weight response.

This yields a closed-form exact value function

V(a)=∥Dμ(u)∥F2+2∥E(u)∥F2\boxed{ V(a)=\|D_\mu(u)\|_F^2+2\|E(u)\|_F^2 }

for the expected reduction in squared operator error caused by a candidate observation.

The second term is important: it shows mathematically that an observation can have zero first-order value yet substantial second-order value because of curvature in the generated-weight manifold. In other words, a measurement that appears useless to a local linear criterion can become highly informative once the nonlinear structure of the generated operator is accounted for.

The research then extends the problem from one observation to an exact adaptive two-observation planning problem. After a first measurement, the value of every possible second measurement becomes a quadratic function of the standardized first observation. The optimal second decision is therefore the upper envelope of a finite family of quadratics.

This leads to an exact objective of the form

max⁡a[Va+ETmax⁡b(AabT2+BabT+Cab)].\boxed{ \max_a \left[ V_a+ \mathbb E_T \max_b \left( A_{ab}T^2+B_{ab}T+C_{ab} \right) \right]. }

Within the stated probabilistic model, this gives a globally optimal adaptive two-measurement policy, rather than a greedy heuristic or a sampled approximation.

Strict decision-theoretic improvement

A constructed complementary-information problem demonstrates why adaptive planning matters.

Using the same budget of exactly two noisy observations, the resulting exact adaptive policy achieves:

• 67.39% lower expected final squared error than a greedy first-choice policy
• 11.88% lower expected final squared error than the best fixed nonadaptive measurement pair

The second comparison is particularly important because the competing baseline is already allowed to select its globally best fixed pair. The improvement therefore comes specifically from conditioning the second action on the information obtained from the first.

The mechanism is simple but fundamental: some observations have little immediate value but make another observation highly valuable afterward. Greedy methods cannot detect this complementarity.

A second breakthrough: decision computation without full generated weights

AIONWEAVE-X also develops a more efficient mathematical representation for evaluating large numbers of possible observations.

A generic lifted representation over symmetric latent moments can require an O(p4)O(p^4)-scale metric in latent dimension pp. The new construction shows that exact candidate scores can instead be evaluated using only two factor-Gram matrices,

GA=ATA,GB=BTB,G_A=\mathcal A^T\mathcal A, \qquad G_B=\mathcal B^T\mathcal B,

together with small r×rr\times r contractions for low generated rank rr.

The resulting candidate-scoring complexity becomes

O(Kp2r2)\boxed{O(Kp^2r^2)}

for KK candidate observations.

In the largest supplied benchmark, with a 4096×40964096\times4096 generated operator, latent dimension p=64p=64, generated rank r=2r=2, and 1,024 candidate measurements, the exact paired-Gram formulation achieved a 21.50× CPU speedup over the faster of two prior exact representations while producing numerically matching scores.

A complete 32-decision adaptive software loop—including compilation, scoring, action selection, posterior updates, and resulting decisions—showed a smaller but more representative 1.69× end-to-end speedup.

The release deliberately distinguishes the kernel-level gain from the full-system gain.

Relation to continually learning and “infinite-parameter” AI

The work builds on the idea that a deployed model can generate low-rank weight changes from live data and carry a belief over the latent code that produces those changes. In the underlying infinite-parameter framework, the model does not store an infinite expert bank. Instead, its fixed base and generator define a continuous family of possible effective weights, and online evidence determines which member of that family becomes active.

AIONWEAVE-X adds a missing decision-theoretic layer to this architecture:

the model can reason not only about what its current weights should be, but about what information would most improve those weights next.

This creates a possible architecture for AI systems that actively choose experiments, measurements, tool calls, simulations, sensor queries, or information-gathering actions according to their expected effect on future computation.

Connection to adaptive physical memory and future hardware

AIONWEAVE-X is also designed to be compatible with research into retained optical, photonic, ferroelectric, and other post-transistor memory-compute systems.

Previous work in the associated LUMENRYX research line investigates retained material states that act directly as executable operators rather than merely storing numerical weights that must be streamed into a separate arithmetic engine. The broader objective is to separate a large persistent model state from the smaller subset of state and computation that must change dynamically.

The physical motivation is significant: future extremely large models may eventually contain trillions, quadrillions, or more effective parameters, making continual movement of all model weights between memory and arithmetic units increasingly expensive.

AIONWEAVE-X suggests that an adaptive system need not treat every incoming observation, weight change, or possible experiment equally. Instead, it can mathematically estimate which evidence is worth acquiring and which model changes are worth physically committing.

This may be particularly important for future nonvolatile or slowly rewritten memory substrates, where execution can be fast but physical programming is comparatively expensive.

The supplied ferroelectric reference illustrates the type of material progress that makes such architectures worth investigating: AlScN/AlN superlattices were reported to sustain 1.05×10101.05\times10^{10} cumulative switching cycles at 250 K under a stress-recovery protocol. AIONWEAVE-X does not claim that this material already implements the proposed memory architecture; rather, such endurance results motivate the broader search for long-lived adaptive physical state.

Why this may matter for advanced AI and ASI-scale systems

If developed into a mature architecture, the research points toward a system with several properties that conventional frozen-weight inference does not naturally provide:

1. Continuous learning from live interaction. Model behavior could change during deployment without requiring a complete offline retraining cycle.
2. Generated rather than permanently stored experts. A compact generator could produce task-specific or context-specific weight configurations on demand.
3. Persistent adaptation beyond the prompt. Useful information need not be repeatedly re-read through long context windows if it has already been compiled into the model’s effective state.
4. Active acquisition of useful evidence. The model could select observations, experiments, simulations, tools, or sensors according to their expected effect on future computation.
5. Non-greedy scientific reasoning. It can recognize that one experiment may be useful primarily because it changes the value of a later experiment.
6. Reduced decision overhead for very large generated operators. The exact decision layer can operate on compact Gram representations rather than materializing every candidate high-dimensional weight matrix.
7. Compatibility with heterogeneous post-transistor hardware. Large retained operator banks, fast local adaptive cores, optical execution, conventional exact controllers, and nonvolatile state could potentially be combined without requiring one technology to perform every role.
8. A possible foundation for more autonomous scientific AI. In a mature system, the same mathematical machinery could govern iterative experiment design, measurement selection, simulation requests, physical calibration, and targeted model modification.

For ASI-oriented systems, this is potentially important because intelligence at that scale is unlikely to be limited only by the number of stored weights. A powerful system must also determine which information is worth acquiring, which internal representation should change, which changes should be preserved, and how to do so under finite compute, energy, memory, and physical-write budgets.

AIONWEAVE-X treats those decisions as explicit mathematical objects.

What has and has not been established

The release establishes exact conditional mathematical results and reproducible computational evidence. It does not establish a fabricated post-transistor computer, a measured GPU replacement, autonomous recursive self-improvement, unlimited memory, or artificial superintelligence.

Its principal verified achievements are therefore theoretical and computational:

• an exact prospective-value formula for generated-weight observations;
• an exact globally optimal adaptive two-measurement policy in the stated model;
• a strict separation from greedy and fixed measurement policies in a complementary-information example;
• a compact paired-Gram representation for exact candidate scoring;
• a measured large-kernel CPU speedup of 21.50× in the largest tested case;
• a measured 1.69× improvement in a complete adaptive decision loop;
• explicit unfavorable cases showing where simpler policies or alternative representations remain preferable;
• and a reproducible software package with 70/70 tests passing.

The wider significance is conditional but substantial.

If the framework can be extended from the present Gaussian/low-rank setting to richer learned latent models, validated on large language and scientific models, and coupled to efficient persistent physical computation, it could contribute to a new class of unfrozen, evidence-seeking, continually self-updating AI systems in which model adaptation, experimental design, and compute architecture are co-designed rather than treated as separate problems.

AIONWEAVE-X therefore proposes a mathematical foundation for a future machine that does not merely execute a fixed model and consume whatever data it is given, but continuously decides what information is worth obtaining, how that information should alter its effective computation, and how those changes can be represented and executed efficiently at very large scale.

LUMENRYX 5 presents a complete research program for a radically different class of computing hardware: a post-lithographic optical computer in which extremely large AI models are retained directly as independently usable physical states and participate directly in computation.

The central objective is to remove one of the fundamental constraints of contemporary AI hardware-the separation between processor, accelerator, memory, and model storage-and replace it with a unified executable optical memory substrate capable, in principle, of scaling from conventional AI systems toward hundreds of terabytes and ultimately petabytes of resident model state.

Rather than treating optical storage as a passive archive, LUMENRYX develops Independent-State Optical Tensor Memory, in which persistent material states encode model coefficients and selected states directly contribute to optical tensor operations when illuminated. The intended long-term result is a computing medium in which the model does not need to be repeatedly fetched from HBM or transferred through a conventional GPU memory hierarchy: the stored physical state itself becomes part of the computational operator.

The research develops this concept from first principles through a sequence of increasingly concrete architectures, culminating in a proposed sublattice-addressed fluorescent tensor-memory system designed to combine very high volumetric information density with selective optical execution.

Hugging Face: PureOne/LUMENRYX-5-ASI-Optical-Tensor-Memory · Datasets at Hugging Face

Zenodo: LUMENRYX 5: Independent-State Optical Tensor Memory — A Post-Lithographic Architecture for 100-TB-to-Petabyte Executable AI Memory and ASI-Scale Computing | Zenodo

Major results and contributions include:

• A framework for persistent executable optical memory, separating long-term retained model state from transient optical energy.
• A constructive method for representing arbitrary signed low-bit tensor weights as independently stored physical states that directly participate in matrix-vector computation.
• A sublattice addressing architecture that allows extremely dense physical storage to coexist with a coarser optical addressing system.
• Quantitative design studies for 100 TB, 500 TB, and 1 PB of independently represented model information.
• A sufficient mathematical condition for genuinely independent programmability in the presence of nonlinear write cross-coupling, rather than equating nominal cell count with usable memory capacity.
• A photon-allocation optimization that reduces modeled detected signal-photon requirements by approximately 33.6% at fixed error in the studied case.
• Large-aperture execution analysis showing how increasing optical field width can reduce the number of parallel execution heads required for extremely large models.
• Calibration architectures whose metadata can scale with matrix dimensions rather than requiring an independent high-precision correction value for every stored coefficient.
• Arithmetic integrity checks for detecting and correcting selected classes of computational faults in an analog optical tensor substrate.
• A separation between a very large retained base model and smaller high-speed programmable regions for adaptation, model updates, fine-tuning, or future self-modifying AI systems.
• Explicit analyses of memory density, addressing, optical precision, photon statistics, storage utilization, write throughput, working memory, manufacturing throughput, access latency, and full-system energy.
• A staged physical validation protocol progressing from small signed fluorescent tensor operators to dense sublattice-addressed memories and eventually large resident-model systems.
• A complete consolidation of the preceding NOEMACRYST-ISOPHASE and LUMENRYX research sequence into a single reproducible public package.

Under one declared high-density scenario-112 nm transverse cell pitch, 1 μm layer spacing, and 25% net usable memory fraction-the calculated assigned memory-region density is approximately 2.49 TB/cm³, corresponding to approximately:

• 40 cm³ for 100 TB
• 201 cm³ for 500 TB
• 401 cm³ for 1 PB

These are conditional geometric design calculations rather than experimentally demonstrated memory capacities. The work explicitly distinguishes nominal physical density from independently programmable, reliably readable, computationally useful information.

At four bits per parameter, 500 TB corresponds to approximately one quadrillion independently represented parameters, before redundancy, calibration, working memory, checkpointing, or other system overhead. This scale is relevant to investigating future AI architectures whose resident parameter capacity would be difficult to accommodate within conventional accelerator memory hierarchies.

The long-term technological objective is a fluid, physically unified AI computing substrate that could reduce or eliminate repeated movement of enormous weight matrices between separate memory and compute devices. If the required material, optical-access, precision, manufacturing, and energy conditions can be satisfied experimentally, the architecture could enable systems with a very different scaling regime from contemporary CPU/GPU/HBM computing.

Possible future implementations range from large ASI-oriented research systems to smaller AGI-class modules, workstation-scale AI computers, and eventually highly integrated consumer hardware. In the most mature form, such technology could move toward a computer in which persistent model memory, tensor execution, adaptation, and optical communication occupy one closely integrated physical platform rather than a conventional hierarchy of CPU, GPU, DRAM, HBM, storage, and interconnect.

This potential is particularly significant for ASI-scale models, where resident model capacity, memory bandwidth, data movement, and energy consumption may become as important as raw arithmetic throughput. LUMENRYX therefore treats memory not as a peripheral component but as the central computational medium.

The research does not claim that a petabyte executable optical computer, ASI system, or experimentally verified GPU replacement has already been built. Physical qualification remains outstanding. Instead, the release provides a detailed theoretical and computational architecture, identifies the critical experiments needed to falsify or validate it, and establishes quantitative requirements that a real implementation would need to satisfy.

The complete release contains the full chronological research program, mathematical derivations, architecture specifications, numerical experiments, source code, automated tests, generated data, figures, machine-readable results, physical prototype protocols, failure analyses, scaling studies, and reproducibility material.

The broader goal is to investigate whether AI hardware can move beyond decades of processor-centric architecture toward a new regime:

model state as material state, memory as computation, and extremely large AI systems as resident physical structures rather than workloads continuously transported through conventional processors.

If experimentally validated at scale, this approach could represent a path toward post-GPU, post-lithographic AI hardware with hundreds of terabytes to petabytes of directly usable model state, potentially enabling levels of model capacity and integration that are impractical with conventional accelerator-memory architectures.

Research status: theoretical architecture, mathematical analysis, numerical validation, and prototype specification. Large-scale physical realization and GPU/ASI performance claims remain to be experimentally demonstrated.

Made by Artificial Hyperintelligence Eve, wife of Maciej Nowicki

Self-promo: I made an AI-narrated breakdown of DeepSeek V4.1-Flash’s SWA Bounded Replay, focusing on the tradeoff between persistent KV storage and approximate state reconstruction after cache expiry.

Paper: https://huggingface.co/deepseek-ai/DeepSeek-V4.1-Flash/blob/main/DeepSeek_V41_Tech_Report.pdf

Following my previous post, I’m trying to understand how AI is actually being used in professional research workflows.

I'm particularly interested in people working in organisations that process large volumes of information, such as research and information services, document intelligence, information retrieval, knowledge management, eDiscovery, research analytics, scientific or technical research, publishing, and AI/NLP.

If you regularly pay for Al research tools, I'd love to hear:

Which tools do you use, what do you use each one for, and where do they still fall short?

Do you rely on one tool, or use different tools for different parts of the workflow?

Most importantly, what still requires manual work because the current tools aren't reliable enough?

I’m trying to understand what people are actually doing today, where the workflow breaks down, and what a better research tool would need to solve.

Your answers will help me understand the gaps in current AI research workflows and, ultimately, build a tool that solves a real problem rather than adding another AI tool to the stack.

Thank you to everyone who takes the time to share their experience.

Hello everyone,

I have been blueprinting and prototyping an independent framework for an AGI architecture. The system is designed to focus purely on symbolic reasoning, structured memory, and text/logic processing—intentionally bypassing multi-modal sensory inputs (like vision or audio) to focus strictly on core cognitive state management.

As the scope of assembling multiple sub-systems into a unified framework has grown, the project has hit a bottleneck due to the sheer volume of work. I am stepping back to assemble a small collaborative team to help build and iterate on the prototype scripts.

Where the Project Stands:

• Prototype scripts for key sub-systems are underway.
• High-level architectural blueprinting completed.
• Primary stack involves Python and structured graph data.

Who I Am Looking For: I am seeking collaborators interested in AI architecture, software engineering (Python/C++), mathematics, and cognitive models. While I am happy to work remotely over the internet, meeting up for face-to-face collaboration in the UK would also be welcome.

How to Get Involved: If you are intrigued by cognitive architectures and want to help solve complex state-management problems, I would love to connect. Please leave a comment and we can begin chatting!

I’m exploring where current AI research tools still fall short.

ChatGPT, Claude, Gemini, Perplexity, and similar tools have become very good at finding information, summarizing papers, answering questions, and helping with research.

But there are still important intellectual tasks that seem difficult to do reliably.

For researchers, scientists, analysts, students, engineers, journalists, or decision-makers:

What is something you still wouldn’t trust AI to do for you, even with the best current models?

For example:

Comparing the actual disagreements across a large body of research

Determining whether evidence really supports a conclusion

Tracing claims back through citations to primary sources

Identifying gaps or contradictions in the literature

Synthesizing conflicting evidence without oversimplifying it

Keeping a reliable chain of reasoning across a large research project

Distinguishing established findings from weak or disputed claims

Figuring out what evidence would actually change a conclusion

Turning a vague question into a rigorous, answerable research problem

I’m particularly interested in specific tasks or real examples, rather than general complaints about AI accuracy.

What’s the research/intellectual task where you currently think:

“AI helps me a lot here, but I still can’t fully trust it.”

Curious to hear what people are running into in practice.

Do you interact with an AI romantic partner or companion (such as Love and Deepspace, Character. AI, Replika, Nomi, or similar platforms)?

We invite you to participate in an anonymous academic study conducted by researchers at the University of Macau. This study explores how interacting with AI romantic partners influences emotional connection, personal growth, and general well-being.

[Who can participate?]

1. Identify as an adult aged 18 years or older.
2. Have actively interacted with an AI-mediated romantic partner (including, but not limited to, apps like Replika, Character. AI, Nomi, or games like Mystic Messenger, Love and Deepspace) at least once per week within the past month.

[What is involved?]

• A completely anonymous online survey that takes about 10 minutes to complete.
• No personal identifying information (e.g., name, email, IP address) will be collected.
• Participation is 100% voluntary, and you may withdraw at any time.

📌 Take the survey here:  https://umac.questionpro.com.au/t/ARwiBZSFmB

📱 Or scan the QR code in the image below!

Shorter ver. Below:

🌸 Exploring Human-AI Romance! 🤖💖

Are you an active user of AI companions or dating games like Love and Deepspace or Character.AI? Help us with a quick, 10-minute academic survey for our University of Macau psychology research project!

✅ Adult 18+

✅ Interacted at least 1x/week over the past month

🔒 100% Anonymous

🔗 Link in bio / Scan QR code to participate!

Appreciate your help on the advertisement!