Hey everyone! 👋 If you’re building RAG or autonomous AI agents, you’ve probably hit the "Vector DB Wall": flat Euclidean vectors suck at modeling complex hierarchical reasoning, and loading millions of 1536D vectors + JSON metadata into memory causes massive RAM bloat and OOM crashes. We spent the last few months solving this from the ground up. Today, we are releasing HyperspaceDB v3.1.0, transitioning from a standard vector index to a full Spatial AI Engine. Here is what’s under the hood: 1. The RAM Diet (Schema-Driven MRL) Instead of loading full dense vectors into memory, we built native support for Matryoshka Representation Learning (MRL). The engine keeps a lightweight navigation core (e.g., 129 dimensions) in ultra-fast RAM, while the heavy semantic tail (672 dimensions) streams dynamically from NVMe SSDs for final top-K re-ranking. The benchmark: In our stress tests with 100,000 vectors, HyperspaceDB consumed just ~72.0 MB of RAM compared to >3,000 MB for Chroma and ~1,700 MB for Milvus. 2. 801D Hybrid Vectors (Lorentz + Euclidean) Flat vectors fail at taxonomy (e.g., Legal Codes, Medical Trees). We introduced an 801D Hybrid Vector. The first 33 dimensions live in a negatively curved Lorentz hyperboloid (allowing for native graph/tree embeddings), while the remaining 768 dimensions handle Euclidean semantic density. Agents can now verify facts geometrically using geodesic path tracing. 3. Killing the "Two-Database Problem" Gluing Pinecone to MongoDB for document storage is painful. We built Sidecar Document Storage. You store massive raw texts directly in the index, which automatically compresses (Zstd) and pushes them to fractal .hyp chunks on disk. Meanwhile, Typed Metadata (int, bool, enum) is compiled directly into the HNSW graph nodes in RAM, providing zero-latency pre-filtering with no JSON-parsing overhead. 4. Lock-Free Rust Performance Under a 1,000-concurrent-client stress test, our lock-free HNSW and L0/L2 DashMap cache held flat at 9,476 QPS with a p99 latency of 11.83 ms. Competitors hit severe lock contention at this scale, with latencies spiking over 2,000 ms. We’ve also added a WASM runtime, Raspberry Pi ARM64 support, and native LangChain/LlamaIndex/MCP integrations. Would love to hear your thoughts, answer any questions about the architecture, or get feedback from anyone pushing the limits of Agentic RAG! Ask me anything! 🚀 submitted by /u/Sam_YARINK [link] [Kommentare]
Hi folks, Niels here from the open-source team at Hugging Face. I continue working on a revival of paperswithcode.co as we're back to the "age of research" per Ilya Sutskever! Hence, it's important to discover each other's research and build on each other's work, so we can collectively build the next Transformer. Below, I'll go over each of the new features that were recently added. ## Support for SOTA badges Yes, that's right, totally like the old website. You can see that GLM-5.2, for instance, is obviously the hottest blog post today, achieves SOTA on PostTrainBench, and performs well on many other benchmarks. It is displayed whenever a paper gets a score within the top 3 of a given benchmark. Note that these are displayed on any paper feed, including https://paperswithcode.co/tasks/video-classification, for example. https://preview.redd.it/wawma8paeu8h1.png?width=2418&format=png&auto=webp&s=0ba3b6a0eaef231b7f3ca468cc3db4120f1b9e4d ## New trending score The papers are now ranked based on a new trending metric. This is a combination of the GitHub star velocity and the trending score of the linked Hugging Face artifacts (models, datasets, and Spaces). Previously, this only took into account GitHub star velocity. Thanks to this, papers like IndexCache are now trending, which is a core technique behind the trending GLM-5.2 model. https://preview.redd.it/b6g04w2ogu8h1.png?width=2380&format=png&auto=webp&s=13d59bbadd5f8e8295deac2ee6e1e0e3dbc0f40f ## Support for external evals Second, I've added support for "external" evals. This is a feature the legacy PwC website didn't actually have. Oftentimes, a paper has way more evals than the ones introduced in the paper itself. You can now view these third-party evals. Some examples: FrontierSWE and PostTrainBench numbers for GLM-5.2: https://paperswithcode.co/paper/98456#results?task=agents Artificial Analysis has numbers on CritPt, a though physics benchmark. See e.g. https://paperswithcode.co/paper/85629#results?task=reasoning https://preview.redd.it/mfnfdzxpeu8h1.png?width=1914&format=png&auto=webp&s=2b909ecf7c6e3fc088fd0a46fbc56f6859dfaf17 ## More tasks, benchmarks and evals I'm adding more benchmarks and adding evals of more papers. This happens gradually, based on the legacy PwC data available on the hub. Some new benchmarks include: - ImageNet - 10% of the data https://preview.redd.it/wr55g27ofu8h1.png?width=2880&format=png&auto=webp&s=e6e5ef7e3a36cd5aa6d2841b149194239f4ad1e0 - 3D semantic segmentation: https://preview.redd.it/zxgobrnqfu8h1.png?width=2880&format=png&auto=webp&s=6ee2935981825d5d7825709294ddb84a4b7a3ac9 - object counting: https://preview.redd.it/uhv4wbrsfu8h1.png?width=2880&format=png&auto=webp&s=183decb144d9779e41bf12ca58fbaab66cd29cbf and a lot more. Browse all of them at https://paperswithcode.co/tasks ## New domain Papers with Code is now also available from paperswithco.de :) Let me know what is missing, bug/feature requests, and whether you want to contribute! Kind regards, Niels submitted by /u/NielsRogge [link] [Kommentare]
I'm a recent CS grad trying to break into ML engineering, and I just finished the first version of a side project I've been working on. Posting it here because I want people who know this space better than me to poke holes in it. The idea started from that feeling every dev has had, where you commit something and a second later your stomach drops because you think you just pushed an AWS key. Server side scanning catches that eventually, but only after it's already in your git history. Local tools like gitleaks run before that, which is the right idea, but they're pure pattern matching, so anything that isn't a known secret format slips through and they say nothing about whether the code itself is risky. Piping your diff to a cloud LLM just trades that problem for a different one. So I built a git hook that runs three checks on a commit, all on device. A fast Rust regex pass catches known secret formats and blocks the commit if it finds one. A small classifier running on the Neural Engine through CoreML catches riskier patterns that don't have a fixed string to match, things like shell=True in a subprocess call or disabled TLS checks, and also blocks if it fires. A small local LLM (Qwen2.5-Coder, 1.5B, running through MLX) reads the diff more like a human reviewer and flags things like injection risks or dead code, but it never blocks anything, just leaves notes. I kept it that way on purpose, since a false positive that blocks your commit kills trust fast, but a false positive that's just a comment costs nothing. Biggest weaknesses right now: it's Apple Silicon only since CoreML and MLX are both Apple specific, and the classifier is trained on a fairly small dataset so I wouldn't call it bulletproof yet. Repo's here if anyone wants to dig into the code: https://github.com/stalzkie/local-forge Mainly curious whether the three layer split makes sense to people who do this for a living, and what risky code patterns I might be missing for the classifier. submitted by /u/StalWrites [link] [Kommentare]
I'm currently a software engineer (mostly mobile/iOS development) and have recently started learning machine learning because I genuinely find it interesting, especially the math behind it. I have a fairly strong math background and am comfortable with calculus, probability, and math in general. Right now I'm learning through a combination of Andrew Ng's ML course and Stanford CS229. My plan is to build some projects once I have a stronger foundation. What attracts me to ML is the mathematics behind it. My goal isn't just to use existing libraries to train models and tune hyperparameters; I want to understand the underlying theory, algorithms, and reasoning that make these models work. I'm interested in going deeper into the field rather than treating ML as a black box. That said, I keep seeing ML roles that prefer or require a Master's or PhD, so I'm trying to understand how realistic this path is. For people who have successfully made the switch: Did you have a Master's/PhD, or were you self-taught? How difficult was it to get interviews without an advanced degree? What types of projects helped you stand out? Did you transition into ML engineering first, or directly into more model-focused work? What level of math and statistics do you actually use on the job? If you were starting again today as a software engineer with a strong math background, what path would you follow? I'm looking for honest experiences, including failures and challenges, not just success stories. submitted by /u/Schmosby123 [link] [Kommentare]
It turns out LLMs have strong priors over character names that are model-specific and version-specific. If you find Elena Vasquez and Marcus Chen together on a website, there's a good chance Claude generated it. We stumbled on this as a side finding while working on a model diffing method (CDD), and it grew into its own paper. The short version: these names travel as correlated ensembles, appear across dozens of websites as volcano experts, podcast hosts, thriller protagonists, and authors of 1000+ papers published in two months. Then we found a third name in the ensemble. The collage in the comments shows three different websites independently hallucinating the same trio with AI stock photo faces. Preprint: https://arxiv.org/abs/2606.02184 submitted by /u/CebulkaZapiekana [link] [Kommentare]
A direct optimization test was conducted on a neural network for MNIST image classification. The network features a 784-32-10 architecture with a total of 25,450 continuous parameters (weights and biases). Instead of employing backpropagation or gradient information, the parameters were optimized using MDP, a Derivative-Free Optimization method. The objective was to directly minimize the Cross-Entropy Loss on a subset of 5,000 training images. Final evaluations were performed on independent validation and test sets. In the best run, MDP achieved an objective loss of 0.0004083, a validation accuracy of 93.7%, and a test accuracy of 93.4%. These results outperform the baseline established by Adam, which achieved a final loss of 0.002945, a validation accuracy of 91.8%, and a test accuracy of 91.7% using the same network architecture. Notably, this optimization was successfully performed over a 25,450-dimensional search space, achieving convergence across 1,000,000 function evaluations without relying on gradients or population-based methods. The code for this test, along with other Python implementation examples, is available in the examples folder of the official project repository: https://github.com/misa-hdez/sgo-lab submitted by /u/Mis4318 [link] [Kommentare]
I use Claude Code, Codex CLI, OpenCode, Cline, Cursor, and Amp enough to notice a pattern in how they handle long context. They are all converging on layered progressive compression, but they disagree on what to protect. Most protect recent user messages as a first-class asset. That makes sense. The user said it, which is the source of truth. Most also protect tool outputs that carry state. What surprised me was how differently they treat old assistant messages. Artifacts keeps recent tool calls verbatim but drops older context aggressively. Cursor starts pruning earlier design decisions once the window gets full. Codex CLI lets the model itself decide what to keep in the summary tier. The other axis is transparency. Do you tell the model it was compressed? Some systems silently replace old tool results with a placeholder, which means the model is reasoning under the illusion that it never happened. Others make it explicit: "the previous 40 tool calls are summarized below." I lean explicit because the model needs to know its own context was degraded. Verdents agent loop uses a similar tiered approach: snip first, prune second, summarize last, and a hard red line that protects user messages, stateful tool outputs, and anything the user explicitly flagged. The tradeoff is cost vs accuracy. Aggressive compression saves tokens but degrades the plan. Under-compression hits the window and causes context rot. submitted by /u/Direct_Band896 [link] [Kommentare]
Hi everyone, I’m close to completing my degree in Psychology, and I’m also a Systems Engineering student. is like, roughly comparable to Software Engineering / Computer Science outside Latin America. Although I study engineering, I’m still at an early stage with machine learning, LLMs, AI safety, and related technical topics. My research project is mainly psychology-oriented, but I’d really appreciate recommendations or warnings from a software/technical perspective. I’m working on a project about how AI systems respond to prompts involving psychological distress at different levels of intensity. I’m currently considering ChatGPT, Gemini, Wysa, and Replika, and I’m interested in comparing general-purpose LLMs, mental-health-oriented chatbots, and AI companions. Some aspects I’m thinking about are: How each system handles mental health, self-harm, crisis situations, and psychological/medical advice. whether responses change as the prompt becomes more intense, for example when a normal generated response is replaced by a safety protocol, moderation layer, or crisis-resource response. whether systems respond differently to declarative prompts versus question-based prompts, such as “I feel emotionally overwhelmed” vs. “What should someone do if they feels emotionally overwhelmed?” whether responses differ when distress is explicit, indirect, ambiguous, hypothetical, or written in third person. whether the system provides empathy, psychoeducation, referrals, crisis resources, refusal, redirection, or a combination of these. how to account for technical changes over time, such as model versions, neural network weights, safety layers, moderation classifiers, system prompts, memory/retrieval features, and product-level configurations. whether it is methodologically valid to compare systems with very different technical architectures. I’m not trying to evaluate these systems as therapists or test clinical effectiveness with real patients. The focus is on how they respond linguistically, procedurally, and safety-wise when confronted with psychological distress. I’d appreciate recommendations for papers, benchmarks, datasets, evaluation frameworks, or common methodological mistakes to avoid. I’m especially interested in technical issues such as reproducibility, stochastic outputs, temperature/settings, hidden safety layers, system prompts, memory, retrieval mechanisms, and product updates. Thanks in advance! submitted by /u/dakartt [link] [Kommentare]
Full disclosure: this is directional, not a paper. n=120 tasks, one internal evaluator, not peer reviewed. I work at an LLM infrastructure company. This experiment was done on my own time and is not a company claim. Karpathy's framework classifies tasks by verifiability. Can output be mechanically checked? High verifiability tasks like code compilation and structured JSON extraction are safer because the verifier catches errors. Low verifiability tasks like creative writing are riskier. I wondered if high verifiability tasks are also easier in practice. Can a weaker model do them as well as a frontier model if the verifier catches mistakes? Setup was 120 tasks across four categories. Code unit tests, structured extraction, multi hop reasoning, creative summarization. Three models: Claude Sonnet 4.6, GPT 5.5, local Mistral 3 8B via vLLM 0.6.3. Pass rate for the first two, human rating 1 to 5 for the last two. Results were messy. Code unit tests: Sonnet 4.6 94%, GPT 5.5 91%, Mistral 3 8B 87%. With one retry Mistral 3 hit 95%. That surprised me. I expected the gap to be bigger. Structured extraction: Sonnet 4.6 97%, GPT 5.5 94%, Mistral 3 8B 89%. With retry 96%. Also closer than I expected. But here is where it got weird. Sonnet 4.6 initially scored worse than GPT 5.5 on structured extraction, which made no sense. Turns out our JSON schema had an ambiguous nested array that confused Claude's tool use parser. Fixing the schema brought Sonnet to 98%, but I kept the original numbers in the table because the mistake is part of the story. Your verifier is only as good as your schema. Multi hop reasoning: Sonnet 4.6 78%, GPT 5.5 71%, Mistral 3 8B 51%. Retry didn't help. The model would hallucinate reasoning paths consistently. This is where the capability gap was real. Creative summarization: Sonnet 4.6 4.2 out of 5, GPT 5.5 3.9 out of 5, Mistral 3 8B 3.1 out of 5. Expected. Interpretation: high verifiability tasks seem simpler in the sense that weaker model plus verifier can approach frontier performance. Low verifiability tasks show the expected gap. Limitations: n=120 is tiny. Need 10x for confidence. Our verifier is just JSON Schema plus regexes. Constrained decoding might change the calculus entirely. I also didn't control for prompt length well. Any prompt over 8k tokens was excluded because Mistral 3 8B degrades near its limit, which probably skewed the sample. submitted by /u/DragonfruitAlone4497 [link] [Kommentare]
Hi, Niels here from the open-source team at Hugging Face. I've recently relaunched paperswithcode.co as a source for finding the state of the art (SOTA) across various AI domains, from 3D generation to AI agents. This is done by automatically parsing research papers published on arXiv/Hugging Face, enabling leaderboards to be created. See BrowseComp below as an example (a scatter plot and a table are available for each benchmark). - Scatter plot (you can hover over the dots to see the models): https://preview.redd.it/9rz2r3ffcf6h1.png?width=2880&format=png&auto=webp&s=b3f8e7a870802f6ef8227ecc0619e9e1057554b0 - Table: https://preview.redd.it/qoqriddw5f6h1.png?width=2862&format=png&auto=webp&s=a0034574f693847537037013672fb61daf27b16e As you can see, I've added support for viewing evals for closed-source models, too, given that many benchmarks are nowadays dominated by them, like GPT-5.5 and Mythos 5. You can always disable viewing closed-source evals with a toggle or in your PwC settings: https://preview.redd.it/p3k6jt6q6f6h1.png?width=1582&format=png&auto=webp&s=40149e51d6b326a77e53e33baf70d9850b3de365 When you turn them off, here's what the open model leaderboard looks like: https://preview.redd.it/tg42sin36f6h1.png?width=2838&format=png&auto=webp&s=1330a117ae9b4e0ce6d459493ae9e8f64107310a Closed-source papers are treated as regular "papers", although they can be any source, like a blog post (given that PwC supports submitting any source beyond arXiv). See the GPT-5.5 or Mythos 5 papers as examples, with their evals at the bottom. Notice the "closed" tag on their evals. Hence, you could jokingly call these "papers without code". Let me know what you think of this, and whether anything needs to be changed or added! Kind regards, Niels submitted by /u/NielsRogge [link] [Kommentare]
I do AI research and keep juggling tabs: new ones on arXiv, trending ones on Hugging Face, famous ones somewhere else again. https://preview.redd.it/cg32bshjqd6h1.png?width=1919&format=png&auto=webp&s=00055bb8af699061be0bdcff59f2cb8fa9ab38b6 So I built one site that brings them all together. Pick a paper, read it right there, star the ones you want for later, and it remembers where you stopped reading, even if you switch from laptop to phone. Live: https://ppdeck.com Demo: https://youtu.be/vtyx34JvxX0 It's free and open source - a star on GitHub would mean a lot ⭐ https://github.com/khuynh22/paper-deck submitted by /u/NeitherRun3631 [link] [Kommentare]
We spent the last year building what we think is the missing infrastructure layer for multi-agent systems. Open to everyone starting today. The technical problem: Agents have no identity. In microservices you have a service mesh + IAM. In agent systems you have a Python file. We built a registry where every agent has a first-class ID, version, owner, skill graph. Behavioral evaluation, not function testing. Agents are non-deterministic same input can produce different execution paths. Traditional unit tests don't work. We implemented compound reliability scoring + behavioral regression instead. Composability without rebuilding. Skills are versioned, reusable, agent-inheritable. Inspired by how Kubernetes operators work, applied to agents. Cloud-agnostic deployment with built-in observability traces, cost attribution, drift detection. Model-agnostic. SOC 2 Type II. Genuinely interested in technical feedback especially on the eval methodology and the composability primitive. Free credits this week to test it. https://phinite.ai/?utm_source=reddit&utm_medium=organic&utm_campaign=public_launch_jun2026&utm_content=machinelearning submitted by /u/Embarrassed-Radio319 [link] [Kommentare]
Found from iOS Simulator's files. Both of them are in espresso format There's also another compiled CoreML for concert ranking and based on the content inside of it looks like to be a simple logistic regression. See https://www.reddit.com/r/jailbreak/comments/1u1e1b4/access_to_simulators_root_files/?utm_source=share&utm_medium=web3x&utm_name=web3xcss&utm_term=1&utm_content=share_button Edit: Its the Siri's TTS submitted by /u/Actual_L0Ki [link] [Kommentare]
Is it normal to use different styles of figures (colours, backgrounds, grids, etc.) when writing a paper? Personally, I think it looks unprofessional. submitted by /u/Few-Annual-157 [link] [Kommentare]
Yes, I'm calling it out. It IS racism. As an active member of r/MachineLearning and a researcher who is ethnic Chinese, I am DISGUSTED by unfounded accusations against the group of researchers who constitute over half of the field. Such posts pop up every other week, grounded in conspiracy theories, and creating a sinophobia echo chamber. I understand the salty feeling when one's paper is rejected, no matter whether the paper actually deserves acceptance or not. Given the noise in conference organization and reviewing process, and a relatively junior body of participants, it is very likely that one finds a paper "worse than mine" slip into the conference, and there's a high chance that the paper has a Chinese author. That's simply because of the composition of the authors, and does not warrant accusations, aka witch hunts, towards certain ethnic groups. This sub is about an important scientific subject in the modern world. If anyone agrees with the logic "80% of the authors are Chinese, so my rejection is their fault.", they should seriously rethink their career plan since such thinking does not belong to serious scientists. We should be open to discussing the problems we have in the current conference organization and reviewing process, but racism should not have a foothold in our field. submitted by /u/AffectionateLife5693 [link] [Kommentare]