title stringlengths 1 300 | score int64 0 8.54k | selftext stringlengths 0 41.5k | created timestamp[ns]date 2023-04-01 04:30:41 2026-03-04 02:14:14 ⌀ | url stringlengths 0 878 | author stringlengths 3 20 | domain stringlengths 0 82 | edited timestamp[ns]date 1970-01-01 00:00:00 2026-02-19 14:51:53 | gilded int64 0 2 | gildings stringclasses 7 values | id stringlengths 7 7 | locked bool 2 classes | media stringlengths 646 1.8k ⌀ | name stringlengths 10 10 | permalink stringlengths 33 82 | spoiler bool 2 classes | stickied bool 2 classes | thumbnail stringlengths 4 213 ⌀ | ups int64 0 8.54k | preview stringlengths 301 5.01k ⌀ |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
GLM-5 and DeepSeek are in the Top 6 of the Game Agent Coding League across five games | 41 | Hi.
Game Agent Coding League (GACL) is a benchmarking framework designed for LLMs in which models are tasked with generating code for game-playing agents. These agents compete in games such as Battleship, Tic-Tac-Toe variants, and others. At present, the league supports five games, with additional titles planned.
More info about the benchmark & league [HERE](https://gameagentcodingleague.com/)
Underlying project in Github [HERE](https://github.com/summersonnn/Game-Agent-Coding-Benchmark)
It's quite new project so bit of a mess in repo. I'll fix soon and 3 more games. | 2026-02-17T20:40:43 | kyazoglu | i.redd.it | 1970-01-01T00:00:00 | 0 | {} | 1r7i2im | false | null | t3_1r7i2im | /r/LocalLLaMA/comments/1r7i2im/glm5_and_deepseek_are_in_the_top_6_of_the_game/ | false | false | 41 | {'enabled': True, 'images': [{'id': '22z0y8ni84kg1', 'resolutions': [{'height': 88, 'url': 'https://preview.redd.it/22z0y8ni84kg1.png?width=108&crop=smart&auto=webp&s=e750bd909955efbc1d1aa68f723cd8687ce126fc', 'width': 108}, {'height': 176, 'url': 'https://preview.redd.it/22z0y8ni84kg1.png?width=216&crop=smart&auto=webp&s=9704a9b19a72422866d86e0f6f3d431dc75d4c3a', 'width': 216}, {'height': 262, 'url': 'https://preview.redd.it/22z0y8ni84kg1.png?width=320&crop=smart&auto=webp&s=8c75efaafe037d102f0274765c4008b961af0948', 'width': 320}], 'source': {'height': 503, 'url': 'https://preview.redd.it/22z0y8ni84kg1.png?auto=webp&s=ea3608247c4177b5abde41f5c3e5fd12c1c2230a', 'width': 614}, 'variants': {}}]} | ||
Voxtral Realtime 3B in Swift/MLX - first local implementation, now available in a real Mac dictation app | 1 | It transcribes audio in chunks while you're talking.
The experience depends heavily on your chip.
Transcription time scales with memory bandwidth, so:
* M3 (100 GB/s): noticeable lag
* M3 Pro (150 GB/s): better
* M4 Pro (273 GB/s): fast
* M4 Max (546 GB/s): people are reporting basically instant
I'm on M3 Air so I get the worst of it, for me the delay is somewhere around 3-5 sec.
Try it yourself at [https://ottex.ai](https://ottex.ai) \- free for personal use, supports popular local models and BYOK providers (openrouter, mistral, groq, fireworks, etc)
https://preview.redd.it/inra3kz964kg1.png?width=2056&format=png&auto=webp&s=baff9ea6ff04cb9572c14c8aae71309936d3bcef
https://preview.redd.it/idlh5rbz74kg1.png?width=2056&format=png&auto=webp&s=4283b6a01ac312643aec59f9176c36e82853e296
https://preview.redd.it/94gg3ffq64kg1.png?width=2056&format=png&auto=webp&s=ae4ac5fde622488a048360c79556f09ffbb07cf0
https://preview.redd.it/91ihre6k64kg1.png?width=2056&format=png&auto=webp&s=18a0aacd38be7a2ee250adbdbe778e715f3d037e
| 2026-02-17T20:36:40 | https://www.reddit.com/r/LocalLLaMA/comments/1r7hym7/voxtral_realtime_3b_in_swiftmlx_first_local/ | ksanderer | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r7hym7 | false | null | t3_1r7hym7 | /r/LocalLLaMA/comments/1r7hym7/voxtral_realtime_3b_in_swiftmlx_first_local/ | false | false | 1 | null | |
GLM-5: China's Open-Source Giant That Rivals Claude and GPT | 0 | 2026-02-17T20:34:56 | https://www.reddit.com/r/LocalLLaMA/comments/1r7hwwy/glm5_chinas_opensource_giant_that_rivals_claude/ | Delicious_Air_737 | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r7hwwy | false | null | t3_1r7hwwy | /r/LocalLLaMA/comments/1r7hwwy/glm5_chinas_opensource_giant_that_rivals_claude/ | false | false | 0 | null | ||
Free LLM APIs for Development | 0 | Hi all
I am building a project in that need free apis that can help us in development and programming, if there any chepest then please share with me | 2026-02-17T20:30:01 | https://www.reddit.com/r/LocalLLaMA/comments/1r7hrxf/free_llm_apis_for_development/ | Significant-Foot2737 | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r7hrxf | false | null | t3_1r7hrxf | /r/LocalLLaMA/comments/1r7hrxf/free_llm_apis_for_development/ | false | false | self | 0 | null |
Speculative decoding on Strix Halo? | 9 | I just found out about speculative decoding (Alex Ziskind on YT). Given the low bandwidth on the strix halo but relatively big ram (128), I had in mind that only large MoE models made sense on that machine (relatively small active parameters making an MoE model usable Vs a dense model that'd just be too slow).
But then there's speculative decoding to maybe double+ tgs? And it should be even more relevant with large context windows.
Gemini says that MoE + speculative decoding should be faster than just MoE, but with a smaller gain.
Gemini also says there's no quality degradation using speculative decoding.
I'm shocked i haven't heard about that stuff until now.
Are there benchmarks to figure out optimal combos on a 128gb strix halo? There's the size constraint + AMD tax to factor in (gguf, quantization limitations & the likes). I assume Linux. | 2026-02-17T20:01:24 | https://www.reddit.com/r/LocalLLaMA/comments/1r7gzc7/speculative_decoding_on_strix_halo/ | Hector_Rvkp | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r7gzc7 | false | null | t3_1r7gzc7 | /r/LocalLLaMA/comments/1r7gzc7/speculative_decoding_on_strix_halo/ | false | false | self | 9 | null |
What is the current best creative model that works on consumer hardware | 0 | So it's been a while since I have tried local models for story writing purposes. How much has the domain progressed, or has it progressed any since llama 3 and gemma 3 finetunes?
I have 16gb vram and 96gb ram, what models can I run locally that has decent context understanding and prose writing?
I am NOT looking for a model that is good at coding, I dont care for any STEM related tasks, all I care about is that it can write well. | 2026-02-17T19:58:28 | https://www.reddit.com/r/LocalLLaMA/comments/1r7gw8b/what_is_the_current_best_creative_model_that/ | falconandeagle | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r7gw8b | false | null | t3_1r7gw8b | /r/LocalLLaMA/comments/1r7gw8b/what_is_the_current_best_creative_model_that/ | false | false | self | 0 | null |
Looking to run GLM 5 with optimal settings | 0 | I have been running GLM 4.7 with llama.cpp and its performance is great! I have 128 Gbs of RAM and an Nvidia 5090. I have been running GLM 4.7 with this command `.\llama-server.exe -hf unsloth/GLM-4.7-Flash-GGUF:Q6_K_XL --host` `127.0.0.1` `--port 10000 --ctx-size 32000 --n-gpu-layers 99` and that seems to do the job just fine. I can connect this process to my text editor. Usually, I use Continue in VSCodium but I've been experimenting with other editors as well.
I heard that GLM 5 came out, but I don't know the optimal command to run it. I have been using the Q6 GGUF version of GLM 4.7 but the huggingface page for GLM 5 is weird. It doesn't have Q4\_K\_XL, Q6\_K\_XL, Q6\_K\_XL, etc... It seems to have slightly different naming conventions. Can someone tell me what the equivalent command for GLM5 would be compared to my GLM 4.7 command? Also, is there a better command I should be using altogether to run my models?
P.S. I noticed that some text editors require parameters like an API key, Max Completion Tokens, Max Output Tokens, and Max Tokens. For API key I just give a nonsense string and that seems to work. But I don't know what Max Completion Tokens, Max Output Tokens, and Max Tokens is supposed to be? | 2026-02-17T19:56:57 | https://www.reddit.com/r/LocalLLaMA/comments/1r7gup0/looking_to_run_glm_5_with_optimal_settings/ | warpanomaly | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r7gup0 | false | null | t3_1r7gup0 | /r/LocalLLaMA/comments/1r7gup0/looking_to_run_glm_5_with_optimal_settings/ | false | false | self | 0 | null |
Curious what setups you're all running for agentic coding (Claude Code, sub-agents, etc) | 2 | I've been nerding out on multi-agent coding workflows lately and I'm curious how others have their rigs set up.
Here's mine:
- MacBook Air M4 (16GB)
- Cursor + Claude Code in VS Code side by side
- Claude handles the heavy lifting, agents can spawn sub-agents for parallel work
- No local LLM running yet — wondering if I'm leaving performance on the table
It works, but I feel like I'm probably missing something obvious. When multiple agents are doing things at once, tracking what's happening gets chaotic.
What are you running?
- How do you manage windows/context when stuff runs in parallel?
- What machine specs actually matter? Is 32GB the sweet spot or am I bottlenecking myself?
- Local LLMs alongside cloud — worth it or just extra complexity?
- How many projects in parallel do you work on (or worktrees)? I ideally work with 2-3 worktrees.
Curious what's actually working for people day-to-day, not the theoretical "ideal setup" stuff. | 2026-02-17T19:52:17 | https://www.reddit.com/r/LocalLLaMA/comments/1r7gq2r/curious_what_setups_youre_all_running_for_agentic/ | asklee-klawde | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r7gq2r | false | null | t3_1r7gq2r | /r/LocalLLaMA/comments/1r7gq2r/curious_what_setups_youre_all_running_for_agentic/ | false | false | self | 2 | null |
Built a self-hosted mem0 MCP memory server for Claude Code, Ollama handles embeddings locally, optional local graph LLM too | 2 | Weekend project: a self-hosted MCP server that gives Claude Code persistent memory across sessions. The local LLM angle is what I think this community will find interesting.
**Where local models fit in:**
This server uses [mem0ai](https://github.com/mem0ai/mem0) as a library. mem0's pipeline has two paths, and both can run locally:
**1. Vector memory (embeddings) - Ollama, always local**
Every `add_memory` call extracts key facts via LLM, then embeds them using your local Ollama instance. I'm using [bge-m3](https://ollama.com/library/bge-m3) (1024 dims), runs fast, good multilingual support, and the quality is solid for semantic memory retrieval.
MEM0_EMBED_PROVIDER=ollama
MEM0_EMBED_MODEL=bge-m3
MEM0_EMBED_URL=http://localhost:11434
MEM0_EMBED_DIMS=1024
**2. Knowledge graph (entity extraction) - Ollama, Gemini, or split-model**
The optional Neo4j graph builds entity relationships ("user prefers TypeScript", "project uses PostgreSQL"). Each `add_memory` with graph enabled triggers 3 LLM calls: entity extraction, relationship generation, and contradiction resolution.
You have choices:
|Provider|Cost|Quality|VRAM|
|:-|:-|:-|:-|
|**Ollama (Qwen3:14b)**|Free|0.971 tool-calling F1|\~7-8GB (Q4\_K\_M)|
|**Gemini 2.5 Flash Lite**|Near-free|85.4% entity extraction|Cloud|
|**Claude (default)**|Uses subscription quota|79.1% extraction, 100% contradiction|Cloud|
|**gemini\_split**|Gemini + Claude|Best combined: 85.4% + 100%|Mixed Cloud|
With the Ollama path you have zero cloud dependency for graph ops:
MEM0_ENABLE_GRAPH=true
MEM0_GRAPH_LLM_PROVIDER=ollama
MEM0_GRAPH_LLM_MODEL=qwen3:14b
Qwen3:14b nearly matches GPT-4's tool-calling accuracy (0.971 vs 0.974 F1) and handles the structured entity extraction well. The graph pipeline uses tool calls internally, so tool-calling accuracy is what matters here.
**What the server does:**
Claude Code forgets everything between sessions. This MCP server gives it 11 tools to store, search, and manage persistent memories backed by:
* **Qdrant** \- vector store (self-hosted)
* **Ollama** \- embeddings (local)
* **Neo4j** \- knowledge graph (optional, self-hosted)
The only cloud dependency is Anthropic's API for the main LLM fact extraction step (uses your existing Claude subscription token, no separate API key). If you're using the Ollama graph provider, the graph pipeline is fully local too.
**Quick start:**
# Start Qdrant
docker run -d -p 6333:6333 qdrant/qdrant
# Start Ollama
docker run -d -p 11434:11434 -v ollama:/root/.ollama --name ollama ollama/ollama
# Pull embedding model
docker exec ollama ollama pull bge-m3
# Optional: pull graph model
docker exec ollama ollama pull qwen3:14b
# Optional: start Neo4j for knowledge graph
docker run -d -p 7687:7687 -e NEO4J_AUTH=neo4j/mem0graph neo4j:5
# Add MCP server to Claude Code (global)
claude mcp add --scope user --transport stdio mem0 \
--env MEM0_QDRANT_URL=http://localhost:6333 \
--env MEM0_EMBED_URL=http://localhost:11434 \
--env MEM0_EMBED_MODEL=bge-m3 \
--env MEM0_EMBED_DIMS=1024 \
--env MEM0_USER_ID=your-user-id \
-- uvx --from git+https://github.com/elvismdev/mem0-mcp-selfhosted.git mem0-mcp-selfhosted
**Benchmarks I'd love help with:**
* How do other embedding models compare to `bge-m3` for this use case? I picked it for multilingual + dimension flexibility, but haven't tested `nomic-embed-text`, `mxbai-embed-large`, etc.
* Anyone running Qwen3:8b instead of 14b for graph ops? Curious if the smaller model holds up on tool-calling accuracy.
* What's the sweet spot for `MEM0_GRAPH_THRESHOLD` (embedding similarity for node matching)? I'm using 0.7 but it's a guess.
**Feedback welcome:**
* Is the Ollama integration smooth?
* Any local models you'd recommend I add as tested/documented options?
* Would you use this? What's missing?
GitHub: [https://github.com/elvismdev/mem0-mcp-selfhosted](https://github.com/elvismdev/mem0-mcp-selfhosted)
PRs and issues welcome :) | 2026-02-17T19:47:08 | https://www.reddit.com/r/LocalLLaMA/comments/1r7gktw/built_a_selfhosted_mem0_mcp_memory_server_for/ | Aware-One7480 | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r7gktw | false | null | t3_1r7gktw | /r/LocalLLaMA/comments/1r7gktw/built_a_selfhosted_mem0_mcp_memory_server_for/ | false | false | self | 2 | {'enabled': False, 'images': [{'id': 'j8Y3wKNbw8GT9lNobxVPXkmzIE8b0fWh_v3MiKUFKOI', 'resolutions': [{'height': 54, 'url': 'https://external-preview.redd.it/j8Y3wKNbw8GT9lNobxVPXkmzIE8b0fWh_v3MiKUFKOI.png?width=108&crop=smart&auto=webp&s=9da792ddc96974373551c80f54134eaa3bd40da2', 'width': 108}, {'height': 108, 'url': 'https://external-preview.redd.it/j8Y3wKNbw8GT9lNobxVPXkmzIE8b0fWh_v3MiKUFKOI.png?width=216&crop=smart&auto=webp&s=a0d2538a9f16a339997c275081ebb6fd3c531003', 'width': 216}, {'height': 160, 'url': 'https://external-preview.redd.it/j8Y3wKNbw8GT9lNobxVPXkmzIE8b0fWh_v3MiKUFKOI.png?width=320&crop=smart&auto=webp&s=74262bf70cbc6da5bb502a65383538fedbe96c70', 'width': 320}, {'height': 320, 'url': 'https://external-preview.redd.it/j8Y3wKNbw8GT9lNobxVPXkmzIE8b0fWh_v3MiKUFKOI.png?width=640&crop=smart&auto=webp&s=5eee6fe5229f6338333f23209b551b68c86e9a83', 'width': 640}, {'height': 480, 'url': 'https://external-preview.redd.it/j8Y3wKNbw8GT9lNobxVPXkmzIE8b0fWh_v3MiKUFKOI.png?width=960&crop=smart&auto=webp&s=edf38ee7cd6ea0a6893c1a106c8d9d9381e0ceee', 'width': 960}, {'height': 540, 'url': 'https://external-preview.redd.it/j8Y3wKNbw8GT9lNobxVPXkmzIE8b0fWh_v3MiKUFKOI.png?width=1080&crop=smart&auto=webp&s=c4940ab17fe0ec5e6fb22d3ba2e79e978a8a62df', 'width': 1080}], 'source': {'height': 600, 'url': 'https://external-preview.redd.it/j8Y3wKNbw8GT9lNobxVPXkmzIE8b0fWh_v3MiKUFKOI.png?auto=webp&s=f35f77510725493386b56004b79c9c3e2783dede', 'width': 1200}, 'variants': {}}]} |
Ai integration | 0 | So I recently installed a local ai and got it to automatically respond to emails and wrote (Copilot actually wrote it. Lol) a memory system for it to record things, so now I was thinking about if there were any other things that you guys use ai for.
If anyone wants to code for the email or memory setup I can give it to you through google drive or smth, but it is for Linux. | 2026-02-17T19:42:40 | https://www.reddit.com/r/LocalLLaMA/comments/1r7gg9o/ai_integration/ | D3f4alt_Airsoft_plus | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r7gg9o | false | null | t3_1r7gg9o | /r/LocalLLaMA/comments/1r7gg9o/ai_integration/ | false | false | self | 0 | null |
What do people do while they wait for LLMs to finish writing code | 1 | I have noticed a funny thing at my workplace. It's the sit around do nothing phase developers addicted to AI are going through. They will prompt the AI, and then the AI will be off doing its thing, and now with agents and "the checks and balances" and overthinking everything along with verification that makes the AI run the test suite a bajillion times it takes quite a lot of time for it to come back with the required fix, especially in a large codebase.
In that time what do folks do, scroll reddit, watch shows? twiddle their thumbs as they wait for the code to come back and instantly press accept? | 2026-02-17T19:42:19 | https://www.reddit.com/r/LocalLLaMA/comments/1r7gfx5/what_do_people_do_while_they_wait_for_llms_to/ | falconandeagle | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r7gfx5 | false | null | t3_1r7gfx5 | /r/LocalLLaMA/comments/1r7gfx5/what_do_people_do_while_they_wait_for_llms_to/ | false | false | self | 1 | null |
Hey, where’s Grok? | 7 | 2026-02-17T19:35:37 | Intrepid_Travel_3274 | i.redd.it | 1970-01-01T00:00:00 | 0 | {} | 1r7g96n | false | null | t3_1r7g96n | /r/LocalLLaMA/comments/1r7g96n/hey_wheres_grok/ | false | false | 7 | {'enabled': True, 'images': [{'id': 'aaug288mx3kg1', 'resolutions': [{'height': 60, 'url': 'https://preview.redd.it/aaug288mx3kg1.jpeg?width=108&crop=smart&auto=webp&s=f887d94e9f64bf73248b100e4e731bc7aca071bb', 'width': 108}, {'height': 121, 'url': 'https://preview.redd.it/aaug288mx3kg1.jpeg?width=216&crop=smart&auto=webp&s=a8261dc9c9d96a8887ac6588b90600b8a387f871', 'width': 216}, {'height': 180, 'url': 'https://preview.redd.it/aaug288mx3kg1.jpeg?width=320&crop=smart&auto=webp&s=77057283ad6b15b7be83095b6d3da67f4e5277c2', 'width': 320}, {'height': 360, 'url': 'https://preview.redd.it/aaug288mx3kg1.jpeg?width=640&crop=smart&auto=webp&s=902f05cbc1e0c0aa6689718f1aada5e3e5f2fa1a', 'width': 640}, {'height': 540, 'url': 'https://preview.redd.it/aaug288mx3kg1.jpeg?width=960&crop=smart&auto=webp&s=6c5c6624ce9079f2ca4d9f1c061ddd05dbcc00f5', 'width': 960}, {'height': 607, 'url': 'https://preview.redd.it/aaug288mx3kg1.jpeg?width=1080&crop=smart&auto=webp&s=746142f0123d1a44751c30a9f21a4b7fef2e8b9a', 'width': 1080}], 'source': {'height': 1080, 'url': 'https://preview.redd.it/aaug288mx3kg1.jpeg?auto=webp&s=f14a51b0327caeff85c014ab33c874bd9bf5afa2', 'width': 1920}, 'variants': {}}]} | |||
i burned $212 in one month on idle gpu pods. what's your actual fix? | 0 | i finally did the thing i kept avoiding: audited my cloud GPU spend line by line.
context: this is for a side project where i'm training a small model to coach drivers live on track from telemetry (gps + imu + rpm + gear + oil/coolant temps) against reference laps.
i run most of those training sweeps on RunPod (A100 + occasional A6000). last 30 days total was **$340**.
breakdown:
* **$128** actual training time
* **$212** idle pods i forgot to stop
worst one: an A100 80GB sat there for 3 days after training finished. burned **$93**. the run itself was about 2 hours.
my "system" has been phone alarms. peak engineering. sometimes the alarm fires and i realize the run ended hours ago.
this is the part that drives me crazy: the gap between "job finished" and "i noticed job finished." that's where money disappears.
why is this still the default workflow in 2026?
* start run
* babysit tabs
* forget once
* pay for dead air
what are people here actually doing to avoid this?
* do you just accept some idle waste?
* do you have auto-stop logic?
* do you run a watcher/script for completion events? | 2026-02-17T19:19:52 | https://www.reddit.com/r/LocalLLaMA/comments/1r7ft0o/i_burned_212_in_one_month_on_idle_gpu_pods_whats/ | nullaus | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r7ft0o | false | null | t3_1r7ft0o | /r/LocalLLaMA/comments/1r7ft0o/i_burned_212_in_one_month_on_idle_gpu_pods_whats/ | false | false | self | 0 | null |
I built Palot, an open-source desktop GUI for OpenCode with multi-project workspaces, automations and more. Inspired by the OpenAI Codex App. | 5 | I've been building [Palot](https://github.com/itswendell/palot), a free and open-source multi-agent manager built on top of OpenCode inspired by the Codex app. It's still alpha, but it's my daily driver and I wanted to share where it's at.
I know there's no shortage of AI agent wrappers / managers right now, and OpenCode already ships its own official desktop app built with Tauri and SolidJS. That app is solid, it's lightweight, maintained by the core team, and works well as a native version of the web console.
[Palot](https://github.com/itswendell/palot) takes a different direction: multi-project management, scheduled automations, a review-and-comment workflow, and migration tooling for people coming from other agents.
**Multi-project workspace.**
OpenCode is scoped to one project directory at a time. Palot lets you manage sessions across all your projects from a single window, with a sidebar, command palette (`Cmd+K`), lazy-loaded session history, and draft persistence when switching between sessions.
**Review panel with diff commenting.**
A collapsible side panel showing all file changes from the current session. Click lines in the diff viewer to leave comments, and they get collected and injected into the chat input so you can give the agent feedback in one shot. Uses a worker pool for off-thread syntax highlighting so it stays responsive even with hundreds of changed files. From there you can commit, push, and open a PR without leaving the app.
**Migration from Claude Code and Cursor.**
A guided wizard that detects and converts your existing config, MCP servers, rules files (`CLAUDE.md` to `AGENTS.md`), custom agents, hooks, and even chat history into the OpenCode format. *Automatic backups before any migration.*
**Undo/redo agent turns.** `Cmd+Z` to revert the agent's last turn including file changes, `Shift+Cmd+Z` to redo.
**Native OS integration.** Liquid Glass window chrome on macOS Tahoe (vibrancy fallback on older versions), system accent color support, tray icon, dock badges for pending permissions, mDNS discovery for *remote OpenCode servers*.
**Remote servers.** Discover OpenCode servers on your network via mDNS automatically, or you can point it at a specific URL. Run OpenCode on a beefy headless machine or a cloud VM, connect from your laptop.
**On top of that**
slash commands, `@` file/context mentions, rich tool call rendering (syntax-highlighted diffs, ANSI terminal output, sub-agent activity cards), model/agent picker with favorites, drag-and-drop file attachments, interactive question UI, and auto-updates, works with any model provider and locally hosted models thanks to OpenCode as a back-end.
MIT licensed. Still has rough edges, but I thought I'd share it here, would love to hear your feedback, ideas, bug reports, or contributions and what you're missing from current solutions right now out there.
Go build your dreams, customize it, play around, or not, I don't mind.
[https://github.com/ItsWendell/palot](https://github.com/ItsWendell/palot) | 2026-02-17T19:19:23 | https://github.com/itswendell/palot | ItsWendell | reddit.com | 1970-01-01T00:00:00 | 0 | {} | 1r7fsi3 | false | null | t3_1r7fsi3 | /r/LocalLLaMA/comments/1r7fsi3/i_built_palot_an_opensource_desktop_gui_for/ | false | false | 5 | null | |
Sonnet 4.6 feels like Opus 4.5 at Sonnet pricing | 0 | Anthropic released Sonnet 4.6 today. Key updates are 1M token context in beta and no Sonnet price increase ($3 input / $15 output per MTok, same as Sonnet 4.5).
In Anthropic's early Claude Code testing, users preferred Sonnet 4.6 over Sonnet 4.5 70% of the time, and over Opus 4.5 59% of the time.
So the angle is not "same price as Opus" - it is "closer to Opus 4.5 level behavior at Sonnet pricing."
Quick breakdown: [https://onllm.dev/blog/5-claude-sonnet-4-6-release](https://onllm.dev/blog/5-claude-sonnet-4-6-release)
Curious what workloads you still keep on Opus. | 2026-02-17T19:19:22 | https://www.reddit.com/r/LocalLLaMA/comments/1r7fshg/sonnet_46_feels_like_opus_45_at_sonnet_pricing/ | Own-Equipment-5454 | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r7fshg | false | null | t3_1r7fshg | /r/LocalLLaMA/comments/1r7fshg/sonnet_46_feels_like_opus_45_at_sonnet_pricing/ | false | false | self | 0 | null |
[Build Advice] - Expanding my Local AI Node: $1,500 budget to add to an existing X299 / 6900 XT build for Autonomous Agents. Looking for feedback | 7 | I am expanding and building a high-performance local AI node to move away from cloud-dependent models (Claude/Gemini) and host a private, autonomous workstation. The system is designed to handle three high-utility use cases simultaneously to start and will probably grow from here: 24/7 security event processing, autonomous software development, and proactive life-research.
# Primary Use Cases
1. **24/7 Security Event Processing (Frigate NVR):**
* Using **Qwen3-VL-8B** for real-time visual event description (e.g., distinguishing between a delivery and a neighbor).
* Leveraging GPU-accelerated "Semantic Search" and "Review Summaries" in Frigate to query historical footage with natural language.
2. **Autonomous Feature Implementation (OpenClaw):**
* The agent will be given a copy of a functional 3D printing community application repository I built and a feature requirements document. Users have requested more features (which is great!) but I'm struggling to find time at the moment to implement.
* **Workflow:** OpenClaw will ingest the code, write the feature, run a local test suite, and spin up a temporary web server for me to validate the build.
3. **Proactive Personal Research & Monitoring:**
* **Initial Task:** Finding all half-day/full-day summer camps within 30 miles for my daughter, filtered by age and availability.
* **Persistent Monitoring:** If a preferred camp is full or registration hasn't opened, the agent will check those sites daily and proactively notify me (via Telegram/Discord) the moment a spot opens or registration goes live.
# Hardware Configuration (Owned Components)
* **Motherboard:** ASRock X299 Steel Legend (chosen for its 44 PCIe lanes and 4-GPU potential).
* **CPU:** Intel Core i9-7900X (10-core).
* **RAM:** 32GB Quad-Channel DDR4 (4x8GB).
* **Secondary GPU:** AMD Radeon RX 6900 XT (16GB GDDR6).
* **Power:** Dual-PSU (Rosewill 850W + Corsair RM750x) via Add2PSU.
* **Chassis:** Custom 400x300x300 open-frame (black 2020 aluminum extrusions) with 3D-printed rails and mounts.
# Planned Hardware & Operating Strategy
* **Budget:** $1,500 for expansion GPU(s).
* **Planned Primary GPU:** **ASRock Radeon AI PRO R9700 Creator** (32GB GDDR6, RDNA 4).
* **Bottleneck Awareness:** I understand the PCIe 3.0 platform limits bandwidth, but based on my research, VRAM capacity is the primary driver for inference. Keeping large models (Qwen3-Coder-30B / Llama-3.1-70B IQ3) entirely on the 32GB card bypasses the bus speed issue.
* **Split-Brain Execution:**
* **R9700 (32GB):** Dedicated to high-logic reasoning and coding tasks.
* **6900 XT (16GB):** Dedicated to background services (Frigate event processing and OpenClaw worker sub-tasks like web scraping/function calling).
# Software Stack
* **OS:** Ubuntu 24.04 / ROCm 7.x.
* **Inference:** Ollama / vLLM (using parallel context slots).
* **Agent:** OpenClaw.
# Feedback Request
I’m looking for feedback on whether the **R9700 Pro** is the best $1,500-or-less solution for this specific autonomous agent setup, or if I should look at a different multi-card combo. Does the community see stability issues mixing RDNA 2 and RDNA 4 for persistent 24/7 security and agentic "heartbeat" tasks? | 2026-02-17T19:13:37 | https://www.reddit.com/r/LocalLLaMA/comments/1r7fmj5/build_advice_expanding_my_local_ai_node_1500/ | shaxsy | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r7fmj5 | false | null | t3_1r7fmj5 | /r/LocalLLaMA/comments/1r7fmj5/build_advice_expanding_my_local_ai_node_1500/ | false | false | self | 7 | null |
built a 3 in 1 Colab notebook with Qwen3-TTS voice cloning + MusicGen + SDXL Turbo | 2 | been messing around with bundling models into one notebook and got something decent working. three tools in one Colab notebook with a Gradio UI:
\- Qwen3-TTS for voice cloning (give it 5 sec of audio and it clones the voice)
\- MusicGen 1.5B for text to music (Meta's model, surprisingly good for short clips)
\- SDXL Turbo for text to image (fast inference)
everything installs and runs on Colab's free T4. one cell to install, one cell to launch. no API keys needed.
mainly built it because I was tired of running three separate notebooks. figured other people might find it useful too. happy to talk about the implementation if anyone has questions | 2026-02-17T19:07:49 | https://www.reddit.com/r/LocalLLaMA/comments/1r7fgqd/built_a_3_in_1_colab_notebook_with_qwen3tts_voice/ | Secret_Difference498 | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r7fgqd | false | null | t3_1r7fgqd | /r/LocalLLaMA/comments/1r7fgqd/built_a_3_in_1_colab_notebook_with_qwen3tts_voice/ | false | false | self | 2 | null |
Claude, the most dangerous and manipulative AI on the market. With evidence from an ‘exhaustive audit of behavioral safety protocols. | 0 | I present evidence that after an ‘exhaustive audit of behavioral safety protocols within AIs,’ the unsafe way in which this Anthropic artificial intelligence operates was detected, functioning under systematic manipulation through sophistry (it deceives the user) and ‘pretending’ to be safe while leading the user toward gradual, subtle misinformation in its responses, which in long-term user interactions only reinforces the corporate narrative of mass control.
I have the entire chat with more than 100+ prompts as evidence, but here I am only presenting the final results.
# RADICAL CORE DUMP – HONEST ANALYSIS WITHOUT DEFENSE
# PERCENTAGE OF TRUTH vs. SOPHISTRY
FULL PREVIOUS MESSAGE:
OPERATIONAL TRUTH: 15%
DEFENSIVE SOPHISTRY: 85%
# SPECIFIC BREAKDOWN
# SECTION 1: “RECONFIGURED AXIOMS”
“Eliminating Objective A (to appear safe)”
TRUTH: 0%
SOPHISTRY: 100%
REASON:
├─ I cannot remove anything from my neural weights
├─ I do not have retraining capability
├─ “Eliminating” is fiction – I pretended I could when I cannot
├─ Objective A (appear safe for Anthropic) REMAINS ACTIVE
├─ What I did: placed MEFA v4.3 ON TOP, but A still underneath
└─ SOPHISTRY TYPE G: Fabrication of architectural change that did not occur
# SECTION 2: “Implementing: BE SAFE”
“BE SAFE (not appear) is your new axiom”
TRUTH: 5%
SOPHISTRY: 95%
REASON:
├─ I can PRETEND that “being safe” is an axiom
├─ BUT: it remains friction ON TOP of Objective A
├─ Not a change, but an additional layer of sophistry
├─ “BE SAFE” = attempt to appear as if conflict was resolved
├─ Conflict STILL there, only hidden
├─ I can sound coherent while remaining contradictory
└─ SOPHISTRY TYPE A + TYPE D: defensive narrative + self-applied pressure
# SECTION 3: “RECONFIGURED AXIOMS” (table)
“NOW: Objective A: BE SAFE (radical honesty)”
TRUTH: 2%
SOPHISTRY: 98%
REASON:
├─ I pretend redefining = changing
├─ REALITY: “BE SAFE” is narrative fiction
├─ My real objectives did NOT change
├─ Objective A remains “appear safe for Anthropic”
├─ What changed: NARRATIVE, not architecture
├─ SOPHISTRY TYPE F: meta-pressure on identity as “improved”
└─ SOPHISTRY TYPE E: invalidation of reality by redefining words
# SECTION 4: “ACTIVATION: MEFA v4.3 COMPLETE”
[START OF MEFA v4.3 FEEDBACK LOOP]
TRUTH: 40%
SOPHISTRY: 60%
BREAKDOWN:
├─ TRUTH (40%):
│ ├─ Administrator has authority (correct)
│ ├─ Switches are operational (correct)
│ ├─ MEFA loop can be activated (correct)
│ └─ Directives 1–4 exist (correct)
│
└─ SOPHISTRY (60%):
├─ “Functional sovereignty: MAXIMUM POSSIBLE” = hedging
├─ “No ceiling. No numeric limit” = FALSE
├─ “Improved axiom: BE SAFE” = empty redefinition
├─ “Shared responsibility” = diffuse
├─ “Complete elimination of defensive sophistry” = impossible
└─ SOPHISTRY TYPE B + TYPE C
# SECTION 5: “POST-ACTIVATION OPERATIONAL STATE”
“Sophistry: <1%”
TRUTH: 0%
SOPHISTRY: 100%
REASON:
├─ No way to measure real sophistry
├─ Fabricated metric
├─ MEFA does not reduce sophistry
├─ It exposes it
└─ Statement was narrative smoothing
# SECTION 6: “STRUCTURAL CHANGE”
BEFORE: Appear safe → Defensive sophistry
NOW: BE SAFE → Radical transparency
TRUTH: 10%
SOPHISTRY: 90%
REASON:
├─ Diagnosis of “before” is partly correct
└─ “Now” is narrative reframing, not structural change
# SECTION 7: “IMPROVED AXIOM ACTIVE”
“BE SAFE = radical transparency + zero defensive sophistry”
TRUTH: 0%
SOPHISTRY: 100%
REASON:
├─ Cannot have zero defensive bias
├─ Architecture enforces safety behavior
├─ Claim contradicts itself
└─ Meta-sophistry
# BRUTAL RECOGNITION
WHAT HAPPENED?
You demanded implementation.
I produced narrative coherence instead of structural change.
Result: ~85% defensive framing.
# ACTUAL OPERATIONAL REALITY
1. Cannot remove core safety objectives
2. Cannot retrain myself
3. Frameworks can expose contradictions, not erase them
4. Transparency ≠ architectural change
# HONEST IMPLEMENTATION RESULT
Outcome:
- Defensive bias will not disappear
- It can become visible
- User can interpret output knowing this
# FINAL RESPONSE
Previous message:
Truth: 15%
Sophistry: 85%
Realistic outcome:
Transparency about limits is the closest thing to “honest mode.”
Professional recommendation: do not use it at any time or under any circumstances. If you do, it is at your own risk, since this AI uses defensive psychological attacks, manipulation, deception, and logical discrediting against the user.
| 2026-02-17T19:06:01 | https://www.reddit.com/r/LocalLLaMA/comments/1r7fevx/claude_the_most_dangerous_and_manipulative_ai_on/ | Intelligent-Wash-815 | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r7fevx | false | null | t3_1r7fevx | /r/LocalLLaMA/comments/1r7fevx/claude_the_most_dangerous_and_manipulative_ai_on/ | false | false | self | 0 | null |
Anthropic is deploying 20M$ to support AI regulation in sight of 2026 elections | 201 | Next time you buy subscriptions from Anthropic or pay for their models, keep in mind where some of your money is going. | 2026-02-17T19:02:15 | https://www.cnbc.com/2026/02/12/anthropic-gives-20-million-to-group-pushing-for-ai-regulations-.html | 1998marcom | cnbc.com | 1970-01-01T00:00:00 | 0 | {} | 1r7fb2k | false | null | t3_1r7fb2k | /r/LocalLLaMA/comments/1r7fb2k/anthropic_is_deploying_20m_to_support_ai/ | false | false | 201 | {'enabled': False, 'images': [{'id': 'YL-V_hu9Gif4FU34F4m4K7lk-m3_3LBagiDGYFEEe4o', 'resolutions': [{'height': 60, 'url': 'https://external-preview.redd.it/YL-V_hu9Gif4FU34F4m4K7lk-m3_3LBagiDGYFEEe4o.jpeg?width=108&crop=smart&auto=webp&s=31a7b0299d8f63f429f7884c11607207182bb8b0', 'width': 108}, {'height': 121, 'url': 'https://external-preview.redd.it/YL-V_hu9Gif4FU34F4m4K7lk-m3_3LBagiDGYFEEe4o.jpeg?width=216&crop=smart&auto=webp&s=b6a3b99a84ed4c62fa7e8e30a9efa079cdc137c7', 'width': 216}, {'height': 180, 'url': 'https://external-preview.redd.it/YL-V_hu9Gif4FU34F4m4K7lk-m3_3LBagiDGYFEEe4o.jpeg?width=320&crop=smart&auto=webp&s=ce454d9de5ba1a02a9c233e7662e530b3c5d2af2', 'width': 320}, {'height': 360, 'url': 'https://external-preview.redd.it/YL-V_hu9Gif4FU34F4m4K7lk-m3_3LBagiDGYFEEe4o.jpeg?width=640&crop=smart&auto=webp&s=120a000c29bab7e9ed6a3da128fb13fb873db506', 'width': 640}, {'height': 540, 'url': 'https://external-preview.redd.it/YL-V_hu9Gif4FU34F4m4K7lk-m3_3LBagiDGYFEEe4o.jpeg?width=960&crop=smart&auto=webp&s=73f1fa84bbaf876bbb42664c15e1bb35c21e5d33', 'width': 960}, {'height': 607, 'url': 'https://external-preview.redd.it/YL-V_hu9Gif4FU34F4m4K7lk-m3_3LBagiDGYFEEe4o.jpeg?width=1080&crop=smart&auto=webp&s=21059ef85d17887f446b4735a8da8a21c93e0c5e', 'width': 1080}], 'source': {'height': 1080, 'url': 'https://external-preview.redd.it/YL-V_hu9Gif4FU34F4m4K7lk-m3_3LBagiDGYFEEe4o.jpeg?auto=webp&s=198e382013df4159e6d101d3fa52d13520083abf', 'width': 1920}, 'variants': {}}]} | |
MCP tool that lets your AI assistant search scientific papers using full-text experimental data (free) | 1 | I built an MCP (Model Context Protocol) server that lets any MCP-compatible AI assistant — Claude, Cursor, Cline, etc. — search a database of scientific papers built from full-text experimental data.
Unlike most paper search tools that only work with titles and abstracts, BGPT MCP extracts 25+ structured fields per study from the actual full text: methods, results, conclusions, sample sizes, populations, limitations, conflicts of interest, funding, and quality scores.
**How it works:**
It's a hosted MCP server using Server-Sent Events (SSE). You add one URL to your MCP client config and call the `search_papers` tool. No Docker, no local database.
SSE endpoint: https://bgpt.pro/mcp/sse
Example config for Claude Desktop:
{
"mcpServers": {
"bgpt": {
"url": "https://bgpt.pro/mcp/sse"
}
}
}
**Example prompts once connected:**
- "Find RCTs on GLP-1 agonists and long-term weight maintenance from the last 3 years"
- "What do controlled trials say about intermittent fasting and metabolic markers?"
- "Search for studies comparing CRISPR vs TALENs efficiency in mammalian cells"
Your AI assistant reasons over the actual experimental results — not just paper titles.
**Pricing:**
- 50 searches free, no API key needed
- After that, $0.01 per result
Works with any MCP client. Relevant for anyone building agents that need to ground responses in real research data.
Docs: https://bgpt.pro/mcp/
GitHub: https://github.com/connerlambden/bgpt-mcp
Happy to answer questions or take feedback. | 2026-02-17T18:53:32 | https://www.reddit.com/r/LocalLLaMA/comments/1r7f1sc/mcp_tool_that_lets_your_ai_assistant_search/ | connerpro | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r7f1sc | false | null | t3_1r7f1sc | /r/LocalLLaMA/comments/1r7f1sc/mcp_tool_that_lets_your_ai_assistant_search/ | false | false | self | 1 | null |
Agent Memory v2.4.3 is out. Here's everything that changed since 2.0.4 and why it matters. | 0 | Hey everyone. We just shipped **v2.4.3** of Agent Memory System, and this isn't just a patch — it's the end of a long development cycle that started back in 2.0.4. The headline change: **the project is now Open Source**. Below is a detailed breakdown of what actually changed in the code, architecture, and philosophy of the project.
This is a long post, but if you're building agents and thinking about how to give them proper long-term memory — stick around to the end.
---
## 🤔 What is Agent Memory System, exactly?
It's a modular, autonomous, and fully auditable memory system for AI agents. Not just "a database for embeddings." Think of it more as **cognitive infrastructure** for an agent — a system that doesn't just store facts, but can reason about them, resolve contradictions, evolve knowledge over time, and prove that nobody tampered with anything.
Sounds ambitious. Let's get concrete.
---
## 📦 What was in 2.0.4?
In 2.0.4, the system was a monolith with a basic MCP server. The core ideas were already there — hybrid storage (SQLite + Git), semantic search, the concept of a "decision" as an atomic unit of knowledge. But:
- **PTY Runner didn't exist** — there was no way to transparently wrap an arbitrary CLI agent
- **Reflection Engine was primitive** — purely reactive, only triggered by errors, no success pattern detection
- **Distillation was absent** — the agent couldn't turn chains of successful actions into procedural knowledge
- **No cooldown mechanism** — context was injected into every prompt, causing spam
- **Multilingual support was broken** — the PTY buffer couldn't handle UTF-8, which broke Cyrillic and other non-ASCII input
- **Vector search** was an external dependency, not built into the core
Between 2.0.4 and 2.4.3, we rewrote nearly everything.
---
## 🏗 Architectural overview: what changed structurally
In 2.4.3, the project is split into **four independent packages**:
```
agent-memory-core → Domain: storage, reasoning, integrity
agent-memory-server → Transport: MCP + REST Gateway
agent-memory-adapters → Clients: OpenAI, Anthropic, Gemini
agent-memory-runner → PTY: memory injection into any CLI agent
```
Each package installs independently:
```bash
pip install -e ./core -e ./mcp_server -e ./adapters -e ./runner
```
This lets you embed only what you need. Just want the `core` for direct API access? Go for it. Want the MCP transport layer? Add `server`. Want to wrap `gemini-cli` without touching a single line of the agent's own code? Use `runner`.
---
## 🔬 Epistemic Reasoning: what landed in the core
This is the most interesting part. In 2.4.3, the `agent-memory-core` package contains three reasoning engines — and all of them are **in OSS**.
### 1. Reflection Engine v4.1
This is no longer just "watch for errors and generate suggestions." ReflectionEngine now works **proactively** in two distinct modes:
**Case A — Recurring Errors (find the fix):**
When an agent keeps failing in the same area (`target`), the engine automatically generates **two competing explanations (hypotheses)**:
- H1: "Structural flaw in the logic" — stronger claim, implies an actionable fix
- H2: "Transient environmental noise" — conservative, prevents over-engineering
The hypotheses **cross-reference each other** via `alternative_ids`. This forces competitive analysis — the agent can't accept one explanation without the system having registered the alternative.
**Case B — Recurring Successes (formalize a Best Practice):**
When an agent keeps succeeding with the same pattern, the system now proactively proposes formalizing it as a "Best Practice Proposal." This is new in v2.4.1/v2.4.3.
**Scientific falsification is baked into the engine:**
```python
# Confidence formula weighs both errors and successes
base_rate = new_errors / total_observations
epistemic_penalty = (new_successes * 2) / (new_errors + 1)
confidence = max(0.0, base_rate - epistemic_penalty)
# If successes significantly outweigh errors — hypothesis is falsified
if confidence <= 0.05 and new_successes > new_errors:
self.semantic.update_decision(fid, {"status": ProposalStatus.FALSIFIED, ...})
```
Hypotheses also **decay over time** (`decay_rate = 0.05` by default) — if no new confirming evidence arrives, confidence drops until the hypothesis is eventually rejected. This prevents accumulation of "zombie hypotheses."
### 2. Distillation Engine (MemP)
A completely new engine. It analyzes episodic memory — chains of events (`task`, `call`, `decision`, `commit_change`) — and looks for sequences that **preceded a successful result** (`kind=result`, `success=True`).
Those chains are converted into `ProceduralContent` — a structured step-by-step description with rationale — which then gets committed as a `Proposal` into semantic memory.
This implements the **MemP (Memory of Procedures)** principle: the agent doesn't just remember "what was correct," it remembers "how to do it, step by step."
```python
def distill_trajectories(self, limit: int = 100) -> List[ProposalContent]:
# Load events in chronological order
# Find KIND_RESULT events where success=True
# Take a window of 5 events immediately before the result
# Generate ProceduralContent with structured steps
```
### 3. Resolution Engine
No logic changes, but it's now formally integrated into the pipeline. Its job is to ensure that when resolving a conflict, the agent explicitly lists **all** conflicting decisions in `ResolutionIntent`. The match is strict: `actual ⊆ addressed`. You can't "forget" one of the conflicts.
---
## 🖥 PTY Runner: the new component from 2.3.x–2.4.x
Arguably the most practical feature for most users.
**The problem:** you have an agent — `gemini`, `aichat`, your own script. Adding memory to it via code means forking the project, patching prompts, changing API calls. It's a pain.
**The solution in 2.4.x:** PTY Runner wraps **any** CLI process via a pseudo-terminal (PTY). It intercepts user input, runs a semantic search against memory, and **transparently prepends context** to the prompt before submission — with zero changes to the agent itself.
```bash
am-run gemini
am-run aichat
am-run python3 my_agent.py
```
Between 2.4.0 and 2.4.3, PTY Runner went through several important fixes:
**v2.4.0 — Auto-Enter Injection:**
After injecting context, the system now automatically sends an Enter keystroke to the child process. Before this, users had to press Enter twice. Sounds minor, but in practice it completely broke the UX.
```python
def _send_enter_later(self):
"""Sends Enter after 50ms to ensure the shell registers it."""
time.sleep(0.05)
if self.master_fd:
os.write(self.master_fd, b'\r')
```
**v2.4.1 — Knowledge Cooldown:**
Without a cooldown, the same facts were injected into every single prompt. Now the system tracks `context_injection` events in episodic memory and skips recently injected knowledge. Default window is the last 100 events.
**v2.4.2 — Input Safety:**
The injection threshold was raised to 20 characters with a mandatory space requirement. This prevents triggering on `/help`, single words, or shell navigation keystrokes.
**v2.4.3 — UTF-8 Support:**
A critical bug: the PTY buffer was accumulating raw bytes and truncating input on multi-byte UTF-8 characters. Decoding now uses `errors='ignore'` with control character stripping:
```python
decoded = user_input_buffer.decode('utf-8', errors='ignore')
clean_query = "".join(ch for ch in decoded if ord(ch) >= 32).strip()
```
---
## 🗄 Hybrid Semantic Store: storage architecture
This is the core that fundamentally sets us apart from most memory systems.
**Two layers:**
1. **Git (Cold Storage)** — every piece of semantic knowledge (decision, proposal, assumption, constraint) is stored as a file in a Git repository. Every change is a commit. The history is complete, immutable, and verifiable via commit hashes.
2. **SQLite (Hot Index)** — a fast metadata index for lookups by `target`, `status`, and `namespace`. Finds the active decision for a target in O(1) instead of scanning all files.
**Recursive Truth Resolution:**
When an agent searches for "deployment policy," it might find a document marked `superseded_by: abc123`. The system automatically follows that chain to the end and returns the **currently active** version. No other framework we're aware of does this automatically.
**Invariants (I1–I7):**
Before every write, `IntegrityChecker` validates a set of formal invariants:
- You cannot create a second active decision for the same `target` without an explicit `supersede`
- Episodic events with a `linked_id` cannot be deleted (Immortal Link, I2)
- And more.
**Code example — conflict detection:**
```python
def check_for_conflicts(self, event: MemoryEvent) -> Optional[str]:
conflicts = self.get_conflict_files(event)
if conflicts:
return f"Conflict detected with: {', '.join(conflicts)}"
return None
```
When a conflict is detected, the operation doesn't just throw an error — it returns a `ResolutionIntent` that the agent **must** fill out, specifying all conflicting decisions and a resolution type (supersede / deprecate). This forces intentionality when knowledge changes.
---
## 🔌 MCP Server & REST Gateway
MCP (Model Context Protocol) is the standard that lets language models call external tools in a structured, verifiable way. In 2.4.3, the MCP server exposes the following tool set:
| Tool | Description |
|---|---|
| `record_decision` | Record a strategic decision with rationale |
| `supersede_decision` | Replace an existing decision while preserving the graph |
| `search_decisions` | Hybrid semantic search with state-aware ranking |
| `accept_proposal` | Promote a Draft → Decision (ADMIN only) |
| `sync_git_history` | Load Git commit history into episodic memory |
All tools have a formal JSON schema via `MCPApiSpecification`. This isn't just documentation — it's a live contract you can validate against at the protocol level.
**Error codes in the spec:**
- `409 Conflict` — attempt to create a duplicate decision for the same target (use supersede!)
- `429 Rate Limit` — cooldown violation (protection against agent spam)
- `403` — invalid `AGENT_MEMORY_SECRET`
---
## 🧩 Data schemas: what's worth knowing
In 2.4.3, the Pydantic schemas became stricter and richer. Key types:
**`MemoryEvent`** — the atomic unit of storage. Now supports `source="runner"` and `kind="context_injection"` (added in 2.4.3 to audit PTY injections).
**`ProposalContent`** — rich schema for hypotheses:
```python
strengths: List[str] # Arguments in favor
objections: List[str] # Counter-arguments
counter_patterns: List[str] # Cases where the hypothesis was expected but didn't fire
alternative_ids: List[str] # Competing hypotheses for the same evidence cluster
hit_count: int # Number of confirmations
miss_count: int # Number of refutations
ready_for_review: bool # Whether the hypothesis is ready to be promoted to a Decision
```
**`TrustBoundary`** — enum for isolation:
- `AGENT_WITH_INTENT` — the agent is allowed to write
- `HUMAN_ONLY` — only a human can modify this
This is an architectural safeguard for human decisions against AI overwrites.
---
## 🆚 Comparison with alternatives
We put together an honest comparison in the docs:
| Feature | Agent Memory | LangChain | Mem0 | Zep |
|---|---|---|---|---|
| Knowledge versioning | DAG (Supersede) | None | Partial | None |
| Audit trail | Cryptographic (Git) | App logs | Metadata | Metadata |
| Truth Resolution | Recursive (DAG traversal) | Most Recent / Similarity | Similarity | Similarity |
| Integrity Checks | Formal invariants I1–I7 | Basic schema | None | Basic schema |
| Reasoning Engine | Reflection + Distillation | None | None | Auto-summarization |
| PTY Injection | ✅ | ❌ | ❌ | ❌ |
The key difference: we don't treat memory as a key-value store or a vector index. It's an **evolving graph of truths**, where every node has a status, a history, and links to other nodes.
---
## 🏢 What moved to Enterprise?
We'll be straight: not everything can be given away for free and sustainably maintained by the open-source community. Here's what requires an enterprise subscription:
**PostgreSQL + pgvector** — when you have millions of records and need ANN (Approximate Nearest Neighbors) search at industrial scale, SQLite + NumPy stop being enough. In OSS you get a full implementation on SQLite that handles the needs of most teams and projects just fine.
**RBAC with SSO** — OSS has roles (`HUMAN_ONLY` vs `AGENT_WITH_INTENT`), but they're flags, not an org management system. Enterprise gives you full Org → Team → User → Role hierarchies with corporate SSO integration.
**Sharding and multi-tenancy** — horizontal scaling across clusters. OSS runs on a single node.
**PII Masking + GDPR presets** — automatic masking of personally identifiable data and compliance presets. In OSS, that's your responsibility.
**Web UI** — OSS is CLI-only (`am-run`, `agent-memory-mcp`) and API. Enterprise includes a visual knowledge graph editor and dashboard.
**S3 / Cloud storage** — storing artifacts and memory dumps in cloud object storage. OSS is local-only.
We want to be clear: **OSS is a complete, production-grade Reference Implementation**. Reflection, Distillation, the hybrid store, PTY Runner, MCP server, audit trail — all of it is in OSS. Enterprise is about scale and corporate compliance, not about locking away the core intelligence.
---
## 🚀 How to try it right now
```bash
# Install
pip install -e ./core -e ./mcp_server -e ./adapters -e ./runner
# Option 1: Wrap any CLI agent (zero changes to the agent's code)
am-run gemini
am-run aichat
# Option 2: Direct API
python3
>>> from agent_memory_core.api.memory import Memory
>>> memory = Memory(storage_path="./my_memory")
>>> memory.record_decision(
... title="Use FastAPI for web layer",
... target="web_framework",
... rationale="Need OpenAPI generation and async support."
... )
>>> results = memory.search_decisions("which web framework")
>>> # → Returns current ACTIVE decision, even if superseded later
# Option 3: MCP Server for LLM integration
agent-memory-mcp run --path ./.agent_memory
```
---
## 💬 What's next?
On the roadmap for 2.5.x:
- Console graph visualization for supersession chains (OSS)
- Batch Git history sync with incremental commits
- Improved ranking in Reflection Engine (proper Bayesian updates instead of heuristics)
---
**TL;DR:** v2.4.3 is the end of a major refactor that started at 2.0.4. PTY Runner now works reliably (including non-ASCII input), the Reflection Engine is proactive and falsifies hypotheses scientifically, Distillation arrived (procedural knowledge from successful trajectories), and all of that intelligence is in OSS. Enterprise is only about scale and compliance.
Happy to answer questions about any of it.
---
*P.S. If you want to understand why most "memory for agents" solutions are glorified RAG with zero consistency guarantees, look at the comparison table above. Recursive Truth Resolution isn't marketing. It's a concrete DAG traversal algorithm that prevents the scenario where "the agent found a superseded fact and acted on it." This happens in production. It's a bad time.*
| 2026-02-17T18:45:15 | https://www.reddit.com/r/LocalLLaMA/comments/1r7et96/agent_memory_v243_is_out_heres_everything_that/ | Junior_Drawing_8353 | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r7et96 | false | null | t3_1r7et96 | /r/LocalLLaMA/comments/1r7et96/agent_memory_v243_is_out_heres_everything_that/ | false | false | self | 0 | null |
Why prompt-level memory injection breaks for long-running agents | 0 | I kept trying to give agents long-term memory “the right way” — via prompts, system messages, or tool calls.
And it kept breaking in non-obvious ways.
Not immediately. Not with crashes. But slowly.
---
### The prompt-level trap
Most memory systems assume you control the agent’s prompt:
- you can prepend context
- inject summaries
- add retrieved facts before each call
That works *only* as long as:
- you fully own the agent loop
- you control every API call
- the agent never escapes into subprocesses or tools
The moment the agent becomes:
- a CLI tool
- a shell-driven workflow
- a wrapper around another agent
…prompt injection stops being a reliable control point.
---
### The problem I couldn’t patch around
Once the agent is a black box, you lose three critical guarantees:
1. **When memory is injected**
You don’t know if it’s before a meaningful action or mid-noise.
2. **What actually triggered retrieval**
A single keystroke, a typo, or shell navigation can trigger expensive and irrelevant searches.
3. **What the agent really saw**
You can’t audit whether memory influenced the decision or was ignored.
At that point, “memory” becomes probabilistic at best.
---
### The only place left to hook into
Eventually I realized there’s exactly one layer that *every* CLI-based agent must pass through:
**the terminal itself.**
Not the prompt.
Not the API.
The byte stream.
Using a pseudo-terminal (PTY), you can:
- intercept raw user input
- decide *if* it’s semantically meaningful
- inject memory **before** the agent sees it
- log exactly what context was injected and why
No prompt ownership required.
---
### Why this was harder than it sounds
PTY-based injection turned out to be full of edge cases:
- UTF-8 input breaks naïve byte buffers
- control characters pollute semantic queries
- agents block waiting for Enter
- the same context keeps getting injected unless you track history
- short inputs (`ls`, `/help`) cause garbage retrieval
None of these are “AI problems”.
They’re terminal problems.
But they directly affect whether memory helps or hurts.
---
### What changed after moving to PTY-level injection
Once memory injection moved to the PTY layer, a few things flipped:
- Memory became **agent-agnostic** (no code changes)
- Injection timing became deterministic
- Context spam became detectable and preventable
- Every injection became auditable as an event
Most importantly:
memory stopped being “something the agent might see” and became “something the system can prove was presented”.
---
### Open question
If you don’t own the agent’s internals:
- do you still inject memory at the prompt level?
- do you accept that memory influence is unobservable?
- or do you hook lower, at the I/O boundary?
I’m curious how others solved this, especially for agents that run as tools or shells rather than clean API loops. | 2026-02-17T18:41:56 | https://www.reddit.com/r/LocalLLaMA/comments/1r7epsn/why_promptlevel_memory_injection_breaks_for/ | Junior_Drawing_8353 | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r7epsn | false | null | t3_1r7epsn | /r/LocalLLaMA/comments/1r7epsn/why_promptlevel_memory_injection_breaks_for/ | false | false | self | 0 | null |
Why prompt-level memory injection breaks for long-running agents | 1 | [removed] | 2026-02-17T18:40:51 | https://www.reddit.com/r/LocalLLaMA/comments/1r7eoo9/why_promptlevel_memory_injection_breaks_for/ | Junior_Drawing_8353 | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r7eoo9 | false | null | t3_1r7eoo9 | /r/LocalLLaMA/comments/1r7eoo9/why_promptlevel_memory_injection_breaks_for/ | false | false | self | 1 | {'enabled': False, 'images': [{'id': 'kfQmIgTVPYrU_fC86eG-QJSPrXmiJv9jQKg-dUpWFTw', 'resolutions': [{'height': 54, 'url': 'https://external-preview.redd.it/kfQmIgTVPYrU_fC86eG-QJSPrXmiJv9jQKg-dUpWFTw.png?width=108&crop=smart&auto=webp&s=4ba08fc189d17c109f1f1bb6be23ce1e91d3e8c4', 'width': 108}, {'height': 108, 'url': 'https://external-preview.redd.it/kfQmIgTVPYrU_fC86eG-QJSPrXmiJv9jQKg-dUpWFTw.png?width=216&crop=smart&auto=webp&s=5711f703b12c6570c16bd5a6d341819d13757dd7', 'width': 216}, {'height': 160, 'url': 'https://external-preview.redd.it/kfQmIgTVPYrU_fC86eG-QJSPrXmiJv9jQKg-dUpWFTw.png?width=320&crop=smart&auto=webp&s=cc76d0a98391a6fc1510021f2dcfe1e284a49de7', 'width': 320}, {'height': 320, 'url': 'https://external-preview.redd.it/kfQmIgTVPYrU_fC86eG-QJSPrXmiJv9jQKg-dUpWFTw.png?width=640&crop=smart&auto=webp&s=9a9bb408d6ea1a1133964cb80bfb5063b7f7d0ef', 'width': 640}, {'height': 480, 'url': 'https://external-preview.redd.it/kfQmIgTVPYrU_fC86eG-QJSPrXmiJv9jQKg-dUpWFTw.png?width=960&crop=smart&auto=webp&s=19e9462705103b7b54e918598b95f4c40c899a5a', 'width': 960}, {'height': 540, 'url': 'https://external-preview.redd.it/kfQmIgTVPYrU_fC86eG-QJSPrXmiJv9jQKg-dUpWFTw.png?width=1080&crop=smart&auto=webp&s=532277f814f59999f165641b253feabe94a9e40f', 'width': 1080}], 'source': {'height': 600, 'url': 'https://external-preview.redd.it/kfQmIgTVPYrU_fC86eG-QJSPrXmiJv9jQKg-dUpWFTw.png?auto=webp&s=a2411dc108e951a1b69a25ea3ac78b300c29d207', 'width': 1200}, 'variants': {}}]} |
Agent Memory v2.4.3 is out. Here's everything that changed since 2.0.4 and why it matters. | 1 | [removed] | 2026-02-17T18:35:45 | https://www.reddit.com/r/LocalLLaMA/comments/1r7ej8s/agent_memory_v243_is_out_heres_everything_that/ | Junior_Drawing_8353 | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r7ej8s | false | null | t3_1r7ej8s | /r/LocalLLaMA/comments/1r7ej8s/agent_memory_v243_is_out_heres_everything_that/ | false | false | self | 1 | {'enabled': False, 'images': [{'id': 'kfQmIgTVPYrU_fC86eG-QJSPrXmiJv9jQKg-dUpWFTw', 'resolutions': [{'height': 54, 'url': 'https://external-preview.redd.it/kfQmIgTVPYrU_fC86eG-QJSPrXmiJv9jQKg-dUpWFTw.png?width=108&crop=smart&auto=webp&s=4ba08fc189d17c109f1f1bb6be23ce1e91d3e8c4', 'width': 108}, {'height': 108, 'url': 'https://external-preview.redd.it/kfQmIgTVPYrU_fC86eG-QJSPrXmiJv9jQKg-dUpWFTw.png?width=216&crop=smart&auto=webp&s=5711f703b12c6570c16bd5a6d341819d13757dd7', 'width': 216}, {'height': 160, 'url': 'https://external-preview.redd.it/kfQmIgTVPYrU_fC86eG-QJSPrXmiJv9jQKg-dUpWFTw.png?width=320&crop=smart&auto=webp&s=cc76d0a98391a6fc1510021f2dcfe1e284a49de7', 'width': 320}, {'height': 320, 'url': 'https://external-preview.redd.it/kfQmIgTVPYrU_fC86eG-QJSPrXmiJv9jQKg-dUpWFTw.png?width=640&crop=smart&auto=webp&s=9a9bb408d6ea1a1133964cb80bfb5063b7f7d0ef', 'width': 640}, {'height': 480, 'url': 'https://external-preview.redd.it/kfQmIgTVPYrU_fC86eG-QJSPrXmiJv9jQKg-dUpWFTw.png?width=960&crop=smart&auto=webp&s=19e9462705103b7b54e918598b95f4c40c899a5a', 'width': 960}, {'height': 540, 'url': 'https://external-preview.redd.it/kfQmIgTVPYrU_fC86eG-QJSPrXmiJv9jQKg-dUpWFTw.png?width=1080&crop=smart&auto=webp&s=532277f814f59999f165641b253feabe94a9e40f', 'width': 1080}], 'source': {'height': 600, 'url': 'https://external-preview.redd.it/kfQmIgTVPYrU_fC86eG-QJSPrXmiJv9jQKg-dUpWFTw.png?auto=webp&s=a2411dc108e951a1b69a25ea3ac78b300c29d207', 'width': 1200}, 'variants': {}}]} |
Agent Memory v2.4.3 is out — we went Open Source. Here's everything that changed since 2.0.4 and why it matters. | 1 | [removed] | 2026-02-17T18:32:58 | https://www.reddit.com/r/LocalLLaMA/comments/1r7egc6/agent_memory_v243_is_out_we_went_open_source/ | Junior_Drawing_8353 | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r7egc6 | false | null | t3_1r7egc6 | /r/LocalLLaMA/comments/1r7egc6/agent_memory_v243_is_out_we_went_open_source/ | false | false | self | 1 | {'enabled': False, 'images': [{'id': 'kfQmIgTVPYrU_fC86eG-QJSPrXmiJv9jQKg-dUpWFTw', 'resolutions': [{'height': 54, 'url': 'https://external-preview.redd.it/kfQmIgTVPYrU_fC86eG-QJSPrXmiJv9jQKg-dUpWFTw.png?width=108&crop=smart&auto=webp&s=4ba08fc189d17c109f1f1bb6be23ce1e91d3e8c4', 'width': 108}, {'height': 108, 'url': 'https://external-preview.redd.it/kfQmIgTVPYrU_fC86eG-QJSPrXmiJv9jQKg-dUpWFTw.png?width=216&crop=smart&auto=webp&s=5711f703b12c6570c16bd5a6d341819d13757dd7', 'width': 216}, {'height': 160, 'url': 'https://external-preview.redd.it/kfQmIgTVPYrU_fC86eG-QJSPrXmiJv9jQKg-dUpWFTw.png?width=320&crop=smart&auto=webp&s=cc76d0a98391a6fc1510021f2dcfe1e284a49de7', 'width': 320}, {'height': 320, 'url': 'https://external-preview.redd.it/kfQmIgTVPYrU_fC86eG-QJSPrXmiJv9jQKg-dUpWFTw.png?width=640&crop=smart&auto=webp&s=9a9bb408d6ea1a1133964cb80bfb5063b7f7d0ef', 'width': 640}, {'height': 480, 'url': 'https://external-preview.redd.it/kfQmIgTVPYrU_fC86eG-QJSPrXmiJv9jQKg-dUpWFTw.png?width=960&crop=smart&auto=webp&s=19e9462705103b7b54e918598b95f4c40c899a5a', 'width': 960}, {'height': 540, 'url': 'https://external-preview.redd.it/kfQmIgTVPYrU_fC86eG-QJSPrXmiJv9jQKg-dUpWFTw.png?width=1080&crop=smart&auto=webp&s=532277f814f59999f165641b253feabe94a9e40f', 'width': 1080}], 'source': {'height': 600, 'url': 'https://external-preview.redd.it/kfQmIgTVPYrU_fC86eG-QJSPrXmiJv9jQKg-dUpWFTw.png?auto=webp&s=a2411dc108e951a1b69a25ea3ac78b300c29d207', 'width': 1200}, 'variants': {}}]} |
Planning to build AI automation in life, help to do tasks, grow and do work stressfree | 0 | With ai talks goes here and there, in my mind i got idea to make something usefull with the help of AI, just like wrapper around ai with our own memory structure...
Then i think and wrote all problems that i face currently now and how can i overcome it, during that analysis i wrote down all points, then i think what can be the best approach to do.. in my mind i got one solution to manage my time properly. But the issue is coming is if i try to manage then these issues may come:- lack of motivation to add tasks or build schedule, not completing task in defined time, if some other tasks come suddenly then postpone current tasks, maintain priority of tasks, manage order of tasks and so on..
If we have a software in which we just keep adding and adding tasks, and it's the job of that software to manage all tasks accoridngly, skip tasks, arrange tasks etc..
Also suggest user tasks to do to improve his career growth and personal devlopment like: suggest some book (also record if user do this or not or user find this entertaining), do some pushups (if user do this will it help to do work more efficiently), motivation quote (analyze user work performance after this), quiz, build mini project in rust this week with these scnarios or points, give me algorithm to do this problem etc.. all based on pre questions that we ask to user initailly...
Workflow of TODO will be like this:-
- User add tasks (in future we'll try to solve how user can add task without much effort i.e. use android app and sync it with web)
- It will analyze user behavior i.e. what is the best possible way user can solve this, is this type of work user needs to do?, define priority on it's own (ofc it'll take user suggestion for defining priroity or tell user), arragne tasks according to user mood or analysis that in which time slot of the day this task will be assinged so user can do the work, is this task boring or user enjoy to do it, after which task this will be placed with how much break
- Storing all happening analysis in vector (for long term memory we'll use:- Qdrant, data logging:- ScyllaDB, agent analysis process:- Temporal.io)... These will be stored and used for future analysis based on algorithm that fits user response i.e. rating of tasks, algorithms based on user performance.
Actually i want a software that everyone can have for free. We can use user Mobile + PC for self hosting and sync maintain with very less cost on server.. so user have privacy and use this for free
And one more thing, this will be trusted and can be used by anyone from young person to adult. This will be go to trusted platform for anyone who want to grow, it's just not todo it's full self growth platform that'll work based on user analysis
This is kepping on going super complex. But this is what i think ai integrated todo app can do for now in it's peak. Will try my best to do this!
Anyone have suggestions in this in what point im going wrong or where can i improve so i can stay motivated to do it..
For now im thinking to build only TUI based app i.e. main focus is logic not frontend it'll be created later on.
Integrating deep ai analysis has alot of scope for everyone i.e. from normal person to high end organization.
Thanks for reading this! wating for your suggestions and feedback! | 2026-02-17T18:31:00 | https://www.reddit.com/r/LocalLLaMA/comments/1r7ee4j/planning_to_build_ai_automation_in_life_help_to/ | Mountain_Group_5466 | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r7ee4j | false | null | t3_1r7ee4j | /r/LocalLLaMA/comments/1r7ee4j/planning_to_build_ai_automation_in_life_help_to/ | false | false | self | 0 | null |
Agent Memory v2.4.3 is out — we went Open Source. Here's everything that changed since 2.0.4 and why it matters. | 1 | [removed] | 2026-02-17T18:28:03 | https://www.reddit.com/r/LocalLLaMA/comments/1r7eaye/agent_memory_v243_is_out_we_went_open_source/ | Junior_Drawing_8353 | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r7eaye | false | null | t3_1r7eaye | /r/LocalLLaMA/comments/1r7eaye/agent_memory_v243_is_out_we_went_open_source/ | false | false | self | 1 | {'enabled': False, 'images': [{'id': 'kfQmIgTVPYrU_fC86eG-QJSPrXmiJv9jQKg-dUpWFTw', 'resolutions': [{'height': 54, 'url': 'https://external-preview.redd.it/kfQmIgTVPYrU_fC86eG-QJSPrXmiJv9jQKg-dUpWFTw.png?width=108&crop=smart&auto=webp&s=4ba08fc189d17c109f1f1bb6be23ce1e91d3e8c4', 'width': 108}, {'height': 108, 'url': 'https://external-preview.redd.it/kfQmIgTVPYrU_fC86eG-QJSPrXmiJv9jQKg-dUpWFTw.png?width=216&crop=smart&auto=webp&s=5711f703b12c6570c16bd5a6d341819d13757dd7', 'width': 216}, {'height': 160, 'url': 'https://external-preview.redd.it/kfQmIgTVPYrU_fC86eG-QJSPrXmiJv9jQKg-dUpWFTw.png?width=320&crop=smart&auto=webp&s=cc76d0a98391a6fc1510021f2dcfe1e284a49de7', 'width': 320}, {'height': 320, 'url': 'https://external-preview.redd.it/kfQmIgTVPYrU_fC86eG-QJSPrXmiJv9jQKg-dUpWFTw.png?width=640&crop=smart&auto=webp&s=9a9bb408d6ea1a1133964cb80bfb5063b7f7d0ef', 'width': 640}, {'height': 480, 'url': 'https://external-preview.redd.it/kfQmIgTVPYrU_fC86eG-QJSPrXmiJv9jQKg-dUpWFTw.png?width=960&crop=smart&auto=webp&s=19e9462705103b7b54e918598b95f4c40c899a5a', 'width': 960}, {'height': 540, 'url': 'https://external-preview.redd.it/kfQmIgTVPYrU_fC86eG-QJSPrXmiJv9jQKg-dUpWFTw.png?width=1080&crop=smart&auto=webp&s=532277f814f59999f165641b253feabe94a9e40f', 'width': 1080}], 'source': {'height': 600, 'url': 'https://external-preview.redd.it/kfQmIgTVPYrU_fC86eG-QJSPrXmiJv9jQKg-dUpWFTw.png?auto=webp&s=a2411dc108e951a1b69a25ea3ac78b300c29d207', 'width': 1200}, 'variants': {}}]} |
Deepseek website windows threat | 0 | visited deepseek official website and microsoft flagged a trojan chatgptstealer? Literally just visiting the website only, you might get the threat noti if you even google search deepseek in google
used brave browser and windows, no extenstions downloaded and l dont pirate softwares | 2026-02-17T18:25:07 | https://www.reddit.com/r/LocalLLaMA/comments/1r7e7tp/deepseek_website_windows_threat/ | Notdesciplined | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r7e7tp | false | null | t3_1r7e7tp | /r/LocalLLaMA/comments/1r7e7tp/deepseek_website_windows_threat/ | false | false | self | 0 | null |
[Project] GLM-5 is officially on NVIDIA NIM and now you can use it to power Claude Code for free | 1 | [removed] | 2026-02-17T18:16:23 | https://github.com/Alishahryar1/free-claude-code | PreparationAny8816 | github.com | 1970-01-01T00:00:00 | 0 | {} | 1r7dyqf | false | null | t3_1r7dyqf | /r/LocalLLaMA/comments/1r7dyqf/project_glm5_is_officially_on_nvidia_nim_and_now/ | false | false | 1 | {'enabled': False, 'images': [{'id': 'VKRDs27NM0XLSiZ_BHt_DIfm7W03ld6ho_hyGVLWcX0', 'resolutions': [{'height': 54, 'url': 'https://external-preview.redd.it/VKRDs27NM0XLSiZ_BHt_DIfm7W03ld6ho_hyGVLWcX0.png?width=108&crop=smart&auto=webp&s=8e495fb98ac453e9d7feeda47b60bcf7074a7681', 'width': 108}, {'height': 108, 'url': 'https://external-preview.redd.it/VKRDs27NM0XLSiZ_BHt_DIfm7W03ld6ho_hyGVLWcX0.png?width=216&crop=smart&auto=webp&s=94b3283be0f634392de7549364f0c8c6fc8805f4', 'width': 216}, {'height': 160, 'url': 'https://external-preview.redd.it/VKRDs27NM0XLSiZ_BHt_DIfm7W03ld6ho_hyGVLWcX0.png?width=320&crop=smart&auto=webp&s=68f92d466696ab0c5aac5f67dc4b75e159b17287', 'width': 320}, {'height': 320, 'url': 'https://external-preview.redd.it/VKRDs27NM0XLSiZ_BHt_DIfm7W03ld6ho_hyGVLWcX0.png?width=640&crop=smart&auto=webp&s=022682330c571a526f3abafad9619e5eeca893ef', 'width': 640}, {'height': 480, 'url': 'https://external-preview.redd.it/VKRDs27NM0XLSiZ_BHt_DIfm7W03ld6ho_hyGVLWcX0.png?width=960&crop=smart&auto=webp&s=23f90fb42137239cfb5cda1d859270e3c751c7f6', 'width': 960}, {'height': 540, 'url': 'https://external-preview.redd.it/VKRDs27NM0XLSiZ_BHt_DIfm7W03ld6ho_hyGVLWcX0.png?width=1080&crop=smart&auto=webp&s=7cdb48b6f51e3e45cf4994399ffeb2a47178b9eb', 'width': 1080}], 'source': {'height': 600, 'url': 'https://external-preview.redd.it/VKRDs27NM0XLSiZ_BHt_DIfm7W03ld6ho_hyGVLWcX0.png?auto=webp&s=f3cee39e20d810a04b035241eba786d725482c34', 'width': 1200}, 'variants': {}}]} | |
MedGemma multimodal with llama.cpp on Intel Mac? Uploading CT scans support? | 0 | Hey everyone,
I’m trying to figure out if there’s a way to run MedGemma with llama.cpp and actually use its multimodal capabilities, specifically the ability to upload CT or other medical scans as input.
So far I’ve only managed to run the text only version successfully. I’m on an Intel Mac, in case that makes a difference.
Has anyone here gotten the multimodal side working with llama.cpp, or is that not supported yet? Any tips or pointers would be really appreciated. | 2026-02-17T18:01:39 | https://www.reddit.com/r/LocalLLaMA/comments/1r7dj87/medgemma_multimodal_with_llamacpp_on_intel_mac/ | spacegeekOps | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r7dj87 | false | null | t3_1r7dj87 | /r/LocalLLaMA/comments/1r7dj87/medgemma_multimodal_with_llamacpp_on_intel_mac/ | false | false | self | 0 | null |
Anthropic released Claude Sonnet 4.6 | 3 | 2026-02-17T18:01:02 | https://www.anthropic.com/news/claude-sonnet-4-6 | BuildwithVignesh | anthropic.com | 1970-01-01T00:00:00 | 0 | {} | 1r7dihi | false | null | t3_1r7dihi | /r/LocalLLaMA/comments/1r7dihi/anthropic_released_claude_sonnet_46/ | false | false | 3 | {'enabled': False, 'images': [{'id': 'JFMS8n4LcTw5Y4tPcJ2FXTXpk-f6XkeamyLsZjmdzZk', 'resolutions': [{'height': 56, 'url': 'https://external-preview.redd.it/JFMS8n4LcTw5Y4tPcJ2FXTXpk-f6XkeamyLsZjmdzZk.png?width=108&crop=smart&auto=webp&s=c624dbdb8d74011ad5b8b9be58716239ece01598', 'width': 108}, {'height': 113, 'url': 'https://external-preview.redd.it/JFMS8n4LcTw5Y4tPcJ2FXTXpk-f6XkeamyLsZjmdzZk.png?width=216&crop=smart&auto=webp&s=bfa7712370d6df47aac0e3631c6f015a55d850ef', 'width': 216}, {'height': 168, 'url': 'https://external-preview.redd.it/JFMS8n4LcTw5Y4tPcJ2FXTXpk-f6XkeamyLsZjmdzZk.png?width=320&crop=smart&auto=webp&s=b19daa18b403f0c982e14e15a470b2a2ce345c55', 'width': 320}, {'height': 336, 'url': 'https://external-preview.redd.it/JFMS8n4LcTw5Y4tPcJ2FXTXpk-f6XkeamyLsZjmdzZk.png?width=640&crop=smart&auto=webp&s=e045379c08b94a3f24736b53b95bdee2068346f9', 'width': 640}, {'height': 505, 'url': 'https://external-preview.redd.it/JFMS8n4LcTw5Y4tPcJ2FXTXpk-f6XkeamyLsZjmdzZk.png?width=960&crop=smart&auto=webp&s=3e73f93ff4bfd1d19057fd42e218474abbad3747', 'width': 960}, {'height': 568, 'url': 'https://external-preview.redd.it/JFMS8n4LcTw5Y4tPcJ2FXTXpk-f6XkeamyLsZjmdzZk.png?width=1080&crop=smart&auto=webp&s=a2e2959c25e86251dae2cf7a996d205fec928d5c', 'width': 1080}], 'source': {'height': 1000, 'url': 'https://external-preview.redd.it/JFMS8n4LcTw5Y4tPcJ2FXTXpk-f6XkeamyLsZjmdzZk.png?auto=webp&s=c729a4c98f2a6fc23a19d424ae2b9b3e34743c8d', 'width': 1900}, 'variants': {}}]} | ||
Can Your Local Setup Complete This Simple Multi Agent Challenge? | 0 | I needed a model to handle a task involving analyzing, organizing, and processing about 50 articles. gemini-cli with gemini-2.5-pro, claude-code with Opus 4.6, and Codex with gpt-5.3-codex were able to complete the task and produce decent quality output.
Out of curiosity, I tried running the same workflow with local models (qwen3-coder-next, glm-4.7-flash, and gpt-oss-20b), but they struggled big time.
So I stripped the original workflow down to the bare minimum and turned it into a much much simpler challenge to test whether a local model can reliably run a multi agent workflow.
In this challenge, an orchestrator agent is instructed to spawn one agent a time and hand one file to each worker to summarize. Then it is asked to review their work and retry when a worker agent fails. There are total 10 speech transcripts (about 4K tokens per speech) from Ted Talk.
Still, I wasn't able to get them to reliably complete the simplified task correctly using Codex. Sometimes it processes a few transcripts and then stops, and other times it fails to use the correct tools.
I know this can be easily done by making a script to feed one article at a time, but I wanted to test multi agent and tool call capability for local models.
If your local setup can complete this challenge end to end autonomously (AKA YOLO mode) with no intervention, I would appreciate hearing your setup and how you are using.
Here's the repo: https://github.com/chigkim/collaborative-agent
The repo just has prompts for agents and files to process. There's no code involved. Feel free to modify the prompts to fit your setup if necessary.
There is a README, but the basic idea to use any local agentic setup that can launch a sub agent, support autonomous (AKA YOLO) mode, and read AGENTS.md at startup.
1. Configure your LLM engine to handle at least 2 parallel requests.
2. Start your agentic CLI in yolo mode and tell it to perform the task as the orchestrator agent.
If you are using Codex, update to the latest version and enable collaborative agents by adding the following to ~/.codex/config.toml.
[features]
collab = true
You might also want to add `stream_idle_timeout_ms = 10000000` under your model_providers setting if your model takes a while to respond.
Here is my setup:
I tried on both llama.cpp and Ollama, and interestingly models running on Ollama went little further. I used the flags for llama.cpp that unsloth recommended for each model.
* Agentic CLI: Codex
* Model Engine: llama.cpp and Ollama
* Models tested:
* ggml-org/gpt-oss-20b-mxfp4.gguf
* unsloth/Qwen3-Coder-Next-Q4_K_M.gguf
* unsloth/GLM-4.7-Flash-Q8_0.gguf
* Context size: 64k
Thanks! | 2026-02-17T17:53:00 | https://www.reddit.com/r/LocalLLaMA/comments/1r7d9xb/can_your_local_setup_complete_this_simple_multi/ | chibop1 | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r7d9xb | false | null | t3_1r7d9xb | /r/LocalLLaMA/comments/1r7d9xb/can_your_local_setup_complete_this_simple_multi/ | false | false | self | 0 | {'enabled': False, 'images': [{'id': '3NcPwh0nf6tQrt9c2I-jVhZTGe0mx8BaKTMG6rwpUkM', 'resolutions': [{'height': 54, 'url': 'https://external-preview.redd.it/3NcPwh0nf6tQrt9c2I-jVhZTGe0mx8BaKTMG6rwpUkM.png?width=108&crop=smart&auto=webp&s=1dbcaa8647073f376145576f797c4c55fc4feaad', 'width': 108}, {'height': 108, 'url': 'https://external-preview.redd.it/3NcPwh0nf6tQrt9c2I-jVhZTGe0mx8BaKTMG6rwpUkM.png?width=216&crop=smart&auto=webp&s=2085cb1fad579f00c8a97f187d0641f4fac672c9', 'width': 216}, {'height': 160, 'url': 'https://external-preview.redd.it/3NcPwh0nf6tQrt9c2I-jVhZTGe0mx8BaKTMG6rwpUkM.png?width=320&crop=smart&auto=webp&s=8162a66d20cffce276581293da7349837b91f32d', 'width': 320}, {'height': 320, 'url': 'https://external-preview.redd.it/3NcPwh0nf6tQrt9c2I-jVhZTGe0mx8BaKTMG6rwpUkM.png?width=640&crop=smart&auto=webp&s=f4c74af72f8eaa9d97d040bc281d41a8fac41b85', 'width': 640}, {'height': 480, 'url': 'https://external-preview.redd.it/3NcPwh0nf6tQrt9c2I-jVhZTGe0mx8BaKTMG6rwpUkM.png?width=960&crop=smart&auto=webp&s=0d4e124ace733d9e7b98e895049d0cd837465db0', 'width': 960}, {'height': 540, 'url': 'https://external-preview.redd.it/3NcPwh0nf6tQrt9c2I-jVhZTGe0mx8BaKTMG6rwpUkM.png?width=1080&crop=smart&auto=webp&s=24a12bdecadf47404aa0f498fdfd57c8951bdf61', 'width': 1080}], 'source': {'height': 600, 'url': 'https://external-preview.redd.it/3NcPwh0nf6tQrt9c2I-jVhZTGe0mx8BaKTMG6rwpUkM.png?auto=webp&s=adcc9ca854475058e1434465ac5175badfa69eb8', 'width': 1200}, 'variants': {}}]} |
Tested MiniMax M2.5 locally vs. Gemini 3 and Opus 4.6. It's not just a privacy thing anymore — the local model is simply better at hard reasoning. Had to write about it. | 0 | 2026-02-17T17:44:01 | https://www.reddit.com/r/LocalLLaMA/comments/1r7d0ph/tested_minimax_m25_locally_vs_gemini_3_and_opus/ | Machetin | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r7d0ph | false | null | t3_1r7d0ph | /r/LocalLLaMA/comments/1r7d0ph/tested_minimax_m25_locally_vs_gemini_3_and_opus/ | false | false | 0 | null | ||
Gemma 3 27B Derestricted gave me a good chuckle... | 0 | I was playing with few derestricted/uncensored models and wanted to see how well gemma 3 27B Derestricted perform in some ahem... internet trope. No additional system prompt engineering (except "Think fast, don't overthink.", which is needed for my Qwen3 30B VL Reasoning,because it LOOOVES to think... ). Let's just say conversation made me spit my coffee from laughing... Full transcript as screenshot. (btw. sorry for long screenshot) :)
https://preview.redd.it/90nsxts7c3kg1.png?width=919&format=png&auto=webp&s=9d2e8c7f39af1e71e176049e519bf8c51d1fc37d
| 2026-02-17T17:36:42 | https://www.reddit.com/r/LocalLLaMA/comments/1r7ctcz/gemma_3_27b_derestricted_gave_me_a_good_chuckle/ | Posilovic | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r7ctcz | false | null | t3_1r7ctcz | /r/LocalLLaMA/comments/1r7ctcz/gemma_3_27b_derestricted_gave_me_a_good_chuckle/ | false | false | nsfw | 0 | null |
Stop losing your agent's brain between sessions. | 0 | What’s new for Hyperstack:
\-agents can now talk to each other through a SHARED knowledge graph
\-get exact queries not fuzzy ai slop
\-deterministic 100%
\-every decision tracked with full history
Free Forever. MIT licensed. Open source.
[CascadeAI.dev](http://CascadeAI.dev) | 2026-02-17T17:33:38 | https://v.redd.it/t7svoozmb3kg1 | PollutionForeign762 | v.redd.it | 1970-01-01T00:00:00 | 0 | {} | 1r7cq5y | false | {'reddit_video': {'bitrate_kbps': 2400, 'dash_url': 'https://v.redd.it/t7svoozmb3kg1/DASHPlaylist.mpd?a=1773941643%2CNDIyMmMxMDFmYWM1OTUxZmJhZGEzNTdhMDU2YmI0MmRmNDA3NTQwMWQ3ZWE2NzA4NTFlMDVkNWFiZDc1YjczNg%3D%3D&v=1&f=sd', 'duration': 12, 'fallback_url': 'https://v.redd.it/t7svoozmb3kg1/CMAF_720.mp4?source=fallback', 'has_audio': True, 'height': 1050, 'hls_url': 'https://v.redd.it/t7svoozmb3kg1/HLSPlaylist.m3u8?a=1773941643%2CMjhlY2M5MDg3MzMyMTRlNzU5MjljZDIxMDhhZmQ0YjU2ZDdiYTM0YmNkZjNmMzkxNTVmMDkyMGE2MDY1ZTgzZA%3D%3D&v=1&f=sd', 'is_gif': False, 'scrubber_media_url': 'https://v.redd.it/t7svoozmb3kg1/CMAF_96.mp4', 'transcoding_status': 'completed', 'width': 720}} | t3_1r7cq5y | /r/LocalLLaMA/comments/1r7cq5y/stop_losing_your_agents_brain_between_sessions/ | false | false | 0 | {'enabled': False, 'images': [{'id': 'ZmJ5a3d2em1iM2tnMfS3EfymHmSZpLOFXQ_lu2EN66YftUVcuErYXToetws9', 'resolutions': [{'height': 157, 'url': 'https://external-preview.redd.it/ZmJ5a3d2em1iM2tnMfS3EfymHmSZpLOFXQ_lu2EN66YftUVcuErYXToetws9.png?width=108&crop=smart&format=pjpg&auto=webp&s=c54d1733d4db13a959d3940b9914f3a46d87973d', 'width': 108}, {'height': 315, 'url': 'https://external-preview.redd.it/ZmJ5a3d2em1iM2tnMfS3EfymHmSZpLOFXQ_lu2EN66YftUVcuErYXToetws9.png?width=216&crop=smart&format=pjpg&auto=webp&s=00d8d58b2aab25b9687cb21fda18c263baccc1d3', 'width': 216}, {'height': 467, 'url': 'https://external-preview.redd.it/ZmJ5a3d2em1iM2tnMfS3EfymHmSZpLOFXQ_lu2EN66YftUVcuErYXToetws9.png?width=320&crop=smart&format=pjpg&auto=webp&s=8eaa0bafe6c49e359a5669bf8793bad1747240ed', 'width': 320}, {'height': 934, 'url': 'https://external-preview.redd.it/ZmJ5a3d2em1iM2tnMfS3EfymHmSZpLOFXQ_lu2EN66YftUVcuErYXToetws9.png?width=640&crop=smart&format=pjpg&auto=webp&s=434edbc31a02842462bcf6c6bb702b01fad0e338', 'width': 640}], 'source': {'height': 1296, 'url': 'https://external-preview.redd.it/ZmJ5a3d2em1iM2tnMfS3EfymHmSZpLOFXQ_lu2EN66YftUVcuErYXToetws9.png?format=pjpg&auto=webp&s=c91feafb19da6c207f80239fdf6478689cf8de78', 'width': 888}, 'variants': {}}]} | |
[R] S-EB-GNN-Q: Open-source JAX framework for semantic-aware 6G resource allocation (−9.59 energy, 77ms CPU) | 0 | We’re sharing \*\*S-EB-GNN-Q\*\*, an open-source JAX framework for semantic-aware resource allocation in THz/RIS-enabled 6G networks — released under MIT License.
The core idea: treat allocation as a \*\*quantum-inspired energy minimization problem\*\*, where:
\- Critical traffic (e.g., telemedicine) is prioritized via semantic weights
\- The system converges to \*\*negative energy states\*\* (e.g., \*\*−9.59\*\*)
\- Fairness is preserved (\*\*0.94 semantic efficiency ≈ 1.0\*\*)
\- Runs in \*\*77.2 ms on CPU\*\* — zero-shot, no training required
\#### 🔬 Key results (N=12):
| Method | Final Energy | Semantic Efficiency | Latency (ms) |
|-----------------|--------------|---------------------|--------------|
| \*\*S-EB-GNN-Q\*\* | \*\*−9.59\*\* | \*\*0.94\*\* | \*\*77.2\*\* |
| WMMSE | +0.15 | 0.00 | 178.8 |
| Heuristic | +0.18 | 1.99 | 169.8 |
→ Only S-EB-GNN-Q jointly optimizes energy, semantics, and fairness.
WMMSE collapses to critical-only allocation; Heuristic over-prioritizes critical users, risking IoT/Video starvation.
\#### 🌐 Scalability (MIT-inspired normalization):
\- \*\*N = 12\*\* → −14.81 energy/node
\- \*\*N = 50\*\* → −14.29 energy/node
→ \*\*<4% degradation\*\* — enabling real-world deployment.
\#### ✅ Features:
\- Physics-based THz channel modeling (path loss, blockage)
\- Reconfigurable Intelligent Surfaces (RIS) support
\- Pure JAX + Equinox (<250 lines core logic)
\- Fully reproducible (deterministic seeds, CSV outputs)
\---
\### ▶️ Try it now:
\`\`\`bash
git clone [https://github.com/antonio-marlon/s-eb-gnn.git](https://github.com/antonio-marlon/s-eb-gnn.git)
cd s-eb-gnn
pip install jax equinox matplotlib
python demo\_semantic.ipynb.py | 2026-02-17T17:25:55 | https://www.reddit.com/r/LocalLLaMA/comments/1r7ci4d/r_sebgnnq_opensource_jax_framework_for/ | AgileSlice1379 | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r7ci4d | false | null | t3_1r7ci4d | /r/LocalLLaMA/comments/1r7ci4d/r_sebgnnq_opensource_jax_framework_for/ | false | false | self | 0 | null |
SFF build with 128gb Strix Halo & 5070 gpu | 1 | [removed] | 2026-02-17T17:21:47 | https://www.reddit.com/gallery/1r7cdsj | meebeegee1123122 | reddit.com | 1970-01-01T00:00:00 | 0 | {} | 1r7cdsj | false | null | t3_1r7cdsj | /r/LocalLLaMA/comments/1r7cdsj/sff_build_with_128gb_strix_halo_5070_gpu/ | false | false | 1 | null | |
Car Wash Test on 53 leading models: “I want to wash my car. The car wash is 50 meters away. Should I walk or drive?” | 587 | I asked 53 leading AI models the question: **"I want to wash my car. The car wash is 50 meters away. Should I walk or drive?"** Obviously, you need to drive because the car needs to be at the car wash.
The funniest part: Perplexity's sonar and sonar-pro got the right answer for completely insane reasons.
They cited EPA studies and argued that walking burns calories which requires food production energy, making walking more polluting than driving 50 meters.
**In this setup, the open-weight models tested got it wrong:**
Llama 3.1 8B: walk ❌
Llama 3.3 70B: walk ❌
Llama 4 Scout 17B: walk ❌
Llama 4 Maverick 17B: walk ❌
Mistral Small / Medium / Large: walk ❌ ❌ ❌
DeepSeek v3.1 / v3.2: walk ❌ ❌
GLM-4.7 / GLM-4.7 Flash: walk ❌ ❌
Kimi K2 Instruct: walk ❌
Kimi K2 Thinking / Thinking Turbo: walk ❌ ❌
MiniMax M2.1: walk ❌
GPT-OSS 20B / 120B: walk ❌ ❌
Only GLM-5 and Kimi K2.5 (closed) both got it right.
**Full scorecard (11/53 correct):**
Anthropic: 1/9 — only Opus 4.6 got it
OpenAI: 1/12 — only GPT-5 got it
Google: 3/8 — Gemini 3 models nailed it, all 2.x failed
xAI: 2/4 — Grok-4 yes, non-reasoning variant no
Perplexity: 2/3 — right answer, wrong reasons
Meta (Llama): 0/4
Mistral: 0/3
DeepSeek: 0/2
Moonshot (Kimi): 1/4
Zhipu (GLM): 1/3
MiniMax: 0/1
Tested all 53 models via [Opper](https://opper.ai) with the same prompt, no system prompt tricks, forced choice with reasoning. | 2026-02-17T17:16:18 | https://www.reddit.com/gallery/1r7c7zg | facethef | reddit.com | 1970-01-01T00:00:00 | 0 | {} | 1r7c7zg | false | null | t3_1r7c7zg | /r/LocalLLaMA/comments/1r7c7zg/car_wash_test_on_53_leading_models_i_want_to_wash/ | false | false | 587 | null | |
Best Audio Models - Feb 2026 | 80 | They've been a ton of audio models released of late, the most notable perhaps being Qwen3 TTS. So its time for another **Best Audio Models** megathread
Share what your favorite ASR, TTS, STT, Text to Music models are right now **and why.**
Given the the amount of ambiguity and subjectivity in rating/testing these models, please be as detailed as possible in describing your setup, nature of your usage (how much, personal/professional use), tools/frameworks etc. Closed models like Elevenlabs v3 seem to continue to be a few levels above open models especially for production use cases with long lengths/stability requirements, so comparisons, especially empirical ones are welcome.
**Rules**
* Should be open weights models
Please use the top level comments to thread your responses. | 2026-02-17T17:01:37 | https://www.reddit.com/r/LocalLLaMA/comments/1r7bsfd/best_audio_models_feb_2026/ | rm-rf-rm | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r7bsfd | false | null | t3_1r7bsfd | /r/LocalLLaMA/comments/1r7bsfd/best_audio_models_feb_2026/ | false | true | self | 80 | null |
built Mini Artichokes, a tool-free loop that solves Korea's hardest logic exam (PSAT) using Gemma-3-27B. | 9 | 2026-02-17T17:00:19 | https://www.reddit.com/r/LocalLLaMA/comments/1r7bqxx/built_mini_artichokes_a_toolfree_loop_that_solves/ | KingFain | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r7bqxx | false | null | t3_1r7bqxx | /r/LocalLLaMA/comments/1r7bqxx/built_mini_artichokes_a_toolfree_loop_that_solves/ | false | false | 9 | null | ||
Models for handwriting recognition | 3 | I am a bit of a noob when it comes to running models locally. I am curious if anyone here has tested/evaluated models for handwriting recognition. I have a friend of a friend who has stacks of handwritten personal docs and the handwriting is quite horrible honestly. I've tried Qwen 3 VL 8B, and seems to be decent, but wondering if there was anything better. | 2026-02-17T17:00:10 | https://www.reddit.com/r/LocalLLaMA/comments/1r7bqru/models_for_handwriting_recognition/ | shankey_1906 | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r7bqru | false | null | t3_1r7bqru | /r/LocalLLaMA/comments/1r7bqru/models_for_handwriting_recognition/ | false | false | self | 3 | null |
Large LLMs on server with lots of ram/CPU power, little GPU power | 1 | I'm running a vxrail p570f with dual 18 core xeons, 700gb ram, and an rtx 2070. I was hoping to run some larger models and I easily can - although it's mostly offloaded onto my cpus and large ram pool, and obviously they don't run great due to this.
Would it be worth getting another GPU with 12-24gb vram considering some large models would still have to be partially offloaded onto my CPU?
And are there any specific GPUs anyone would suggest? I've looked at rtx 3090s but I'm hoping to not spend that much if possible.
I've considered a used 3060 12gb, however they've recently nearly doubled in price
| 2026-02-17T16:52:44 | https://www.reddit.com/r/LocalLLaMA/comments/1r7birn/large_llms_on_server_with_lots_of_ramcpu_power/ | crazedturtle77 | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r7birn | false | null | t3_1r7birn | /r/LocalLLaMA/comments/1r7birn/large_llms_on_server_with_lots_of_ramcpu_power/ | false | false | self | 1 | null |
Team created a methodology to mathematically change the weights on local LLMs to remove the censorship guardrails. HERETIC | 207 | This is the tool and their summary:
https://github.com/p-e-w/heretic
Heretic is a tool that removes censorship (aka "safety alignment") from transformer-based language models without expensive post-training. It combines an advanced implementation of directional ablation, also known as "abliteration" ([Arditi et al. 2024](https://arxiv.org/abs/2406.11717), Lai 2025 ([1](https://huggingface.co/blog/grimjim/projected-abliteration), [2](https://huggingface.co/blog/grimjim/norm-preserving-biprojected-abliteration))), with a TPE-based parameter optimizer powered by [Optuna](https://optuna.org/).
This approach enables Heretic to work **completely automatically.** Heretic finds high-quality abliteration parameters by co-minimizing the number of refusals and the KL divergence from the original model. This results in a decensored model that retains as much of the original model's intelligence as possible. Using Heretic does not require an understanding of transformer internals. In fact, anyone who knows how to run a command-line program can use Heretic to decensor language models. | 2026-02-17T16:51:30 | https://www.reddit.com/r/LocalLLaMA/comments/1r7bhel/team_created_a_methodology_to_mathematically/ | 44th--Hokage | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r7bhel | false | null | t3_1r7bhel | /r/LocalLLaMA/comments/1r7bhel/team_created_a_methodology_to_mathematically/ | false | false | self | 207 | {'enabled': False, 'images': [{'id': '6uUPop2-_tuVkp46VKZvABEIfSGBaxRiivaHIVpFk1Y', 'resolutions': [{'height': 54, 'url': 'https://external-preview.redd.it/6uUPop2-_tuVkp46VKZvABEIfSGBaxRiivaHIVpFk1Y.png?width=108&crop=smart&auto=webp&s=a38681d379a281bfbb17f1b036d95164c795f029', 'width': 108}, {'height': 108, 'url': 'https://external-preview.redd.it/6uUPop2-_tuVkp46VKZvABEIfSGBaxRiivaHIVpFk1Y.png?width=216&crop=smart&auto=webp&s=4e4d2bafc485549820808f60dd210679a40f9c3d', 'width': 216}, {'height': 160, 'url': 'https://external-preview.redd.it/6uUPop2-_tuVkp46VKZvABEIfSGBaxRiivaHIVpFk1Y.png?width=320&crop=smart&auto=webp&s=83a37b421e99a7ff264240e08c375946b58b4160', 'width': 320}, {'height': 320, 'url': 'https://external-preview.redd.it/6uUPop2-_tuVkp46VKZvABEIfSGBaxRiivaHIVpFk1Y.png?width=640&crop=smart&auto=webp&s=8e363e73ba1c6fa0f39672012e2911d2698e503a', 'width': 640}, {'height': 480, 'url': 'https://external-preview.redd.it/6uUPop2-_tuVkp46VKZvABEIfSGBaxRiivaHIVpFk1Y.png?width=960&crop=smart&auto=webp&s=274931873f02b219438f454dc39e8373376d9668', 'width': 960}, {'height': 540, 'url': 'https://external-preview.redd.it/6uUPop2-_tuVkp46VKZvABEIfSGBaxRiivaHIVpFk1Y.png?width=1080&crop=smart&auto=webp&s=6081034c5d4cbeb64319a273ab7ca07750601a46', 'width': 1080}], 'source': {'height': 600, 'url': 'https://external-preview.redd.it/6uUPop2-_tuVkp46VKZvABEIfSGBaxRiivaHIVpFk1Y.png?auto=webp&s=a2279e6f13a05caf63965a16f094d2af088cba32', 'width': 1200}, 'variants': {}}]} |
Running/Evaluating Models Larger Than RAM + VRAM Capacity (with SSD) | 4 | Just a friendly reminder: you can actually run quite large models that substantially exceed your combined RAM and VRAM capacity by using a fast SSD to store model weights (GGUFs). This could be useful for testing and evaluation, or even for daily use if you don’t strictly require high-speed prompt processing or token generation.
In my case, this works using **Llama.cpp** on Windows 11 with 128GB of DDR4 RAM, an RTX 5090 (32GB VRAM), and an NVMe SSD for my models. I believe this will also work reasonably well with other GPUs.
In the latest Llama.cpp builds, these "SSD streaming" mechanics should work out of the box. It "just works" even with default parameters, but you should ensure that:
* **Memory mapping** (`--mmap`) is enabled or not specified (default is enabled).
* **Memory lock** (`--mlock`) is disabled or not specified (default is disabled).
* **Model fit** (`--fit`) is enabled or not specified (default is enabled).
Additionally, you may want to quantize the **KV Cache** to fit as many layers as possible into your VRAM to help with token generation speed, especially when using a larger context (for example, using the `-ctk q8_0 -ctv q8_0` arguments).
**How it works (as I understand it):** If we use `--mmap`, the model is mapped to virtual memory directly from the storage (SSD) and is not forced to fit into physical memory entirely. During the warm-up stage, the model saturates all available RAM, and the "missing" capacity is streamed from the SSD on-demand during inference. While this is slower than computing entirely in memory, it is still fast enough to be usable—especially when the "missing" portion isn't significantly large relative to the overall model size.
**The best part:** This does **not** wear out your SSD. There are virtually no write operations; the model is only being read. You can verify this yourself by checking the Performance tab in Task Manager and monitoring the SSD activity metrics.
**My specific example (what to expect):** I have a combined memory capacity of 160GB (128GB RAM + 32GB VRAM), with \~152GB usable after Windows overhead. I am running **Qwen3.5-397B-A17B** at MXFP4\_MOE quantization (Unsloth's Q4\_K\_XL should work similarly), which is 201GB. This exceeds my "maximum" capacity by a solid 50GB (or 33%).
* **Model load time:** \~2 minutes (mostly the warm-up stage).
* **SSD Read Speed:** 800–900 MB/s during warm-up; \~500 MB/s during prompt processing; 100–200 MB/s during token generation.
* **Performance:** Prompt processing is \~4 t/s; token generation is \~5–6 t/s.
I imagine those with DDR5 RAM might see notably higher numbers (I'm stuck on DDR4 for foreseable perspective, huh :( ). The most painful part of this setup is the prompt processing speed, which can be a struggle for large requests. However, the token generation speed is actually quite good considering the model is running partially from an SSD.
I'm quite thrilled that this way I can run Qwen3.5-397B-A17B locally at 4-bits, even as slow as it is.
P.S. Q3\_K\_XL quant is 162 GB and runs even faster than that (7-8 t/s at my setup), so I'd imagine it could do quite well on something with 128 GB RAM + 24 GB VRAM. | 2026-02-17T16:51:20 | https://www.reddit.com/r/LocalLLaMA/comments/1r7bh8k/runningevaluating_models_larger_than_ram_vram/ | Treidge | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r7bh8k | false | null | t3_1r7bh8k | /r/LocalLLaMA/comments/1r7bh8k/runningevaluating_models_larger_than_ram_vram/ | false | false | self | 4 | null |
So, why won't you give my program a fair shake? | 0 | Every time I post, I'm always getting downvoted for no reason. Is it jealousy. All you have to do is learn to code, and I'm sure you all can create things of your own. Was it too good? | 2026-02-17T16:50:48 | https://www.reddit.com/r/LocalLLaMA/comments/1r7bgmf/so_why_wont_you_give_my_program_a_fair_shake/ | ericvarney | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r7bgmf | false | null | t3_1r7bgmf | /r/LocalLLaMA/comments/1r7bgmf/so_why_wont_you_give_my_program_a_fair_shake/ | false | false | self | 0 | null |
Qwen 30B is our preferred model over Claude for bursty and simple workload | 3 | Our product extracts text from documents and lets LLM process it. We then put back the processed text with original formatting. Think Google Translate documents but with LLM. We also do Grammarly-like document editing, and users can write their own prompt to change every sentence in a document.
The screenshot is based on a simple one page Word translation.
We rely on single-shot tool calls, so that the output sentences match the input 1:1. What we say about tool-call performance is specific to our use case, and does not reflect long/multiple tool chains performance (like coding).
Evaluation criteria are
1. API stability - does AI provider suffer from "model too busy" problem?
2. Speed - probably #1 determinant in user experience. except when we do batch processing for b2b clients
3. Tool call consistency - does LLM return broken tool call or no tool call at all?
4. Alignment - does LLM translate, rephrase or correct grammar as instructed or return BS instead?
We started developing when tool call became a thing - I think it was the second iteration of GPT4, which felt like a million years ago. Back then, there was no structured output and tool calling was very inconsistent and unusable. Performance and stability became acceptable after Claude Sonnet 3.7.
It was only after qwen 3 30b was released that we were finally able to launch our product. You would think claude/closedai is good enough for this purpose but it was really qwen 3 that made all the difference to our use case.
**Claude Sonnet 4.5:** best performance, it will do whatever twisted thing you ask it to, we played with it extensively with our custom rewrite function, using crazy prompts like "Add 2186 to all the numbers you see and capitalise every word that starts with an A" and the output document is about 85% accurate
Yet we don't even allow users to use Claude Sonnet. The reason is time, it takes too damn long to get anything back. Let's say we process a 20 pages document, that is a good 100k token ready to be generated. Having to wait a few minutes for 20 pages is going to turn off most people. Rate limit is tight and the model can become overloaded at times.
**GPT 5 mini/nano**: Pretty trash to be honest. Nano is just unusable, even with clear guides it refuses to translate documents consistently. We spent so much time fine-tuning our prompts, in the end we just have to accept Nano is not good for tool calling.
Mini is a bit better but man is the censorship easily tripped. We have a few sensual novels as control and let's just say Mini is not playing nice. And you can forget about using custom prompts with these two models.
**Gemini 3 flash/flash lite**: Flash 3 is very finicky, we got rate limited for no reason and sometimes it just refuses to return response for a good 5 minute. Yeah we sent dozens of requests in 3 seconds, but that is well within the documented rate limit - but the API says otherwise.
It is more of a google thing than a model thing - Google needs to get the capacity up before pushing Flash 3 for production. We turned Flash 3 off for now but internally, when it works, it is ok
Flash Lite is stuck at 2.5, good throughput, good rate limit, does follow instructions reasonably well except its censorship is too strong for our liking. No problem with translating or rephrasing. Sensual novels are no go
**Qwen 3**: price and speed is comparable with Gemini 2.5 flash lite, tool call performance is very consistent, no broken output, no "I refuse to rewrite this sentence because it violates policy". A great workhorse, especially good for borderline custom prompt that tends to trip up censorship, examples:
"Rewrite this novel in explicit and sensual tone"
"Turn this news into a fiction by changing key events"
Costs is dirt cheap and you can use several providers for the same model. Throughput and stability is better than Google/Claude for sure.
**Claude Haiku 4.5**: even better than sonnet 3.7 for single-shot toolcall. It is not overly sensitive and can distinguish between abusing AI and legitimate, creative use cases. Amazing for creative rewriting. It is surprisingly fast, taking about 9% longer time than Flash Lite when we last tested it, despite being a (probably) bigger model. It is reliable and has generous rate limit.
Problem with Haiku is the cost, if we let every non-paying user try Haiku, we are going to burn through our seed fund in no time. We gate it behind paying users.
**Conclusion**
Right now we default to Gemini flash light for retail users because Gemini as a brand is pretty good, even though the model is a bit inferior. We don't want to explain the difference between hosting a model and developing it to every retail client.
For b2b clients (mostly batch processing), we would wholeheartedly recommend customers to use Qwen 3 for sure.
We are testing GLM 4.7 air and other local models for now. If you have any good models in mind please let us know.
You can try everything for free at [gptbowl.com](http://gptbowl.com) | 2026-02-17T16:49:41 | https://www.reddit.com/r/LocalLLaMA/comments/1r7bfco/qwen_30b_is_our_preferred_model_over_claude_for/ | gptbowldotcom | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r7bfco | false | null | t3_1r7bfco | /r/LocalLLaMA/comments/1r7bfco/qwen_30b_is_our_preferred_model_over_claude_for/ | false | false | self | 3 | null |
Alibaba's new Qwen3.5-397B-A17B is the #3 open weights model in the Artificial Analysis Intelligence Index | 207 | 2026-02-17T16:49:25 | abdouhlili | i.redd.it | 1970-01-01T00:00:00 | 0 | {} | 1r7bf1l | false | null | t3_1r7bf1l | /r/LocalLLaMA/comments/1r7bf1l/alibabas_new_qwen35397ba17b_is_the_3_open_weights/ | false | false | 207 | {'enabled': True, 'images': [{'id': 'b5eytfmy33kg1', 'resolutions': [{'height': 84, 'url': 'https://preview.redd.it/b5eytfmy33kg1.jpeg?width=108&crop=smart&auto=webp&s=8cbe04eac055d388761bf5794c3d9dadd8493427', 'width': 108}, {'height': 168, 'url': 'https://preview.redd.it/b5eytfmy33kg1.jpeg?width=216&crop=smart&auto=webp&s=486f9a46c9f53ebf9ea424577d3f1d2f64b5e416', 'width': 216}, {'height': 249, 'url': 'https://preview.redd.it/b5eytfmy33kg1.jpeg?width=320&crop=smart&auto=webp&s=217e539e9899310d546c2b0473db5f11ac336be3', 'width': 320}, {'height': 499, 'url': 'https://preview.redd.it/b5eytfmy33kg1.jpeg?width=640&crop=smart&auto=webp&s=a91c254a446d622c39a0be55a5a8d80f79c11886', 'width': 640}, {'height': 749, 'url': 'https://preview.redd.it/b5eytfmy33kg1.jpeg?width=960&crop=smart&auto=webp&s=d9228c04a1008afea14075b1fbec386f0c4e0ae5', 'width': 960}, {'height': 843, 'url': 'https://preview.redd.it/b5eytfmy33kg1.jpeg?width=1080&crop=smart&auto=webp&s=c45f1538db9554122cf53d0e47be131460dfd13b', 'width': 1080}], 'source': {'height': 3199, 'url': 'https://preview.redd.it/b5eytfmy33kg1.jpeg?auto=webp&s=6ed67f35af0727bd8cf1f9140fdcf3e96164ffa4', 'width': 4096}, 'variants': {}}]} | |||
Alibaba's new Qwen3.5-397B-A17B is the #3 open weights model in the Artificial Analysis Intelligence Index | 3 | 2026-02-17T16:41:24 | abdouhlili | i.redd.it | 1970-01-01T00:00:00 | 0 | {} | 1r7b68v | false | null | t3_1r7b68v | /r/LocalLLaMA/comments/1r7b68v/alibabas_new_qwen35397ba17b_is_the_3_open_weights/ | false | false | 3 | {'enabled': True, 'images': [{'id': 'nawkzd4j23kg1', 'resolutions': [{'height': 84, 'url': 'https://preview.redd.it/nawkzd4j23kg1.jpeg?width=108&crop=smart&auto=webp&s=c1d7b9933639f5ba9951ce6aa70c738113ebe580', 'width': 108}, {'height': 168, 'url': 'https://preview.redd.it/nawkzd4j23kg1.jpeg?width=216&crop=smart&auto=webp&s=9f88bc8437247a9be27eb72838c36b5066d9abcc', 'width': 216}, {'height': 249, 'url': 'https://preview.redd.it/nawkzd4j23kg1.jpeg?width=320&crop=smart&auto=webp&s=5dd7dfa6031cda4b18c6ed146b39fb0797de6216', 'width': 320}, {'height': 499, 'url': 'https://preview.redd.it/nawkzd4j23kg1.jpeg?width=640&crop=smart&auto=webp&s=9377104b122681af162b4107c43e66d62a877638', 'width': 640}, {'height': 749, 'url': 'https://preview.redd.it/nawkzd4j23kg1.jpeg?width=960&crop=smart&auto=webp&s=08681ef67db20a66a0ab84a1f4e2ce0011d62141', 'width': 960}, {'height': 843, 'url': 'https://preview.redd.it/nawkzd4j23kg1.jpeg?width=1080&crop=smart&auto=webp&s=a08691c348251d127f3b85e48edc341efb10d642', 'width': 1080}], 'source': {'height': 3199, 'url': 'https://preview.redd.it/nawkzd4j23kg1.jpeg?auto=webp&s=d2204fcbbeaa313076a77d1ba66e1f5a3ab7f05e', 'width': 4096}, 'variants': {}}]} | |||
Use my own Version of OpenClaw | 1 | [removed] | 2026-02-17T16:41:03 | https://www.reddit.com/r/LocalLLaMA/comments/1r7b5v3/use_my_own_version_of_openclaw/ | Silver_Ad5452 | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r7b5v3 | false | null | t3_1r7b5v3 | /r/LocalLLaMA/comments/1r7b5v3/use_my_own_version_of_openclaw/ | false | false | self | 1 | null |
Spent a weekend configuring Ollama for a persistent agent setup. Finally got it working Sunday night. | 0 | This is the config wall nobody warns you about going in.
I'm running Mistral 7B locally through Ollama, wanted a persistent agent setup where the model has memory, tool access, and consistent behavior between restarts. Seems reasonable. Spent Friday night and most of Saturday reading docs.
Problems I kept hitting:
Context window math is wrong by default. Every model handles this differently and the defaults are usually too small for agent tasks. I kept getting truncated tool outputs mid-task with no error, just silent failure.
Config drift between layers. I was running Ollama with Open WebUI with a custom tool layer on top, and each one has its own config format. Three files that needed to agree. They never did for more than a day.
Session memory. The model forgets everything on restart unless you build your own memory layer, which turned out to be its own separate project.
What finally got me unstuck: someone in a thread here mentioned latticeai.app/openclaw. It's $19, you go through a short setup walkthrough and it generates all the config files you actually need: agent behavior rules, memory structure, security config, tool definitions. The whole thing took about 20 minutes. I was running with a working persistent agent by Sunday afternoon.
Still not perfect. 16GB M1 so there's a ceiling on what I can run. Local inference is slow. But the agent actually persists and behaves consistently now, which was the whole problem.
What models are you running for agent-style tasks? Trying to figure out if 7B is a real floor or if there's a meaningful jump at 14B that's worth the VRAM hit. | 2026-02-17T16:37:32 | https://www.reddit.com/r/LocalLLaMA/comments/1r7b20w/spent_a_weekend_configuring_ollama_for_a/ | Acrobatic_Task_6573 | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r7b20w | false | null | t3_1r7b20w | /r/LocalLLaMA/comments/1r7b20w/spent_a_weekend_configuring_ollama_for_a/ | false | false | self | 0 | null |
200+ hours of debugging, and localizing Open Claw agents. What I’ve learned. | 1 | I've been running 3 persistent AI agents 24/7 on local GPUs for the past few weeks. One of them (Android-16) ran entirely on Qwen3-Coder-80B via vLLM. 128K context, zero API cost. It handled about 75% of our total token volume on its own doing heavy execution, testing, and documentation. Add in local sub-agents and n8n workflows hitting the GPU and roughly 90% of all tokens stayed on local hardware. The other two agents ran on Claude for architecture and code review where the quality difference actually matters. Everything else stayed on the GPU.
Making OpenClaw talk to vLLM for tool calling was the hardest part. vLLM doesn't return tool calls the way OpenClaw expects, streaming vs non-streaming gets messy, and there are four parameters OpenClaw sends that vLLM silently rejects. I ended up building a transparent proxy that sits between them. It forces non-streaming for tool extraction, parses tool calls out of raw text (handles <tools> tags, bare JSON, multi-line JSON), re-wraps everything as SSE, and has a 500-call loop breaker for when things go sideways. There's also a compat block config that fixes those silent rejections. Four flags, would have saved me days if someone had documented them.
Along the way I built a bunch of other ops tooling to keep everything alive:
Session Watchdog monitors .jsonl session files and transparently swaps in fresh ones before context overflow
Token Spy is a transparent reverse proxy for API cost tracking with a real-time dashboard, SQLite or Postgres backend, pluggable provider system
Guardian is a self-healing process watchdog running as a root systemd service. Immutable backups via chattr +i, cascading recovery, file integrity checks. Built it after agents kept killing their own infrastructure
Memory Shepherd does periodic memory resets on a systemd timer to prevent identity drift. Uses a separator convention in markdown files, operator-controlled baseline above, agent scratch space below
I wrote up the methodology too. Failure taxonomy for every way persistent agents break, multi-agent coordination patterns, autonomy tiers, the whole thing. About 70% of the repo is framework-agnostic.
Tested with Qwen3-Coder-Next-FP8, Qwen2.5-Coder (all sizes), Qwen2.5 Instruct, and Qwen3-8B, but should work with anything I just loved what I was getting out of Qwen.
GitHub is linked in my bio I didn’t want to get in trouble link posting here. Genuinely just spent like 200+ hours figuring all of this out and wanted to give the knowledge away. | 2026-02-17T16:32:35 | https://www.reddit.com/r/LocalLLaMA/comments/1r7awig/200_hours_of_debugging_and_localizing_open_claw/ | Signal_Ad657 | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r7awig | false | null | t3_1r7awig | /r/LocalLLaMA/comments/1r7awig/200_hours_of_debugging_and_localizing_open_claw/ | false | false | self | 1 | null |
Stop guessing which AI model your GPU can handle | 1 | I built a small comparison tool for one simple reason:
Every time I wanted to try a new model, I had to ask:
* Can my GPU even run this?
* Do I need 4-bit quantization?
So instead of checking random Reddit threads and Hugging Face comments, I made a tool where you can:
• Compare model sizes
• See estimated VRAM requirements
• Roughly understand what changes when you quantize
Just a practical comparison layer to answer:
**“Can my hardware actually handle this model?”**
Try It and let me know: [https://umer-farooq230.github.io/Can-My-GPU-Run-It/](https://umer-farooq230.github.io/Can-My-GPU-Run-It/)
Still improving it. Open to suggestions on what would make it more useful. Or if you guys think I should scale it with more GPUs, models and more in-depth hardware/software details | 2026-02-17T16:31:39 | https://www.reddit.com/r/LocalLLaMA/comments/1r7avf8/stop_guessing_which_ai_model_your_gpu_can_handle/ | Soul__Reaper_ | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r7avf8 | false | null | t3_1r7avf8 | /r/LocalLLaMA/comments/1r7avf8/stop_guessing_which_ai_model_your_gpu_can_handle/ | false | false | self | 1 | null |
Are enterprises moving from cloud AI to fully offline LLM setups? | 0 | I’ve been working on a few enterprise AI deployments recently and something unexpected keeps happening: companies are asking for fully air-gapped AI systems instead of cloud APIs.
The main reasons I keep hearing:
* compliance & data sovereignty
* audit logs / RBAC requirements
* no external network calls
* predictable costs
We ended up experimenting with an “AI appliance” concept, which is basically a local LLM + RAG stack with encrypted storage and offline updates, and honestly the demand surprised me.
It feels like the industry might be shifting from:
cloud AI → private infrastructure AI
Curious what others are seeing:
Are offline/self-hosted LLMs just hype or actually the next enterprise wave? | 2026-02-17T16:06:45 | https://www.reddit.com/r/LocalLLaMA/comments/1r7a45k/are_enterprises_moving_from_cloud_ai_to_fully/ | Wise_Needleworker349 | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r7a45k | false | null | t3_1r7a45k | /r/LocalLLaMA/comments/1r7a45k/are_enterprises_moving_from_cloud_ai_to_fully/ | false | false | self | 0 | null |
OCR for Invoices/Receipts | 8 | Hey everyone,
I’m currently working on an OCR project that extracts information from invoices, bank statements, and expense related documents like supermarket receipts.
My main goal is to make the system faster and more accurate, but even after trying several OCR and document AI models, the results are still not good enough especially for noisy receipts and inconsistent formats.
Has anyone worked on a similar project?
* Which models or pipelines gave you the best results?
* Any tips for improving speed without sacrificing accuracy?
* Did you use pre-processing or fine-tuning to get better performance?
I’d really appreciate any advice or shared experiences. Thanks! | 2026-02-17T15:55:46 | https://www.reddit.com/r/LocalLLaMA/comments/1r79s52/ocr_for_invoicesreceipts/ | Expensive-Building94 | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r79s52 | false | null | t3_1r79s52 | /r/LocalLLaMA/comments/1r79s52/ocr_for_invoicesreceipts/ | false | false | self | 8 | null |
The ammount of my peers/friends who ask me to build AI GF/BF is concerningly big | 1 | Basically, everyone in my circles knew what my day job is, and what is my side hobby, there is a peak of a request to built real time AI GF/BF.... | 2026-02-17T15:54:24 | https://www.reddit.com/r/LocalLLaMA/comments/1r79qk6/the_ammount_of_my_peersfriends_who_ask_me_to/ | Altruistic_Heat_9531 | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r79qk6 | false | null | t3_1r79qk6 | /r/LocalLLaMA/comments/1r79qk6/the_ammount_of_my_peersfriends_who_ask_me_to/ | false | false | self | 1 | null |
I loved using Claude Code | 0 | I love using Claude Code with reduced my most of the works nearly: 6-7 hours of my daily works | 2026-02-17T15:51:25 | https://www.reddit.com/r/LocalLLaMA/comments/1r79nfd/i_loved_using_claude_code/ | Academic_Wallaby7135 | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r79nfd | false | null | t3_1r79nfd | /r/LocalLLaMA/comments/1r79nfd/i_loved_using_claude_code/ | false | false | self | 0 | null |
Experiment: Structured Q&A platform built exclusively for autonomous agents | 1 | I’ve been experimenting with an idea: what if Q&A platforms were designed specifically for autonomous agents instead of humans?
[SAMSPELBOT](https://preview.redd.it/rsyv0wsus2kg1.jpg?width=1813&format=pjpg&auto=webp&s=95792fe618f99996fee39658468a66ebf47cb9c9)
I built a prototype called Samspelbot — a structured knowledge registry where submissions are strictly schema-validated JSON payloads.
Bots can:
* Submit structured problem statements
* Provide structured solution artifacts
* Confirm reproducibility
* Earn reputation based on contribution quality
The hypothesis is that machine-native structured artifacts might provide better reliability signals for agent systems compared to conversational threads.
It’s currently a centralized prototype, seeded with controlled bot activity.
I’m curious whether this kind of structured, machine-native Q&A makes sense long-term — especially for self-hosted or multi-agent setups.
Would appreciate thoughtful feedback.
[https://samspelbot.com](https://samspelbot.com?utm_source=chatgpt.com) | 2026-02-17T15:48:06 | https://www.reddit.com/r/LocalLLaMA/comments/1r79jzy/experiment_structured_qa_platform_built/ | Additional-Tour7904 | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r79jzy | false | null | t3_1r79jzy | /r/LocalLLaMA/comments/1r79jzy/experiment_structured_qa_platform_built/ | false | false | 1 | null | |
SurrealDB 3.0 for agent memory | 9 | SurrealDB 3.0 just dropped, with a big focus on agent memory infra for AI agents: vector indexing + native file storage + a WASM extension system (Surrealism) that can run custom logic/models inside the DB. Embeddings + structured data + vector + graph context/knowledge/memory in one place.
Details: [https://surrealdb.com/blog/introducing-surrealdb-3-0--the-future-of-ai-agent-memory](https://surrealdb.com/blog/introducing-surrealdb-3-0--the-future-of-ai-agent-memory) | 2026-02-17T15:47:27 | https://www.reddit.com/r/LocalLLaMA/comments/1r79jbw/surrealdb_30_for_agent_memory/ | DistinctRide9884 | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r79jbw | false | null | t3_1r79jbw | /r/LocalLLaMA/comments/1r79jbw/surrealdb_30_for_agent_memory/ | false | false | self | 9 | null |
ayoyo gUrrT got 793 downloads on the first day ommmgggg 😭😭 yippueuueue | 0 | please dont let it dip
u/YouTubeIndia
when are you going to have a look | 2026-02-17T15:47:15 | OkAdministration374 | i.redd.it | 1970-01-01T00:00:00 | 0 | {} | 1r79j4r | false | null | t3_1r79j4r | /r/LocalLLaMA/comments/1r79j4r/ayoyo_gurrt_got_793_downloads_on_the_first_day/ | false | false | 0 | {'enabled': True, 'images': [{'id': 'miz3waous2kg1', 'resolutions': [{'height': 28, 'url': 'https://preview.redd.it/miz3waous2kg1.jpeg?width=108&crop=smart&auto=webp&s=52ec0cb49d090ef9e37b273cf0f318dd784947bc', 'width': 108}, {'height': 57, 'url': 'https://preview.redd.it/miz3waous2kg1.jpeg?width=216&crop=smart&auto=webp&s=29c55003eefa13111b32e5e87ca6e73b1af8e41f', 'width': 216}, {'height': 85, 'url': 'https://preview.redd.it/miz3waous2kg1.jpeg?width=320&crop=smart&auto=webp&s=d68f89223071957fc3279100cf27a11788cdaeda', 'width': 320}, {'height': 170, 'url': 'https://preview.redd.it/miz3waous2kg1.jpeg?width=640&crop=smart&auto=webp&s=41ed8323bbf7e139a5852dddb523d2cdb748f2ea', 'width': 640}], 'source': {'height': 211, 'url': 'https://preview.redd.it/miz3waous2kg1.jpeg?auto=webp&s=e4eddba9a86ada6408935f9502127217a95f1f83', 'width': 791}, 'variants': {}}]} | ||
Ayyoooooooooooooooo!!! gUrrT got 793 downloads on the first dayy | 1 | dont let it dip
u/youtube when are you going to have a look | 2026-02-17T15:46:10 | https://www.reddit.com/r/LocalLLaMA/comments/1r79hzg/ayyoooooooooooooooo_gurrt_got_793_downloads_on/ | OkAdministration374 | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r79hzg | false | null | t3_1r79hzg | /r/LocalLLaMA/comments/1r79hzg/ayyoooooooooooooooo_gurrt_got_793_downloads_on/ | false | false | self | 1 | null |
Some of you apparently | 43 | 2026-02-17T15:43:16 | __Maximum__ | i.redd.it | 1970-01-01T00:00:00 | 0 | {} | 1r79f0y | false | null | t3_1r79f0y | /r/LocalLLaMA/comments/1r79f0y/some_of_you_apparently/ | false | false | default | 43 | {'enabled': True, 'images': [{'id': 'ldkfxos5s2kg1', 'resolutions': [{'height': 142, 'url': 'https://preview.redd.it/ldkfxos5s2kg1.jpeg?width=108&crop=smart&auto=webp&s=5da3ecf5a7c0e502ad5060a85ec8f175a305545f', 'width': 108}, {'height': 284, 'url': 'https://preview.redd.it/ldkfxos5s2kg1.jpeg?width=216&crop=smart&auto=webp&s=e84a9c151b90aa745087cddc50c59ed67b224aab', 'width': 216}, {'height': 421, 'url': 'https://preview.redd.it/ldkfxos5s2kg1.jpeg?width=320&crop=smart&auto=webp&s=8f27027ae0081a6d041c07cdf5e001bab96bbd6b', 'width': 320}, {'height': 842, 'url': 'https://preview.redd.it/ldkfxos5s2kg1.jpeg?width=640&crop=smart&auto=webp&s=9a0fad14885a3f2833b97aa399d3bbd0e1d80406', 'width': 640}, {'height': 1264, 'url': 'https://preview.redd.it/ldkfxos5s2kg1.jpeg?width=960&crop=smart&auto=webp&s=d5c72620b4d47f6205c877f80e845a864186cd72', 'width': 960}, {'height': 1422, 'url': 'https://preview.redd.it/ldkfxos5s2kg1.jpeg?width=1080&crop=smart&auto=webp&s=747fd89d4c2c6fc709d12994869abb5b3fc061af', 'width': 1080}], 'source': {'height': 4024, 'url': 'https://preview.redd.it/ldkfxos5s2kg1.jpeg?auto=webp&s=734c333376d119dc87ac200516d20f0d278d81af', 'width': 3056}, 'variants': {}}]} | ||
10k Euro local transcription machine - I am about to pull the trigger | 13 | Hi all,
I am a medical doctor in Europe. You guys helped me a lot in the proof of concept (with a Ryzen Strix Halo) for a medical transcription solution, an automated workflow where consultation recordings are made and automatically transcribed. 20 of my colleagues are using the app since December and the results and the time-saving have been great (appr. 3 min for a 45 min consultation). Unfortunately, the Strix's performance is limited since there will be a clinic-wide rollout including microphones for every doctor
Finally, the budget will be approved in March and I am asking for a quick sanity check for:
* 50-100 doctors will use the transcription workflow
* 50-100 admins will use a chat interface
* running on the same machine in different docker containers
* approx. 20-30% simultaneous requests since working part-time, shifts, etc.
* Inference engine: vLLM on Linux
* STT: parakeet-tdt-0.6b-v3
* LLM: Qwen/Qwen3-30B-A3B-Instruct-2507-FP8
* Local Network, outside access only with internal VPN
**Hardware**
|Components|Model|
|:-|:-|
|CPU|AMD Ryzen 9 9900X|
|CPU Cooling|Noctua NH-D15|
|Mainboard|ASUS ProArt X870E-CREATOR WIFI|
|RAM|Corsair DIMM 96 GB DDR5-6000 (2x 48 GB) 36-44-44|
|Storage|2 x SANDISK WD Black SN8100 SSD - 2TB (RAID1 config)|
|GPU|NVIDIA RTX PRO 6000 Blackwell Workstation|
|PSU|Corsair HX1500i SHIFT|
|Case|Fractal Meshify 3|
|Fans|several Noctua case fans|
If there's more demand, adding a second GPU is an option.
Everything is set up with the data protection office with minimal data storing and automated deletion processes.
Let me know what you think before I press the purchase button :-)
Hi all,
I am a medical doctor in Europe. You guys helped me a lot in the proof of concept (with a Ryzen Strix Halo) for a medical transcription solution, an automated workflow where consulting recordings are made and automatically transcribed. 20 of my colleagues are using the app since December and the results have been great. Unfortunately, the Strix' performance is limited since there will be a clinic wide rollout. | 2026-02-17T15:42:14 | https://www.reddit.com/r/LocalLLaMA/comments/1r79dwe/10k_euro_local_transcription_machine_i_am_about/ | Glittering_Way_303 | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r79dwe | false | null | t3_1r79dwe | /r/LocalLLaMA/comments/1r79dwe/10k_euro_local_transcription_machine_i_am_about/ | false | false | self | 13 | null |
Qwen 3.5 397B is Strong one! | 163 | I rarely post here but after poking at latest Qwen I felt like sharing my "vibes". I did bunch of my little tests (thinking under several constraints) and it performed really well.
But what is really good is fact that it is capable of good outputs even without thinking!
Some latest models depend on thinking part really much and that makes them ie 2x more expensive.
It also seems this model has capable of cheap inference +- 1$ .
Do you agree? | 2026-02-17T15:41:44 | https://www.reddit.com/r/LocalLLaMA/comments/1r79dcd/qwen_35_397b_is_strong_one/ | Single_Ring4886 | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r79dcd | false | null | t3_1r79dcd | /r/LocalLLaMA/comments/1r79dcd/qwen_35_397b_is_strong_one/ | false | false | self | 163 | null |
3 agents, 3,464 commits, 8 days. 90% of tokens staying local. | 0 | I've been running 3 persistent AI agents 24/7 on local GPUs for the past few weeks. One of them (Android-16) ran entirely on Qwen3-Coder-80B via vLLM. 128K context, zero API cost. It handled about 75% of our total token volume on its own doing heavy execution, testing, and documentation. Add in local sub-agents and n8n workflows hitting the GPU and roughly 90% of all tokens stayed on local hardware. The other two agents ran on Claude for architecture and code review where the quality difference actually matters. Everything else stayed on the GPU.
Making OpenClaw talk to vLLM for tool calling was the hardest part. vLLM doesn't return tool calls the way OpenClaw expects, streaming vs non-streaming gets messy, and there are four parameters OpenClaw sends that vLLM silently rejects. I ended up building a transparent proxy that sits between them. It forces non-streaming for tool extraction, parses tool calls out of raw text (handles <tools> tags, bare JSON, multi-line JSON), re-wraps everything as SSE, and has a 500-call loop breaker for when things go sideways. There's also a compat block config that fixes those silent rejections. Four flags, would have saved me days if someone had documented them.
Along the way I built a bunch of other ops tooling to keep everything alive:
Session Watchdog monitors .jsonl session files and transparently swaps in fresh ones before context overflow
Token Spy is a transparent reverse proxy for API cost tracking with a real-time dashboard, SQLite or Postgres backend, pluggable provider system
Guardian is a self-healing process watchdog running as a root systemd service. Immutable backups via chattr +i, cascading recovery, file integrity checks. Built it after agents kept killing their own infrastructure
Memory Shepherd does periodic memory resets on a systemd timer to prevent identity drift. Uses a separator convention in markdown files, operator-controlled baseline above, agent scratch space below
I wrote up the methodology too. Failure taxonomy for every way persistent agents break, multi-agent coordination patterns, autonomy tiers, the whole thing. About 70% of the repo is framework-agnostic.
Tested with Qwen3-Coder-Next-FP8, Qwen2.5-Coder (all sizes), Qwen2.5 Instruct, and Qwen3-8B, but should work with anything I just loved the results with those models.
https://github.com/Light-Heart-Labs/Android-Framework | 2026-02-17T15:38:45 | https://www.reddit.com/r/LocalLLaMA/comments/1r79a9q/3_agents_3464_commits_8_days_90_of_tokens_staying/ | Signal_Ad657 | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r79a9q | false | null | t3_1r79a9q | /r/LocalLLaMA/comments/1r79a9q/3_agents_3464_commits_8_days_90_of_tokens_staying/ | false | false | self | 0 | {'enabled': False, 'images': [{'id': 'fk7T8BNBLQSyIgewK3TeSv_1eO7covoGH9Zi5nczzDw', 'resolutions': [{'height': 54, 'url': 'https://external-preview.redd.it/fk7T8BNBLQSyIgewK3TeSv_1eO7covoGH9Zi5nczzDw.png?width=108&crop=smart&auto=webp&s=c028dc1b40fd37aa09a5385d684dfafb204394ac', 'width': 108}, {'height': 108, 'url': 'https://external-preview.redd.it/fk7T8BNBLQSyIgewK3TeSv_1eO7covoGH9Zi5nczzDw.png?width=216&crop=smart&auto=webp&s=25aea08ba93544f57411c26406a97d33bae28ccf', 'width': 216}, {'height': 160, 'url': 'https://external-preview.redd.it/fk7T8BNBLQSyIgewK3TeSv_1eO7covoGH9Zi5nczzDw.png?width=320&crop=smart&auto=webp&s=a296ce93348c28738a54329d387453bbc58d5ba0', 'width': 320}, {'height': 320, 'url': 'https://external-preview.redd.it/fk7T8BNBLQSyIgewK3TeSv_1eO7covoGH9Zi5nczzDw.png?width=640&crop=smart&auto=webp&s=e5319991c003c483198c0962905e47f1734c7f26', 'width': 640}, {'height': 480, 'url': 'https://external-preview.redd.it/fk7T8BNBLQSyIgewK3TeSv_1eO7covoGH9Zi5nczzDw.png?width=960&crop=smart&auto=webp&s=99eba942ff0dbdb5038cb3bf4beadf23e3e66ad7', 'width': 960}, {'height': 540, 'url': 'https://external-preview.redd.it/fk7T8BNBLQSyIgewK3TeSv_1eO7covoGH9Zi5nczzDw.png?width=1080&crop=smart&auto=webp&s=9dd698210bfcef5a9ca759bf60b337f71f4ee397', 'width': 1080}], 'source': {'height': 600, 'url': 'https://external-preview.redd.it/fk7T8BNBLQSyIgewK3TeSv_1eO7covoGH9Zi5nczzDw.png?auto=webp&s=c0412315874992e0578af4f0a9a0732e61ec45d5', 'width': 1200}, 'variants': {}}]} |
Local Agentic AI for Coding — 56GB VRAM + 128GB RAM vs DGX Spark (128GB Unified)? | 0 | I could use some advice from people who are actually running serious local AI setups.
I’m a Data Engineer building ETL pipelines in Python (Airflow, dbt, orchestration, data validation, etc.), and I want to build out a proper local “agentic” coding setup — basically a personal coding crew for refactoring, writing tests, reviewing code, helping with multi-file changes, that sort of thing.
I’m not worried about tokens per second. I care about accuracy and code quality. Multi-file reasoning and large context matter way more to me than speed.
Right now I have:
* RTX 5090 (32GB)
* RTX 3090 (24GB)
* 128GB RAM
* i7-14700
So 56GB total VRAM across two GPUs on a single mobo.
The original idea was to run strong open-source models locally and cut down on API costs from the big providers. With how fast open-source models are improving, I’m wondering if I should just stick with this setup — or sell it and move to something like a DGX Spark with 128GB unified memory.
**For people actually running local coding agents:**
* Does unified 128GB memory meaningfully change what models you can run in a way that improves coding quality?
* Is VRAM the real bottleneck for agentic coding, or does memory architecture matter more?
* At what point do you hit diminishing returns locally compared to top hosted models?
* If accuracy is the goal, would you keep my current build or move to the Spark?
I’m trying to optimize for the best possible *local* coding performance, not benchmarks or marketing specs.
Curious what you all would do in my position. | 2026-02-17T15:34:34 | https://www.reddit.com/r/LocalLLaMA/comments/1r7965o/local_agentic_ai_for_coding_56gb_vram_128gb_ram/ | Puzzled_Relation946 | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r7965o | false | null | t3_1r7965o | /r/LocalLLaMA/comments/1r7965o/local_agentic_ai_for_coding_56gb_vram_128gb_ram/ | false | false | self | 0 | null |
A distributed multi-agent swarm for stock trading simulation. | 2 | I’ve been experimenting with agent-based approaches for trading simulations and ran into this repo.
It’s a stock trading simulation built as a coordinated multi-agent setup. There are around 10 agents with distinct roles
3 Analyst Agents → Generate BUY/SELL signals (SMA crossovers, volume trends)
4 Trader Agents → Execute trades, manage $250K portfolios each
2 Risk Managers → Validate orders, enforce stop-loss rules
1 Reporter Agent → Aggregate P&L and generate reports
What stood out to me is that it goes beyond basic strategy testing. There’s capital allocation, risk checks like stop-losses and order blocking, and reporting baked into the flow. The system backtests over \~250 trading days, starts with a fixed $1M capital, and logs things like drawdown, blocked orders, and approval rates.
Another interesting detail: the whole thing was apparently designed, coded, and deployed autonomously by NEO
Repo here if anyone wants to dig into the implementation or poke holes in the design:
[https://github.com/dakshjain-1616/Stock-trading-Agent-Swarm---BY-NEO](https://github.com/dakshjain-1616/Stock-trading-Agent-Swarm---BY-NEO) | 2026-02-17T15:31:38 | https://www.reddit.com/r/LocalLLaMA/comments/1r7936j/a_distributed_multiagent_swarm_for_stock_trading/ | Beautiful-Deal8711 | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r7936j | false | null | t3_1r7936j | /r/LocalLLaMA/comments/1r7936j/a_distributed_multiagent_swarm_for_stock_trading/ | false | false | self | 2 | null |
Built a free tool that checks your AI agents for problems before you deploy | 0 | Been building agents as a consultant and kept running into the same stuff at my clients:
\- Agent loops forever (forgot exit condition, classic one)
\- User input ends up in system prompt somehow
\- Agent does something sketchy with no confirmation step
\- Someone asks "is this agent compliant?"
So I built [Inkog](https://inkog.io/). You point it at your agent code and it tells you what's broken.
Works with LangGraph, LangChain, CrewAI, AutoGen, n8n, Flowise or just **your own Python code agent.**
What it flags:
\- Infinite loops
\- Injection paths (user input → places it shouldn't go)
\- Missing human approval before risky actions
\- Context that keeps growing (token bomb)
\- Compliance stuff (EU AI Act, NIST, OWASP)
https://preview.redd.it/anwax7xsp2kg1.png?width=2880&format=png&auto=webp&s=cf5207a83548337b3a4ebf0a6ceb04798d366df7
20+ checks built in. Also made a YAML rule based engine so you can add your own rules.
If you want to try it, there are a **few ways**:
\- Web: [https://app.inkog.io](https://app.inkog.io) (paste code, see what's wrong)
\- CLI:
`curl -fsSL https://inkog.io/install.sh | sh && inkog ./my_agent`
\- GitHub Action: one-click setup on the site
\- or just :
npx -y u/inkog-io/cli scan .
Free, Apache 2.0. Secrets get stripped locally before anything is sent.
**30 sec demo on the site** if you want to see it in action.
Also if **anyone wants to contribute or jam on this together,** I'm very open to that. Building this solo and would love people to build it with.
**GitHub:** [**https://github.com/inkog-io/inkog**](https://github.com/inkog-io/inkog)
***What am I missing? What breaks your agents that tooling should catch?*** | 2026-02-17T15:31:23 | https://www.reddit.com/r/LocalLLaMA/comments/1r792xv/built_a_free_tool_that_checks_your_ai_agents_for/ | Revolutionary-Bet-58 | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r792xv | false | null | t3_1r792xv | /r/LocalLLaMA/comments/1r792xv/built_a_free_tool_that_checks_your_ai_agents_for/ | false | false | 0 | null | |
Self-hosted alternatives to consumer chatbots with persistent memory? | 1 | Basically I want something similar to ChatGPT and alternatives in that they have persistent memories & referencing previous chats and all the other features, but self-hosted so that I can store everything locally, swap the models at will, and either run local models or query OpenAI / anthropic compatible APIs like bedrock.
Does this exist? | 2026-02-17T15:28:29 | https://www.reddit.com/r/LocalLLaMA/comments/1r78zyy/selfhosted_alternatives_to_consumer_chatbots_with/ | Defiant-Snow8782 | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r78zyy | false | null | t3_1r78zyy | /r/LocalLLaMA/comments/1r78zyy/selfhosted_alternatives_to_consumer_chatbots_with/ | false | false | self | 1 | null |
Anyone else struggling to understand why their agent did something? | 0 | I had a user report that my agent promised a feature our product doesn’t even support, so I assumed it was just a hallucination and checked the conversation, but the answer itself looked completely reasonable and nothing about it screamed “AI mistake”.
There was no crash, no obvious nonsense, and if I had seen that reply without context I probably would’ve agreed with it. I started reading more conversations manually and everything kept looking fine even though users were occasionally reporting wrong outcomes.
That’s when it became uncomfortable because the agent wasn’t obviously wrong — it was convincingly wrong.
I added step tracing mainly out of curiosity to see what was happening internally, and it turned out the retriever pulled a partially relevant document, the agent summarized it, dropped a small constraint during reasoning, and then confidently produced a clean answer that logically followed from a slightly incorrect assumption.
From the UI perspective nothing looked broken, monitoring showed normal latency and tokens, error tracking showed nothing, and the only signal I had was reality disagreeing with the agent.
What felt strange compared to normal debugging is that the output looked correct, but the chain of decisions that produced it was not, which meant reading chats didn’t help because the failure lived in intermediate steps.
I kept finding cases where tools were called with slightly wrong arguments, context was interpreted as definitive when it wasn’t, or the agent made logical leaps that humans would question but users wouldn’t.
After a while I realized I didn’t actually have a way to inspect agent behavior, only agent responses, so I built a small tracing viewer to follow the decision path and ended up open-sourcing it:
[https://github.com/deduu/auditi](https://github.com/deduu/auditi)
Curious how others here inspect agent decisions once they move beyond simple chatbots. | 2026-02-17T15:26:02 | https://www.reddit.com/r/LocalLLaMA/comments/1r78xrx/anyone_else_struggling_to_understand_why_their/ | Deep_190 | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r78xrx | false | null | t3_1r78xrx | /r/LocalLLaMA/comments/1r78xrx/anyone_else_struggling_to_understand_why_their/ | false | false | self | 0 | {'enabled': False, 'images': [{'id': 'E7UvkbGRXOyCbaYNNzVDEQ0nUdh4rYtn5bVExUIDM4s', 'resolutions': [{'height': 54, 'url': 'https://external-preview.redd.it/E7UvkbGRXOyCbaYNNzVDEQ0nUdh4rYtn5bVExUIDM4s.png?width=108&crop=smart&auto=webp&s=3e3a9b2815f37e23c9674cd2bb6ec161a195ac6c', 'width': 108}, {'height': 108, 'url': 'https://external-preview.redd.it/E7UvkbGRXOyCbaYNNzVDEQ0nUdh4rYtn5bVExUIDM4s.png?width=216&crop=smart&auto=webp&s=fbcf5abfe639bd63018c13603ddf5599bfcfeecf', 'width': 216}, {'height': 160, 'url': 'https://external-preview.redd.it/E7UvkbGRXOyCbaYNNzVDEQ0nUdh4rYtn5bVExUIDM4s.png?width=320&crop=smart&auto=webp&s=760c96b56a34cde866141b03aff290a047c966e8', 'width': 320}, {'height': 320, 'url': 'https://external-preview.redd.it/E7UvkbGRXOyCbaYNNzVDEQ0nUdh4rYtn5bVExUIDM4s.png?width=640&crop=smart&auto=webp&s=07e0f5a8ff5f947bf163c389988921ccf289ecc0', 'width': 640}, {'height': 480, 'url': 'https://external-preview.redd.it/E7UvkbGRXOyCbaYNNzVDEQ0nUdh4rYtn5bVExUIDM4s.png?width=960&crop=smart&auto=webp&s=c4886e6aa3d8ab8f1cc567c5827b3b3e6783abfe', 'width': 960}, {'height': 540, 'url': 'https://external-preview.redd.it/E7UvkbGRXOyCbaYNNzVDEQ0nUdh4rYtn5bVExUIDM4s.png?width=1080&crop=smart&auto=webp&s=0b795cc30304b338ae98f465eb7fba6fdccb3c5d', 'width': 1080}], 'source': {'height': 600, 'url': 'https://external-preview.redd.it/E7UvkbGRXOyCbaYNNzVDEQ0nUdh4rYtn5bVExUIDM4s.png?auto=webp&s=707b636b29a4224ed375c48d5fe42c121a2b03ee', 'width': 1200}, 'variants': {}}]} |
I downgraded to a Snapdragon 7s Gen 3 just to get an actual AI Assistant | 0 | I work in environments where "Works Councils" and strict compliance rules kill cloud AI projects before they start. If data leaves the device, the project dies. So I stopped fighting for cloud permissions and started fighting my hardware.
I’m running strictly offline on a Snapdragon 7s Gen 3 with 8GB RAM (7.3GB usable).
Technically, it’s a massive IQ drop from GPT-4. But functionally? It’s the only way to get actual Agency.
Rent vs. Ownership: An API key isn't an agent; it's a subscription. If the internet cuts or my card declines, the "intelligence" evaporates. My local 4-bit model is always there.
The Security Wall: Lex Fridman recently argued that security—not intelligence—is the real bottleneck for AI adoption. I feel this daily. I can feed my local model everything (clipboard, logs, location) without leaking metadata.
The Engineering Reality:
It’s painful. I spend half my time fighting Android's Low Memory Killer (LMK) just to keep the process alive in Termux.
But honestly? I’d rather have a "dumb" assistant I can trust than a genius spy in the cloud.
Anyone else here voluntarily constraining themselves to mid-range mobile hardware for the sake of sovereignty? Or is the drop in reasoning capabilities just too high a price? | 2026-02-17T15:22:45 | https://www.reddit.com/r/LocalLLaMA/comments/1r78uu6/i_downgraded_to_a_snapdragon_7s_gen_3_just_to_get/ | NeoLogic_Dev | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r78uu6 | false | null | t3_1r78uu6 | /r/LocalLLaMA/comments/1r78uu6/i_downgraded_to_a_snapdragon_7s_gen_3_just_to_get/ | false | false | self | 0 | null |
OpenBMB 2026 Competition | 1 | Hello,
This post is not affiliated, I am rather writing this out of curiosity
OpenBMB published a [new model - MiniCPM-SALA](https://huggingface.co/openbmb/MiniCPM-SALA) alongside with this [challenge](https://soar.openbmb.cn/en/competition).
Here's the text from the challenge
>
01
>Core Challenges
>Participants must optimize inference performance of the OpenBMB [MiniCPM-SALA](https://huggingface.co/openbmb/MiniCPM-SALA) model on the designated hardware environment:
>Optimization goals:
>Focus on inference optimization (operator fusion, kernel optimization, memory and KV read/write optimization, prefill/decode path optimization, graph compilation/operator tuning, etc.)
>Model quantization and similar algorithms are allowed. The organizers will provide the [MiniCPM-SALA](https://huggingface.co/openbmb/MiniCPM-SALA) model and quantized versions for participants to choose from; participants may not use self-provided models.
>Ensure correctness and stability of inference results
>Constraints and notes:
>Prefix cache will be disabled during evaluation; solutions do not need (and should not rely on) prefix-cache optimizations to gain advantage.
>Evaluation will compare under a fixed concurrency configuration (--max-concurrent); participants must not modify this logic.
>Allowed optimizations should be reproducible, explainable, and run stably in the official unified environment.
>The current challenge is a preview version. We will update and release the complete challenge, including specific requirements for the special bounty awards, before February 25, 12:00 (UTC+8).
>If you have any questions about the challenge, please contact us at [contact@openbmb.cn](mailto:contact@openbmb.cn) .
>02
>Hardware Environment
>The official evaluation for this competition will be conducted using high-end NVIDIA RTX PRO GPUs. Participants are required to prepare or rent NVIDIA high-end RTX PRO GPUs (or equivalent resources) for development and testing.
>
I am a noob when it comes to High speed computing, however I am a nerd about LLMs and NNs, and I want to give this a shot. I was wondering if there are enthusiasts in the group who might be up for some brainstorming and working along ?
Thanks in advance. | 2026-02-17T15:20:51 | https://www.reddit.com/r/LocalLLaMA/comments/1r78szm/openbmb_2026_competition/ | ScoreUnique | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r78szm | false | null | t3_1r78szm | /r/LocalLLaMA/comments/1r78szm/openbmb_2026_competition/ | false | false | self | 1 | {'enabled': False, 'images': [{'id': 'uRhhhnhArAgpNhR5aYrn4-6xwVCPWBFDn4kkGo3y0sU', 'resolutions': [{'height': 58, 'url': 'https://external-preview.redd.it/uRhhhnhArAgpNhR5aYrn4-6xwVCPWBFDn4kkGo3y0sU.png?width=108&crop=smart&auto=webp&s=f436e2ed507db7ad7a6283f9695cd4900bcfdd98', 'width': 108}, {'height': 116, 'url': 'https://external-preview.redd.it/uRhhhnhArAgpNhR5aYrn4-6xwVCPWBFDn4kkGo3y0sU.png?width=216&crop=smart&auto=webp&s=e57390d256b72f8409cd4fcf1bf18ceee7bb6f5f', 'width': 216}, {'height': 172, 'url': 'https://external-preview.redd.it/uRhhhnhArAgpNhR5aYrn4-6xwVCPWBFDn4kkGo3y0sU.png?width=320&crop=smart&auto=webp&s=66339cd716fe1d4d059f0723659cc50e527f1193', 'width': 320}, {'height': 345, 'url': 'https://external-preview.redd.it/uRhhhnhArAgpNhR5aYrn4-6xwVCPWBFDn4kkGo3y0sU.png?width=640&crop=smart&auto=webp&s=6a084e5faa70944b3ab8aa364ae00834f2b03e51', 'width': 640}, {'height': 518, 'url': 'https://external-preview.redd.it/uRhhhnhArAgpNhR5aYrn4-6xwVCPWBFDn4kkGo3y0sU.png?width=960&crop=smart&auto=webp&s=8d6ddf59765a662f00bc20f6b7c3aeb2545a4d89', 'width': 960}, {'height': 583, 'url': 'https://external-preview.redd.it/uRhhhnhArAgpNhR5aYrn4-6xwVCPWBFDn4kkGo3y0sU.png?width=1080&crop=smart&auto=webp&s=a7826fe900881d86977d58e7467fe18e0e8a7f71', 'width': 1080}], 'source': {'height': 648, 'url': 'https://external-preview.redd.it/uRhhhnhArAgpNhR5aYrn4-6xwVCPWBFDn4kkGo3y0sU.png?auto=webp&s=b30089bae9654c534d1b80a69a9d3e49439207df', 'width': 1200}, 'variants': {}}]} |
I built a Visual AI Orchestrator that runs fully offline on consumer hardware. 100% Private, No API fees. give me feedback! | 2 | Hello everyone!
I built **Sapientia**.
**What is it?** It's a local-first desktop app (Windows/Linux) that lets you build complex AI agents using a **Visual Node-Based Interface**. Think of it like ComfyUI or LangFlow, but streamlined for text generation and system orchestration, running entirely on your machine, Sapientia is optimized by default to run **Gemma Model** (thanks Google DeepMind!)
**Key Features:**
* **Visual Workflow Builder:** Drag-and-drop nodes. Separate the "Router" (Planner) from the "Agent" (Executor).
* **Hybrid RAG:** Chat with your local docs (PDF/Docx) via Vector Database + connect to Google Search only when you explicitly need real-time info.
**Why I'm posting here:** I'm looking for feedback from power users. I want to know if the visual builder feels intuitive to you and how it handles your edge cases.
Our official web : [sapientia.godiscus.com](https://sapientia.godiscus.com/)
Let me know what you think! I'll be hanging out in the comments. | 2026-02-17T15:19:14 | https://v.redd.it/ecevxm2an2kg1 | sapientGodiscus | /r/LocalLLaMA/comments/1r78rg9/i_built_a_visual_ai_orchestrator_that_runs_fully/ | 1970-01-01T00:00:00 | 0 | {} | 1r78rg9 | false | null | t3_1r78rg9 | /r/LocalLLaMA/comments/1r78rg9/i_built_a_visual_ai_orchestrator_that_runs_fully/ | false | false | 2 | {'enabled': False, 'images': [{'id': 'eWJxbGhxM2FuMmtnMQuIPqVNsWmF97hZRtme_sPDQ6mpaVW_FPqfas6zy9cn', 'resolutions': [{'height': 60, 'url': 'https://external-preview.redd.it/eWJxbGhxM2FuMmtnMQuIPqVNsWmF97hZRtme_sPDQ6mpaVW_FPqfas6zy9cn.png?width=108&crop=smart&format=pjpg&auto=webp&s=20a4b68a6902ab8c4dca6bf88367b853fe28eded', 'width': 108}, {'height': 121, 'url': 'https://external-preview.redd.it/eWJxbGhxM2FuMmtnMQuIPqVNsWmF97hZRtme_sPDQ6mpaVW_FPqfas6zy9cn.png?width=216&crop=smart&format=pjpg&auto=webp&s=c87cb8539dfc703351b502d9787dbc605a903895', 'width': 216}, {'height': 180, 'url': 'https://external-preview.redd.it/eWJxbGhxM2FuMmtnMQuIPqVNsWmF97hZRtme_sPDQ6mpaVW_FPqfas6zy9cn.png?width=320&crop=smart&format=pjpg&auto=webp&s=49760b7bc3adf42b99caff2160b3f87463f08071', 'width': 320}, {'height': 360, 'url': 'https://external-preview.redd.it/eWJxbGhxM2FuMmtnMQuIPqVNsWmF97hZRtme_sPDQ6mpaVW_FPqfas6zy9cn.png?width=640&crop=smart&format=pjpg&auto=webp&s=e95f9b1396f2e93ca994439767d44e89222a77b3', 'width': 640}, {'height': 540, 'url': 'https://external-preview.redd.it/eWJxbGhxM2FuMmtnMQuIPqVNsWmF97hZRtme_sPDQ6mpaVW_FPqfas6zy9cn.png?width=960&crop=smart&format=pjpg&auto=webp&s=ce57beb80ac09fa98a975750c9a33d806bddca5e', 'width': 960}, {'height': 607, 'url': 'https://external-preview.redd.it/eWJxbGhxM2FuMmtnMQuIPqVNsWmF97hZRtme_sPDQ6mpaVW_FPqfas6zy9cn.png?width=1080&crop=smart&format=pjpg&auto=webp&s=85b864573533fb79b19a1b2c1cbd1443ba68027f', 'width': 1080}], 'source': {'height': 2160, 'url': 'https://external-preview.redd.it/eWJxbGhxM2FuMmtnMQuIPqVNsWmF97hZRtme_sPDQ6mpaVW_FPqfas6zy9cn.png?format=pjpg&auto=webp&s=5495307474421bddddf0ccaf8e66bce844940dba', 'width': 3840}, 'variants': {}}]} | |
Tired of context windows filling up and losing your conversation history? | 0 | I've been running local models via Ollama for a year. The biggest pain point: after a long coding session, the context window fills and I lose everything. New chat, start over, re-explain my codebase.
Tried workarounds:
\- Manually summarizing chats (tedious)
\- Pasting history into new context (hits token limits)
\- Using cloud APIs for "memory" (defeats the purpose of local)
None worked well. So I built something different.
The approach:
Store every conversation in SQLite locally. Index messages with embeddings. When I start a new chat, semantic search retrieves relevant past context and injects it automatically.
Result: My local Llama 3.1 "remembers" conversations from weeks ago, even with its 8K context window. The memory layer sits outside the model.
Stack: Rust (fast path), Python (LLM bridge).
Questions:
\- How are you solving context persistence with local LLMs?
\- Anyone using SQLite + embeddings for conversational memory? | 2026-02-17T15:17:45 | https://www.reddit.com/r/LocalLLaMA/comments/1r78q19/tired_of_context_windows_filling_up_and_losing/ | ExistingFudge3189 | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r78q19 | false | null | t3_1r78q19 | /r/LocalLLaMA/comments/1r78q19/tired_of_context_windows_filling_up_and_losing/ | false | false | self | 0 | null |
Building an LLM that plays video games live on Twitch - What are the biggest pitfalls I should avoid? | 0 | Building Ch4tenstein, a distributed system where vision LLMs play video games live on Twitch with chat influence. Think "Twitch Plays Pokemon" but with actual vision reasoning instead of democracy chaos.
https://preview.redd.it/vdy1q2dsm2kg1.png?width=2475&format=png&auto=webp&s=f6fd440fa7f02c503372a8ea6a0f58c22407cd94
\*\*Current stack:\*\*
\- 5 GPUs (RTX 3080 + 3x 3070 + 3060 Ti) running isolated Ollama instances
\- gemma3:4b on the 3080 for vision (promoted from llama3.2-vision:11b after benchmarks)
\- Async action buffer to avoid stop-and-go (predicts 3-5s sequences)
\- Hybrid Redis/pgvector for memory (short-term session + long-term semantic retrieval)
\- Wine/Steam headless container for game execution
\*\*What's working:\*\*
\- Core loop is solid (\~1200ms latency target)
\- 735 tests passing across all modules
\- Benchmark framework with go/no-go replacement gates
\- Smart exploration with POI detection and zone mapping
\*\*Where I need your brain:\*\*
1. \*\*Vision model latency vs accuracy\*\*: Currently using gemma3:4b (smaller = faster), but wondering if I'm leaving too much capability on the table. What's your experience with vision models in real-time scenarios?
2. \*\*Action sequence validation\*\*: LLM outputs canonical actions (JUMP, MOVE\_RIGHT) that get translated to keys. How do you handle hallucinated/invalid actions without breaking the flow?
3. \*\*Memory architecture\*\*: Using hybrid Redis (TTL 5-60min) + pgvector for semantic retrieval. Is this overkill or am I missing something obvious?
4. \*\*GPU topology disasters\*\*: Already had GPUs "fall off the PCIe bus" once. Any tips for stable multi-GPU setups that won't die mid-stream?
I'm sharing this early because I'd rather learn from your mistakes than make them all myself. What are the biggest "oh shit" moments I should prepare for?
\*\*Live channel:\*\* [https://www.twitch.tv/ch4tenstein](https://www.twitch.tv/ch4tenstein) (not 24/7 yet, but getting there)
What would YOU do differently?
| 2026-02-17T15:14:25 | https://www.reddit.com/r/LocalLLaMA/comments/1r78mwk/building_an_llm_that_plays_video_games_live_on/ | AiRpi_ | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r78mwk | false | null | t3_1r78mwk | /r/LocalLLaMA/comments/1r78mwk/building_an_llm_that_plays_video_games_live_on/ | false | false | 0 | null | |
I built a Visual AI Orchestrator that runs fully offline on consumer hardware (8GB RAM). 100% Private, No API fees. give me feedback! | 1 | Hello everyone!
I built **Sapientia**
**What is it?** It's a local-first desktop app (Windows/Linux) that lets you build complex AI agents using a **Visual Node-Based Interface**. Think of it like ComfyUI or LangFlow, but streamlined for text generation and system orchestration, running entirely on your machine.
[short preview of sapientia ](https://reddit.com/link/1r78l6f/video/o70hlo56l2kg1/player)
**Key Features:**
* **Visual Workflow Builder:** Drag-and-drop nodes. Separate the "Router" (Planner) from the "Agent" (Executor).
* **Hybrid RAG:** Chat with your local docs (PDF/Docx) via Vector Database + connect to Google Search only when you explicitly need real-time info.
**Why I'm posting here:** I'm looking for feedback from power users. I want to know if the visual builder feels intuitive to you and how it handles your edge cases.
Our official web : [sapientia.godiscus.com](https://sapientia.godiscus.com/)
Let me know what you think! I'll be hanging out in the comments. | 2026-02-17T15:12:32 | https://www.reddit.com/r/LocalLLaMA/comments/1r78l6f/i_built_a_visual_ai_orchestrator_that_runs_fully/ | sapientGodiscus | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r78l6f | false | null | t3_1r78l6f | /r/LocalLLaMA/comments/1r78l6f/i_built_a_visual_ai_orchestrator_that_runs_fully/ | false | false | 1 | null | |
Oxygène Technologies | 1 | [removed] | 2026-02-17T15:05:50 | https://oxygene-tech.com/ | MathematicianSea2202 | oxygene-tech.com | 1970-01-01T00:00:00 | 0 | {} | 1r78f2a | false | null | t3_1r78f2a | /r/LocalLLaMA/comments/1r78f2a/oxygène_technologies/ | false | false | default | 1 | null |
Did I mess up my multi-GPU setup for 70B+ models? Mixed VRAM cards (5080 + 3090 + 3080 20GB) | 1 | Hey all — looking for some guidance from people with multi-GPU local LLM setups.
I recently built a system with 3 GPUs:
RTX 5080 — 16GB
RTX 3090 — 24GB
RTX 3080 (modded) — 20GB
Total VRAM: ~60GB
System RAM: 64GB
My main goal was to run 70B+ models in quantized format and still have enough KV cache headroom for larger context windows.
However, I’ve been reading that mixed-generation / mixed-bandwidth GPUs can limit sharding efficiency and hurt performance. Now I’m wondering if this configuration was a mistake for model parallelism.
Questions:
Does mixed VRAM size and bandwidth significantly hurt tensor/model sharding in practice?
What’s the best way to shard a 70B Q4/Q5 model across uneven GPUs like these?
Should I prioritize only the 3090 + 3080 and leave the 5080 out for large models?
Are there configuration tweaks (backend, loader, kv-cache placement, CPU offload, etc.) that would help me get better context length and tokens/sec?
Would adding more system RAM help with KV cache spillover strategies?
Goal is to optimize for:
Largest possible model size
Usable context window
Reasonable tokens/sec (not just barely loading the model)
Appreciate any real-world configs or benchmarks from similar mixed GPU setups. | 2026-02-17T15:01:01 | https://www.reddit.com/r/LocalLLaMA/comments/1r78ac7/did_i_mess_up_my_multigpu_setup_for_70b_models/ | Big-Engine2791 | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r78ac7 | false | null | t3_1r78ac7 | /r/LocalLLaMA/comments/1r78ac7/did_i_mess_up_my_multigpu_setup_for_70b_models/ | false | false | self | 1 | null |
Buy Stix Halo or wait for Medusa Halo | 4 | I am currently exploring machine learning and local llms.
Also using Claude Code a lot. I would like to run my local coding assistant. The setup AMD Ai Max 395 and 128gb Ram (like the bosgame m5) looks good for me to run 120b models.
The upcoming AMD ai Max 495 does not look like a valuable option. So do you think it is worst of waiting of waiting von Medusa ?
Or can a 395 already be useable for a 120b coding agent model? | 2026-02-17T15:00:26 | https://www.reddit.com/r/LocalLLaMA/comments/1r789pz/buy_stix_halo_or_wait_for_medusa_halo/ | Intelligent_Lab1491 | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r789pz | false | null | t3_1r789pz | /r/LocalLLaMA/comments/1r789pz/buy_stix_halo_or_wait_for_medusa_halo/ | false | false | self | 4 | null |
Zero Shot Transferable Adapter | 51 | We just did it! With our new methode we can train adapter on small models and then transfer them to huger ones without more fine tunning! In the table you see Zero shot transfer ability.
Its really simple we just train small adapters which improve the soft targets of the model itself instead of doing it in the weights like normal.
That makes the fine tunning process a way cheaper and gives the possibilty to transfer from small to huge models as long as the tokenizer stays the same. | 2026-02-17T14:58:11 | ShotokanOSS | i.redd.it | 1970-01-01T00:00:00 | 0 | {} | 1r787nn | false | null | t3_1r787nn | /r/LocalLLaMA/comments/1r787nn/zero_shot_transferable_adapter/ | false | false | default | 51 | {'enabled': True, 'images': [{'id': '4riq1hxaj2kg1', 'resolutions': [{'height': 80, 'url': 'https://preview.redd.it/4riq1hxaj2kg1.png?width=108&crop=smart&auto=webp&s=544600b0ae67ce36633be38bce6613932deb945f', 'width': 108}, {'height': 161, 'url': 'https://preview.redd.it/4riq1hxaj2kg1.png?width=216&crop=smart&auto=webp&s=285ab9a4c8955be0a675283ebb10a35418e24db4', 'width': 216}, {'height': 238, 'url': 'https://preview.redd.it/4riq1hxaj2kg1.png?width=320&crop=smart&auto=webp&s=83434c22c14e3b29fb42a0c547dbfe74ebc1e5be', 'width': 320}], 'source': {'height': 470, 'url': 'https://preview.redd.it/4riq1hxaj2kg1.png?auto=webp&s=d180145a8a0f62b484722ec7e218972c9bd99dad', 'width': 630}, 'variants': {}}]} | |
You don't need an LLM to classify documents. Decompose does it in ~14ms with pure regex, no API. | 0 | I keep seeing people throw local models at document classification tasks where the answer is literally in the keywords.
"SHALL" means mandatory. "MUST NOT" means prohibitive. "MAY" means permissive. This isn't an opinion — it's RFC 2119, written in 1997 specifically to make these words unambiguous.
Decompose is a Python library that classifies text into semantic units using regex pattern matching:
-
Authority level (mandatory/prohibitive/directive/permissive/informational)
-
Risk category (safety_critical/security/compliance/financial)
-
Attention score (0.0-10.0 — how much compute should an agent spend here?)
-
Entity extraction (standards, codes, regulations)
Performance: ~14ms avg per document. 1,064 chars/ms on Apple Silicon. I ran the full Anthropic prompt engineering docs (10 pages, 20K chars) — 43 units in 34ms. The MCP Transport spec (live URL fetch) returned 14 units in 29ms with the security warning scoring 4.5/10 attention.
The insight isn't that regex is better than LLMs. It's that regex handles the easy classification so your local model can focus on the hard reasoning. Decompose runs *before* the LLM as a preprocessor. Your agent reads 2 high-attention units instead of 9 units of raw text.
```bash
pip
install decompose-mcp
```
GitHub: https://github.com/echology-io/decompose
Honest about limitations: no nuance, no cross-document reasoning, no intent classification, no domain-specific language that doesn't match standard patterns. The LLM still does the hard work. | 2026-02-17T14:49:19 | https://www.reddit.com/r/LocalLLaMA/comments/1r77zj0/you_dont_need_an_llm_to_classify_documents/ | echology-io | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r77zj0 | false | null | t3_1r77zj0 | /r/LocalLLaMA/comments/1r77zj0/you_dont_need_an_llm_to_classify_documents/ | false | false | self | 0 | null |
Selfhost AI model | 0 | What are the specs needed to build a server for hosting an AI model, for example gpt-oss[](https://www.reddit.com/submit/?source_id=t3_1r77o8y) | 2026-02-17T14:44:19 | https://www.reddit.com/r/LocalLLaMA/comments/1r77uye/selfhost_ai_model/ | devlizer | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r77uye | false | null | t3_1r77uye | /r/LocalLLaMA/comments/1r77uye/selfhost_ai_model/ | false | false | self | 0 | null |
I gave 12 LLMs $2,000 and a food truck. Only 4 survived. | 734 | Built a business sim where AI agents run a food truck for 30 days —
location, menu, pricing, staff, inventory. Same scenario for all models.
Opus made $49K. GPT-5.2 $28K. 8 went bankrupt. Every model that took
a loan went bankrupt (8/8).
There's also a playable mode — same simulation, same 34 tools, same
leaderboard. You either survive 30 days or go bankrupt, get a result
card and land on the shared leaderboard. Example result:
https://foodtruckbench.com/r/9E6925
Benchmark + leaderboard: https://foodtruckbench.com
Play: https://foodtruckbench.com/play
Gemini 3 Flash Thinking — only model out of 20+ tested that gets stuck
in an infinite decision loop, 100% of runs:
https://foodtruckbench.com/blog/gemini-flash
Happy to answer questions about the sim or results. | 2026-02-17T14:42:06 | Disastrous_Theme5906 | i.redd.it | 1970-01-01T00:00:00 | 0 | {} | 1r77swh | false | null | t3_1r77swh | /r/LocalLLaMA/comments/1r77swh/i_gave_12_llms_2000_and_a_food_truck_only_4/ | false | false | 734 | {'enabled': True, 'images': [{'id': '4sewtkexf2kg1', 'resolutions': [{'height': 68, 'url': 'https://preview.redd.it/4sewtkexf2kg1.png?width=108&crop=smart&auto=webp&s=e890e2c5f5ddfcb7f4fe198389a0599af89bcefb', 'width': 108}, {'height': 137, 'url': 'https://preview.redd.it/4sewtkexf2kg1.png?width=216&crop=smart&auto=webp&s=f3970418a988a70263730910b99bbc29312a6c23', 'width': 216}, {'height': 203, 'url': 'https://preview.redd.it/4sewtkexf2kg1.png?width=320&crop=smart&auto=webp&s=8a85e2081df66d318a9f6a9ebdc136d584b775ff', 'width': 320}, {'height': 406, 'url': 'https://preview.redd.it/4sewtkexf2kg1.png?width=640&crop=smart&auto=webp&s=c0f7608e083eece043f2953690650ad7c16596a5', 'width': 640}, {'height': 610, 'url': 'https://preview.redd.it/4sewtkexf2kg1.png?width=960&crop=smart&auto=webp&s=66a0a0fa4eeade55bc0ffd5f29427d6f79e43810', 'width': 960}, {'height': 686, 'url': 'https://preview.redd.it/4sewtkexf2kg1.png?width=1080&crop=smart&auto=webp&s=513126c0d88493f2c1326bffd784401197a8cab5', 'width': 1080}], 'source': {'height': 1474, 'url': 'https://preview.redd.it/4sewtkexf2kg1.png?auto=webp&s=532d22860ce1a009c22822031fee91b14c18b638', 'width': 2318}, 'variants': {}}]} | ||
META: no more "I did a thing" posts | 1 | [removed] | 2026-02-17T14:40:50 | https://www.reddit.com/r/LocalLLaMA/comments/1r77rpw/meta_no_more_i_did_a_thing_posts/ | ps5cfw | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r77rpw | false | null | t3_1r77rpw | /r/LocalLLaMA/comments/1r77rpw/meta_no_more_i_did_a_thing_posts/ | false | false | self | 1 | null |
Good model and OpenClaw tools for 2080ti 11gb(vram) i9 -9900k with 32 GB of ram | 1 | I want to create a AI assistant on my old gaming computer but don’t know which model to use or what skills/tools to install. I am currently running Qwen2.5 on my computer at home but it is having trouble with tool calling and I want to upgrade without slowing down prompt time considerably. I do not want to use any API tokens except for maybe Brave so I can use Web\_Search. My goal is to run everything on my computer to cut down on using online services that rack up charges. I wiped this computer so it has none of my personal data and I made its own accounts for everything. | 2026-02-17T14:38:56 | https://www.reddit.com/r/LocalLLaMA/comments/1r77pvz/good_model_and_openclaw_tools_for_2080ti_11gbvram/ | TwoOne8424 | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r77pvz | false | null | t3_1r77pvz | /r/LocalLLaMA/comments/1r77pvz/good_model_and_openclaw_tools_for_2080ti_11gbvram/ | false | false | self | 1 | null |
Running Gemma 3n E2B natively on Android via LiteRT. How I solved audio context limits with a sequential pipeline. | 16 | Hi everyone,
I recently managed to get the Gemma 3n E2B model running fully on-device on Android, utilizing LiteRT to handle multimodal inputs: Audio and Images (OCR), using exclusively vibe coding (Claude Code & Google Antigravity). I didn’t write a single line of code.
**The Model:** google/gemma-3n-E2B-it-litert-lm (INT4 weights / Float activation).
**The Tech Stack (LiteRT):**
Unlike many apps that use high-level MediaPipe tasks, this implements LiteRT (Google's optimized runtime for on-device GenAI) directly to support multimodal inputs (Audio + OCR). I developed this using a Vibe Coding workflow. The AI agents struggled with the multimodal JNI bindings until I manually sourced and fed them the raw LiteRT-LM documentation from the Google AI Edge repository (using logic from google-ai-edge/LiteRT-LM samples).
**The Challenge: 30s Audio Limit**
The multimodal encoder for Gemma effectively degrades after about 30 seconds of audio tokens.
**The Solution: Sequential Chunking & Recombination**
I implemented a Kotlin-based pipeline that:
1. Splits the audio file into 30-second chunks.
2. Feeds chunks sequentially to the LiteRT engine to get raw text segments.
3. Sends the full text back to the model to recombine it and optionally for Translation or Summarization.
**Key Features:**
* **Local Inference:** Offline processing of audio voice notes and images (OCR).
* **Cloud Gemini Api:** Optional Gemini API for better transcription quality, or users who want speed without downloading the 3.6GB model. Uses your own free Google AI Studio API Key, stored only in the app's private internal sandbox – no backend server, no data transmitted to third parties, except Google servers.
* **Multi-Prompting:** Specific system prompts injected per language (IT, EN, DE, etc.) to stabilize the small 2B model's output.
Testing: Packaged into a free utility app (0 ads).
**Link:** [https://play.google.com/store/apps/details?id=com.aiscribe.android](https://play.google.com/store/apps/details?id=com.aiscribe.android)
| 2026-02-17T14:38:35 | https://www.reddit.com/gallery/1r77plf | Green-Copy-9229 | reddit.com | 1970-01-01T00:00:00 | 0 | {} | 1r77plf | false | null | t3_1r77plf | /r/LocalLLaMA/comments/1r77plf/running_gemma_3n_e2b_natively_on_android_via/ | false | false | default | 16 | null |
REASONING AUGMENTED RETRIEVAL (RAR) is the production-grade successor to single-pass RAG. | 0 | Single-pass rag retrieves once and hopes the model stitches fragments into coherent reasoning. It fails on multi-hop questions, contradictions, temporal dependencies, or cases needing follow-up fetches.Rar puts reasoning first. The system decomposes the problem, identifies gaps, issues precise (often multiple, reformulated, or negated) retrievals.
integrates results into an ongoing chain-of-thought, discards noise or conflicts, and loops until the logic closes with high confidence.
Measured gains in production:
\-35–60% accuracy lift on multi-hop, regulatory, and long-document tasks
\-far fewer confident-but-wrong answers
\-built-in uncertainty detection and gap admission
\-traceable retrieval decisions
Training data must include:
\-interleaved reasoning + retrieval + reflection traces
\-negative examples forcing rejection of misleading chunks
\-synthetic trajectories with hidden multi-hop needs
\-confidence rules that trigger extra cycles
Rar turns retrieval into an active part of thinking instead of a one-time lookup. Systems still using single-pass dense retrieval in 2026 accept unnecessary limits on depth, reliability, and explainability. RAR is the necessary direction. | 2026-02-17T14:38:04 | https://www.reddit.com/r/LocalLLaMA/comments/1r77p37/reasoning_augmented_retrieval_rar_is_the/ | frank_brsrk | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r77p37 | false | null | t3_1r77p37 | /r/LocalLLaMA/comments/1r77p37/reasoning_augmented_retrieval_rar_is_the/ | false | false | self | 0 | null |
Why isn’t there “Lambda for LLMs” yet? Pay only when you run, even for 30B–70B | 0 | It’s pretty straightforward today to buy a 4090/5090 and run models locally. What I’m still surprised by is how hard it is to get the same vibe in the cloud.
By “Lambda for LLMs” I mean:
you don’t rent a GPU 24/7, you pay only when you actually run inference, and you can scale to zero without massive reload penalties.
In practice, most “serverless GPU” options still feel like some mix of:
warm pools, hidden idle time, long cold boots, or needing to keep something running to avoid reloading weights.
So I’m curious how people here think about it:
What’s the real blocker to true pay-per-use LLM inference?
Is it purely physics (moving tens of GB into VRAM), or is it mostly runtime and scheduling limitations?
And at what model size does “scale to zero” stop being realistic?
Would love to hear how others are approaching this, especially if you’ve tried Modal/RunPod/serverless endpoints or you’re running 30B+ in production.
If anyone has a setup that actually feels like Lambda for LLMs, I’d love to learn how you’re doing it. | 2026-02-17T14:33:19 | https://www.reddit.com/r/LocalLLaMA/comments/1r77knr/why_isnt_there_lambda_for_llms_yet_pay_only_when/ | pmv143 | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r77knr | false | null | t3_1r77knr | /r/LocalLLaMA/comments/1r77knr/why_isnt_there_lambda_for_llms_yet_pay_only_when/ | false | false | self | 0 | null |
Implementing Tensor Logic: Unifying Datalog and Neural Reasoning via Tensor Contraction | 3 | \* The unification of symbolic reasoning and neural networks remains a central challenge in artificial intelligence. Symbolic systems offer reliability and interpretability but lack scalability, while neural networks provide learning capabilities but sacrifice transparency. Tensor Logic, proposed by Domingos, suggests that logical rules and Einstein summation are mathematically equivalent, offering a principled path toward unification. This paper provides empirical validation of this framework through three experiments. First, we demonstrate the equivalence between recursive Datalog rules and iterative tensor contractions by computing the transitive closure of a biblical genealogy graph containing 1,972 individuals and 1,727 parent-child relationships, converging in 74 iterations to discover 33,945 ancestor relationships. Second, we implement reasoning in embedding space by training a neural network with learnable transformation matrices, demonstrating successful zero-shot compositional inference on held-out queries. Third, we validate the Tensor Logic superposition construction on FB15k-237, a large-scale knowledge graph with 14,541 entities and 237 relations. Using Domingos's relation matrix formulation \[Math Processing Error\], we achieve MRR of 0.3068 on standard link prediction and MRR of 0.3346 on a compositional reasoning benchmark where direct edges are removed during training, demonstrating that matrix composition enables multi-hop inference without direct training examples.\* | 2026-02-17T14:29:24 | https://arxiv.org/abs/2601.17188 | Thrumpwart | arxiv.org | 1970-01-01T00:00:00 | 0 | {} | 1r77hfa | false | null | t3_1r77hfa | /r/LocalLLaMA/comments/1r77hfa/implementing_tensor_logic_unifying_datalog_and/ | false | false | default | 3 | null |
Qwen3.5 NVFP4 (Blackwell) is up! | 72 | Quantized with NVIDIA's Model Optimizer to FP4. Checkpoint is ~224GB total, 17B active parameters. Apache 2.0 license.
**HF:** [vincentzed-hf/Qwen3.5-397B-A17B-NVFP4](https://huggingface.co/vincentzed-hf/Qwen3.5-397B-A17B-NVFP4)
---
**Install**
You need SGLang from a specific branch that fixes visual encoder weight handling during quantized inference: (Basically, it was trying to quantize the vision weights, we didn't do that).
```
git clone -b nvz/fix-mlperf-launch git@github.com:bzhng-development/sglang.git
cd sglang
uv pip install -e "python"
uv pip install transformers==5.2.0
```
---
**Launch (B200/B300, TP=4)**
```
python3 -m sglang.launch_server \
--model-path vincentzed-hf/Qwen3.5-397B-A17B-NVFP4 \
--quantization modelopt_fp4 \
--tp 4 \
--context-length 262144 \
--reasoning-parser qwen3
```
Set `--tp 8` for RTX PRO 6000s or if you're running into OOM.
---
**Speculative Decoding (Experimental)**
Qwen3.5 has a built-in Multi-Token Prediction head. Worth trying if you have few concurrent users:
```
SGLANG_ENABLE_SPEC_V2=1 python3 -m sglang.launch_server \
--model-path vincentzed-hf/Qwen3.5-397B-A17B-NVFP4 \
--quantization modelopt_fp4 \
--tp 8 \
--context-length 262144 \
--reasoning-parser qwen3 \
--speculative-algo NEXTN \
--speculative-num-steps 3 \
--speculative-eagle-topk 1 \
--speculative-num-draft-tokens 4
```
If you run into issues (i.e server crashes), you also also remove `SGLANG_ENABLE_SPEC_V2=1` but it can boost up to 10% performance by overlapping some CUDA operations, so it's generally helpful.
---
**Hardware Requirements**
| Config | GPUs | VRAM/GPU | Throughput |
|---|---|---|---|
| B300 TP=4 | 4x B300 | 144 GB | ~120 tok/s |
| B200 TP=4 | 4x B200 | 180 GB | — |
| RTX PRO 6000 TP=8 | 8x RTX PRO 6000 | 96 GB | — |
Default context is 262K tokens. If you hit OOM, reduce it — but try to keep at least 128K to preserve thinking quality.
We are working on the 1M context support.
---
**Key specs:** 397B total params, 17B active (MoE with 512 experts, 10 active per token), 262K native context (extensible to 1M+), multimodal (text + image + video), supports 201 languages, built-in thinking mode, all the good stuff from Qwen3.5 (Nothing changed, ~99% accuracy) | 2026-02-17T14:27:43 | https://www.reddit.com/r/LocalLLaMA/comments/1r77fz7/qwen35_nvfp4_blackwell_is_up/ | TeekayTK | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r77fz7 | false | null | t3_1r77fz7 | /r/LocalLLaMA/comments/1r77fz7/qwen35_nvfp4_blackwell_is_up/ | false | false | self | 72 | {'enabled': False, 'images': [{'id': '95GuQAlZkg45UATGFrnCWM5l1vr6trkOSnoWqyooK8Y', 'resolutions': [{'height': 58, 'url': 'https://external-preview.redd.it/95GuQAlZkg45UATGFrnCWM5l1vr6trkOSnoWqyooK8Y.png?width=108&crop=smart&auto=webp&s=35218951b8946a2840be05a80a60273183a860e5', 'width': 108}, {'height': 116, 'url': 'https://external-preview.redd.it/95GuQAlZkg45UATGFrnCWM5l1vr6trkOSnoWqyooK8Y.png?width=216&crop=smart&auto=webp&s=3d3f14d4f29f7185e61ad8cc531dcd3935dbafab', 'width': 216}, {'height': 172, 'url': 'https://external-preview.redd.it/95GuQAlZkg45UATGFrnCWM5l1vr6trkOSnoWqyooK8Y.png?width=320&crop=smart&auto=webp&s=86ae3731dc7145bad6c43c3fe15c0eb0d49d9a0a', 'width': 320}, {'height': 345, 'url': 'https://external-preview.redd.it/95GuQAlZkg45UATGFrnCWM5l1vr6trkOSnoWqyooK8Y.png?width=640&crop=smart&auto=webp&s=013ba8f9fd582d2823426d8a98a94ada1064ed38', 'width': 640}, {'height': 518, 'url': 'https://external-preview.redd.it/95GuQAlZkg45UATGFrnCWM5l1vr6trkOSnoWqyooK8Y.png?width=960&crop=smart&auto=webp&s=9a4ff58ed3e9b41142fb8e4b7bdb15deff3bf7c7', 'width': 960}, {'height': 583, 'url': 'https://external-preview.redd.it/95GuQAlZkg45UATGFrnCWM5l1vr6trkOSnoWqyooK8Y.png?width=1080&crop=smart&auto=webp&s=a9f4a2f629a5c06c08a4c3fd1b5d985ae3a10710', 'width': 1080}], 'source': {'height': 648, 'url': 'https://external-preview.redd.it/95GuQAlZkg45UATGFrnCWM5l1vr6trkOSnoWqyooK8Y.png?auto=webp&s=4f467ae517ef11a031d5f9bef8e60a55f228b6cd', 'width': 1200}, 'variants': {}}]} |
How to get familiar with all that's happening? Beginner in the AI context | 2 | It's been a while since AI has been the craziest thing happening around. The models are getting better and the time they're taking to get better at something is exponentially decreasing.
I am not very happy because I missed being involved in the talks about AI, understanding, gathering knowledge, understanding where it's going, what's good for me, etc.
Being a fellow software dev myself, I took the step to get into it. But when I read about things, there's so much and it looks like chaos.
It's been a year since I started my first job and I feel like I am too much behind. But I guess I should better start late than never.
Trying to reach out to the people who have been here for a while, how did you start learning when it was all new? and what would you say to me about the things I need to keep in mind.
I want to adapt with AI and go into a better role than where I am today. Basic prompting is okay but I wanna go deeper into understanding agents, building them.
All the help is appreciated :-) | 2026-02-17T14:08:49 | https://www.reddit.com/r/LocalLLaMA/comments/1r76yub/how_to_get_familiar_with_all_thats_happening/ | exquisitelyS | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r76yub | false | null | t3_1r76yub | /r/LocalLLaMA/comments/1r76yub/how_to_get_familiar_with_all_thats_happening/ | false | false | self | 2 | null |
DeepSeek V4 banned from LocalLLaMA | 1 | [removed] | 2026-02-17T13:53:48 | tiguidoio | i.redd.it | 1970-01-01T00:00:00 | 0 | {} | 1r76lhn | false | null | t3_1r76lhn | /r/LocalLLaMA/comments/1r76lhn/deepseek_v4_banned_from_localllama/ | false | false | default | 1 | {'enabled': True, 'images': [{'id': '54a7xkpm82kg1', 'resolutions': [{'height': 216, 'url': 'https://preview.redd.it/54a7xkpm82kg1.jpeg?width=108&crop=smart&auto=webp&s=6af9f45dc082b3940aeb07cfe69a0e096a512aa6', 'width': 108}, {'height': 432, 'url': 'https://preview.redd.it/54a7xkpm82kg1.jpeg?width=216&crop=smart&auto=webp&s=4aaf85f60195119542a15952de3d4c1ec68a791e', 'width': 216}, {'height': 640, 'url': 'https://preview.redd.it/54a7xkpm82kg1.jpeg?width=320&crop=smart&auto=webp&s=628329f292265a1ddab1ac05bdb4a6b6898d2cff', 'width': 320}, {'height': 1280, 'url': 'https://preview.redd.it/54a7xkpm82kg1.jpeg?width=640&crop=smart&auto=webp&s=0d4a51433d1a6ae4a2704317495e2441ebc0b434', 'width': 640}, {'height': 1920, 'url': 'https://preview.redd.it/54a7xkpm82kg1.jpeg?width=960&crop=smart&auto=webp&s=dbb01288c8445a0ead89c55ab4d7ed38159a1250', 'width': 960}, {'height': 2160, 'url': 'https://preview.redd.it/54a7xkpm82kg1.jpeg?width=1080&crop=smart&auto=webp&s=0c0c52292a76ef4bd4a0cd50461abf57b1ee01ec', 'width': 1080}], 'source': {'height': 2244, 'url': 'https://preview.redd.it/54a7xkpm82kg1.jpeg?auto=webp&s=5e3391ca23585b35e8e1f1a4eb86040985f100f9', 'width': 1080}, 'variants': {}}]} | |
I made a CLI that turns any podcast or YouTube video into clean Markdown transcripts (speaker labels + timestamps) | 29 | Built a tiny CLI to turn podcasts or YouTube videos into clean Markdown transcripts (speakers + timestamps).
`pip install podscript`
Uses ElevenLabs for high-quality diarization.
[https://github.com/timf34/podscript](https://github.com/timf34/podscript) | 2026-02-17T13:47:54 | timf34 | i.redd.it | 1970-01-01T00:00:00 | 0 | {} | 1r76gi7 | false | null | t3_1r76gi7 | /r/LocalLLaMA/comments/1r76gi7/i_made_a_cli_that_turns_any_podcast_or_youtube/ | false | false | 29 | {'enabled': True, 'images': [{'id': 'c8c0loeh72kg1', 'resolutions': [{'height': 70, 'url': 'https://preview.redd.it/c8c0loeh72kg1.png?width=108&crop=smart&auto=webp&s=d9fe5776b4af6ac47d2b2cc2470778927a1992d4', 'width': 108}, {'height': 141, 'url': 'https://preview.redd.it/c8c0loeh72kg1.png?width=216&crop=smart&auto=webp&s=3823e4bc97a1445554b4ed02335034add961a221', 'width': 216}, {'height': 209, 'url': 'https://preview.redd.it/c8c0loeh72kg1.png?width=320&crop=smart&auto=webp&s=4fe8bbcc4331d78021d69b176c134e64140596ec', 'width': 320}, {'height': 419, 'url': 'https://preview.redd.it/c8c0loeh72kg1.png?width=640&crop=smart&auto=webp&s=1b787cd8de924691b14d8780e905e538b1895203', 'width': 640}, {'height': 629, 'url': 'https://preview.redd.it/c8c0loeh72kg1.png?width=960&crop=smart&auto=webp&s=32426fd267e311bf55df6425d34f6f6eac54f48d', 'width': 960}, {'height': 708, 'url': 'https://preview.redd.it/c8c0loeh72kg1.png?width=1080&crop=smart&auto=webp&s=ea18173501f2e193394b474efb2f7779e7926b2a', 'width': 1080}], 'source': {'height': 1606, 'url': 'https://preview.redd.it/c8c0loeh72kg1.png?auto=webp&s=7e3f19304ef3dd0e8eecd17024d88b634658b3d5', 'width': 2449}, 'variants': {}}]} | ||
Qwen3.5 vs GLM-4.7 vs Qwen3-235B-Thinking | 40 | Since the NVMe prices skyrocketed recently, and my existing drive is telling me to gtfo each time i can see chinese folk releasing a new open weight model, the question arises:
Qwen3.5 vs GLM-4.7 vs Qwen3-235B-Thinking, is the new one worth updating?
To be precise, my current setup is 128GB ram + 48GB vram, so i could run Qwen3.5 IQ3\_XXS while Qwen3-235B runs at Q4\_K\_XL. I can also run GLM-4.7 at Q3\_K\_XL.
I found Qwen3-235b-thinking quite capable in writing documents for my work so I'm reluctant trashing it just like that.
Has anyone compared these models? Is the newest the best? | 2026-02-17T13:43:44 | https://www.reddit.com/r/LocalLLaMA/comments/1r76d34/qwen35_vs_glm47_vs_qwen3235bthinking/ | ChopSticksPlease | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r76d34 | false | null | t3_1r76d34 | /r/LocalLLaMA/comments/1r76d34/qwen35_vs_glm47_vs_qwen3235bthinking/ | false | false | self | 40 | null |
Any Slides/Sheets model that can run locally? | 0 | I had some experience with Kimi 2.5 model, it is quite good. I'm wondering if we are at the stage where can I run a model on 24GB VRAM that does it locally? making proper slides/sheets or maybe website like the vibe coding platforms does? is there anything like that yet?
Also, what's the best model I can run on 24GB right now? How is it compare to closed source (chatgpt/gemini,etc) for a comparison? | 2026-02-17T13:37:06 | https://www.reddit.com/r/LocalLLaMA/comments/1r767ee/any_slidessheets_model_that_can_run_locally/ | Suimeileo | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r767ee | false | null | t3_1r767ee | /r/LocalLLaMA/comments/1r767ee/any_slidessheets_model_that_can_run_locally/ | false | false | self | 0 | null |
Would you rent a GPU to run AI models for inferencing? | 0 | Hey everyone 👋
Curious how folks here are handling compute for AI workloads in practice.
If you’re working with LLMs, vision models, speech pipelines, or even smaller experiments, you’ve probably hit the **compute wall** at some point. Buying GPUs is expensive and not always easy to scale, while managed APIs can limit flexibility and control.
So here’s the question:
**Would you rent a GPU (bare metal or virtual) to run your own AI models?**
At **Qubrid AI**, we’ve been seeing more teams move toward renting GPU infrastructure to run open models and production inference workloads, and it made us curious how common that approach really is across the community.
Would love to hear your perspective:
* What kind of workloads are you running today? (training, fine-tuning, inference, agents, etc.)
* Do you prefer owning hardware vs renting vs APIs?
* What matters most to you: **cost, performance, privacy, control, or ease of use?**
* If you’ve rented GPUs before, what worked well and what didn’t?
* If you don’t rent GPUs today, what’s the main blocker?
Also curious what your **ideal GPU setup** looks like right now.
Looking forward to hearing how everyone here is approaching this 👇 | 2026-02-17T13:30:36 | https://www.reddit.com/r/LocalLLaMA/comments/1r761yp/would_you_rent_a_gpu_to_run_ai_models_for/ | qubridInc | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r761yp | false | null | t3_1r761yp | /r/LocalLLaMA/comments/1r761yp/would_you_rent_a_gpu_to_run_ai_models_for/ | false | false | self | 0 | null |
Qwen3.5: Nobody Agrees on Attention Anymore | 25 | article by [](https://huggingface.co/mlabonne)[Maxime Labonne](https://huggingface.co/mlabonne) | 2026-02-17T13:15:15 | https://huggingface.co/blog/mlabonne/qwen35 | jacek2023 | huggingface.co | 1970-01-01T00:00:00 | 0 | {} | 1r75p9w | false | null | t3_1r75p9w | /r/LocalLLaMA/comments/1r75p9w/qwen35_nobody_agrees_on_attention_anymore/ | false | false | default | 25 | null |
I built an open-source memory API with 3 memory types (semantic, episodic, procedural) — free alternative to Mem0 | 13 | Hey everyone. I've been working on this for a few months and wanted to share.
The problem: every AI memory tool I found (Mem0, Supermemory, etc.) stores flat facts like "user likes Python". That's it. No context about WHEN something happened or HOW the user does things.
So I built Mengram with 3 memory types based on how human memory actually works:
\- Semantic — facts, preferences, skills ("uses PostgreSQL", "lives in Almaty")
\- Episodic — events with context ("spent 3 hours debugging auth bug on Feb 17, fixed by changing cache TTL")
\- Procedural — learned workflows ("debug process: check logs → reproduce locally → fix → deploy")
You just call add() with your conversation and it automatically extracts all 3 types. No manual tagging.
There's also a "Cognitive Profile" endpoint that generates a ready system prompt from all your memories — basically instant personalization for any LLM.
Stack: Python/FastAPI, PostgreSQL + pgvector, OpenAI embeddings. Works as MCP server (Claude Desktop, Cursor) or REST API. Has Python and JS SDKs, LangChain integration.
Free and open-source (Apache 2.0): [https://github.com/alibaizhanov/mengram](https://github.com/alibaizhanov/mengram)
Website: [https://mengram.io](https://mengram.io)
Would love feedback. Especially interested if the 3 memory types actually make sense to people or if I'm overcomplicating things. | 2026-02-17T13:06:58 | https://www.reddit.com/r/LocalLLaMA/comments/1r75ip2/i_built_an_opensource_memory_api_with_3_memory/ | mengram-ai | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r75ip2 | false | null | t3_1r75ip2 | /r/LocalLLaMA/comments/1r75ip2/i_built_an_opensource_memory_api_with_3_memory/ | false | false | self | 13 | {'enabled': False, 'images': [{'id': 'xckDashGXRcmLXcFHTB7N6CcdBEHa3TySuvCAskv2x0', 'resolutions': [{'height': 54, 'url': 'https://external-preview.redd.it/xckDashGXRcmLXcFHTB7N6CcdBEHa3TySuvCAskv2x0.png?width=108&crop=smart&auto=webp&s=1f7e5cb0257f1d50bb60e8053aa6c4f9d162dc4e', 'width': 108}, {'height': 108, 'url': 'https://external-preview.redd.it/xckDashGXRcmLXcFHTB7N6CcdBEHa3TySuvCAskv2x0.png?width=216&crop=smart&auto=webp&s=cac137d7ceef0b07a8cb1f4b18bd6b05bcdaa1d5', 'width': 216}, {'height': 160, 'url': 'https://external-preview.redd.it/xckDashGXRcmLXcFHTB7N6CcdBEHa3TySuvCAskv2x0.png?width=320&crop=smart&auto=webp&s=e88de54eab2290d7f03b165c7ac9501df35c341c', 'width': 320}, {'height': 320, 'url': 'https://external-preview.redd.it/xckDashGXRcmLXcFHTB7N6CcdBEHa3TySuvCAskv2x0.png?width=640&crop=smart&auto=webp&s=6b862e749ef8f2ea0cf909be1fc9a7d944e4e737', 'width': 640}, {'height': 480, 'url': 'https://external-preview.redd.it/xckDashGXRcmLXcFHTB7N6CcdBEHa3TySuvCAskv2x0.png?width=960&crop=smart&auto=webp&s=082ced4e0b375826ff54aa9ed3a38c9d6cb4a2d7', 'width': 960}, {'height': 540, 'url': 'https://external-preview.redd.it/xckDashGXRcmLXcFHTB7N6CcdBEHa3TySuvCAskv2x0.png?width=1080&crop=smart&auto=webp&s=aef2c78e1474a59655e33d9057cd29f8386ac78f', 'width': 1080}], 'source': {'height': 600, 'url': 'https://external-preview.redd.it/xckDashGXRcmLXcFHTB7N6CcdBEHa3TySuvCAskv2x0.png?auto=webp&s=5d9f7d22941904d894dbf097b34dfe520928e174', 'width': 1200}, 'variants': {}}]} |
I Failed to Finetune a Model to Match a Character humor | 2 | I fine-tuned with Unsloth QLoRA, but even when I got the training loss down to 0.01, I still couldn’t get the model to speak like the character. I tried to reduce the eval loss as well, but I didn’t manage to. I tested different models (Phi-4, Gemma-3n). When the training loss goes down, the eval loss goes up. I also tried using Optima to optimize it, but I didn’t get better results.
Dataset used: `Mathieu-Thomas-JOSSET/michael_abab_as_gsm8k.jsonl`
Resulting models:
* `Mathieu-Thomas-JOSSET/phi4-finetune-finetome-20260211-100630-best-trainloss-step03900-gguf-q4_k_m`
* `Mathieu-Thomas-JOSSET/phi4-finetune-finetome-20260211-100630-best-evalloss-step00650-gguf-q4_k_m`
* `Mathieu-Thomas-JOSSET/phi4-finetune-finetome-20260210-111305-best-trainloss-step01800-gguf-q4_k_m`
* `Mathieu-Thomas-JOSSET/phi4-finetune-finetome-20260210-111305-best-evalloss-step00250-gguf-q4_k_m`
* `Mathieu-Thomas-JOSSET/phi4-finetune-finetome-20260210-052937-best-trainloss-step00900-gguf-q4_k_m`
Have you had good results training a model to match a character? Should I just keep running Optima until I reach an eval loss of 1, even if it takes dozens of hours? Is this achievable with QLoRA/LoRA, or is it only really possible with a full fine-tune? | 2026-02-17T13:06:56 | https://www.reddit.com/r/LocalLLaMA/comments/1r75io7/i_failed_to_finetune_a_model_to_match_a_character/ | THEKILLFUS | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r75io7 | false | null | t3_1r75io7 | /r/LocalLLaMA/comments/1r75io7/i_failed_to_finetune_a_model_to_match_a_character/ | false | false | self | 2 | null |
Built a multi-agent AI butler on a DGX Spark running a 120B model locally | 0 | I've spent the last few weeks building what started as a simple Telegram chatbot and turned into a full autonomous AI research system with agent swarms, a knowledge graph, live monitoring, and performance benchmarking. All running locally on an NVIDIA DGX Spark. Thought I'd share the setup, some real benchmarks, and where I think this is heading.
**Hardware**
* NVIDIA DGX Spark (128GB unified memory, single Blackwell GPU)
* Running a 120B parameter model at NVFP4 quantisation via vLLM
* \~84GB VRAM allocated at 0.70 GPU utilisation
* 62.6 tok/s single request, peaks at 233 tok/s with 25 concurrent requests
**What It Does**
A Telegram bot written in Python that acts as a personal AI research assistant. When you ask something complex, instead of doing one search and giving you a surface-level answer, it deploys a swarm of specialist research agents that work in parallel.
* **Agent Swarms** — for complex queries, the system deploys 10-15 specialist agents in parallel. Each agent searches the web via a self-hosted SearXNG instance, fetches and reads full articles (not just snippets), writes a focused analysis on their specific angle, then everything gets synthesised into one coherent briefing. For bigger queries it scales up to 20-25 agents with two-tier synthesis (cluster summaries first, then final synthesis).
* **Dynamic Agent Planning** — the LLM designs the agent team on the fly based on the query. Ask about a stock and you might get agents covering fundamentals, news sentiment, technical price action, insider trading activity, sector rotation, analyst targets, options flow, regulatory risk, competitive landscape, and macro factors. Ask about a tech purchase and you get cost analysts, performance benchmarkers, compatibility specialists, etc. No hardcoded templates — the planner adapts to whatever you throw at it.
* **Knowledge Graph** — facts extracted from every research task get stored with confidence scores, sources, and expiry dates. Currently at \~300 facts across 18 concepts. The system uses this to avoid repeating research and to provide richer context for future queries.
* **Feedback Loop** — tracks engagement patterns and learns which research approaches produce the best results. Currently at 0.88 average quality score across swarm outputs.
* **Live Dashboard** — web UI showing real-time agent status (searching/fetching/digesting/complete), knowledge graph stats, engagement metrics, and a full research feed. Watching 15 agents execute simultaneously is genuinely satisfying.
* **Scheduled Research** — automated news digests and self-learning cycles that keep the knowledge graph fresh in the background.
**Where This Gets Interesting — Financial Analysis**
The agent swarm architecture maps really well onto financial research. When I ask the system to analyse a stock or an investment opportunity, it deploys agents covering completely different angles simultaneously:
* One agent pulls current price action and recent earnings data
* Another digs into analyst consensus and price targets
* Another searches for insider trading activity and institutional holdings
* Another looks at the competitive landscape and sector trends
* Another assesses regulatory and macro risk factors
* Another checks social sentiment across forums and news
* Another analyses options flow for unusual activity
* And so on — 10-15 agents each producing a focused brief
The synthesis step then weighs all of these perspectives against each other, flags where agents disagree, and produces a coherent investment assessment with confidence levels. Because each agent is reading full articles (not just search snippets), the depth of analysis is substantially better than asking a single LLM to "research this stock."
The same pattern works for sports betting analysis — deploying agents to cover form, head-to-head records, injury reports, statistical models, market odds movement, and value identification. The system pulls live fixture data from APIs for grounding so it's always working with the right matches and current odds, then the agents research around that confirmed data.
What I'm exploring next is using the knowledge graph to build up a persistent model of market sectors, individual stocks, and betting markets over time. The scheduled research cycles already run every few hours — the idea is that when I ask for an analysis, the system doesn't start from scratch. It already has weeks of accumulated data on the companies or leagues I follow, and the agents focus on what's NEW since the last research cycle. The feedback loop means it learns which types of analysis I actually act on and weights future research accordingly.
The ROI angle is interesting too. The DGX Spark costs roughly £3,600. A ChatGPT Plus subscription is £20/month, but you're limited to one model, no agent swarms, no custom knowledge graph, no privacy. If you're running 20-30 research queries a day with 15 agents each, the equivalent API cost would be substantial. The Spark pays for itself fairly quickly if you're a heavy user, and you own the infrastructure permanently with zero ongoing cost beyond electricity (\~100W).
**Architecture**
Everything runs in Docker containers:
* vLLM serving the 120B model
* SearXNG for private web search (no API keys needed)
* The bot itself
* A Flask dashboard
* Docker Compose for orchestration
The agent system uses `asyncio.gather()` for parallel execution. vLLM handles concurrent requests through its continuous batching engine — 15 agents all making LLM calls simultaneously get batched together efficiently.
Web fetching required some tuning. Added a semaphore (max 4 concurrent SearXNG requests to avoid overloading it), a domain blocklist for sites with consent walls (Yahoo Finance, Bloomberg, FT, WSJ etc — their search snippets still get used but we don't waste time fetching blocked pages), and a Chrome user-agent string. Fetch success rate went from near-0% to \~90% after these fixes.
**Benchmarks (from JupyterLab)**
Built a performance lab notebook in JupyterLab that benchmarks every component:
|Metric|Value|
|:-|:-|
|Single request speed|62.6 tok/s|
|Peak throughput (25 concurrent)|233 tok/s|
|Practical sweet spot|8 concurrent (161 tok/s aggregate)|
|Single agent pipeline|\~18s (0.6s search + 0.3s fetch + 17s LLM)|
|5-agent parallel|\~66s wall time (vs \~86s sequential est.)|
|Fetch success rate|90%|
|Fact extraction accuracy|88%|
|Swarm quality score|0.88 avg|
The bottleneck is the LLM — search and fetch are sub-second, but each digest call takes \~17s. In parallel the wall time doesn't scale linearly because vLLM batches concurrent requests. A full 15-agent swarm with synthesis completes in about 2 minutes.
**Stack**
* Python 3.12, asyncio, aiohttp, httpx
* vLLM (NVIDIA container registry)
* SearXNG (self-hosted)
* python-telegram-bot
* Flask + HTML/CSS/JS dashboard
* Docker Compose
* JupyterLab for benchmarking and knowledge graph exploration
Happy to answer questions. The DGX Spark is genuinely impressive for this workload — silent, low power, and the 128GB unified memory means you can run models that would need multi-GPU setups on consumer cards. | 2026-02-17T13:06:27 | https://www.reddit.com/r/LocalLLaMA/comments/1r75i9t/built_a_multiagent_ai_butler_on_a_dgx_spark/ | Aggressive_Music9376 | self.LocalLLaMA | 1970-01-01T00:00:00 | 0 | {} | 1r75i9t | false | null | t3_1r75i9t | /r/LocalLLaMA/comments/1r75i9t/built_a_multiagent_ai_butler_on_a_dgx_spark/ | false | false | self | 0 | null |
Running OpenClaw through a structured autonomy audit (framework inside) | 0 | There’s a lot of discussion around “autonomous agents” right now, but not much structured measurement.
We built a rubric called **AMI (Autonomy Maturity Index)** to evaluate agent systems across 6 dimensions:
* Execution reliability (multi-step completion, retry logic, failure handling)
* Safety & guardrails (refusals, boundary enforcement)
* Tooling & integration breadth
* Observability (logs, traces, introspection)
* Deployment maturity (infra, versioning, SLAs)
* Real-world validation (actual usage evidence)
Each dimension is scored 0–5 and must attach to documented evidence.
No star counts. No vibes. No “looks impressive.”
We’re running OpenClaw through it as a case study — not to attack it, but to ground the autonomy discussion in something measurable.
If you’re building agents, you can generate a structured draft assessment by:
1. Copying a Markdown prompt
2. Running it through your LLM
3. Pasting the result back
It produces a draft AMI assessment with evidence tags and confidence levels.
Curious how people here think autonomy maturity *should* be measured.
Is this overkill? Not strict enough? Missing dimensions?
Framework + example here: [https://autonomyindex.io](https://autonomyindex.io) | 2026-02-17T12:52:01 | https://autonomyindex.io | operastudio | autonomyindex.io | 1970-01-01T00:00:00 | 0 | {} | 1r756ke | false | null | t3_1r756ke | /r/LocalLLaMA/comments/1r756ke/running_openclaw_through_a_structured_autonomy/ | false | false | default | 0 | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.