aifeed.fyi - AI news today

19 January 2026

Ai Top News

Models

Tools

reddit.com

I built a Claude Code skill where 17 agents work as a dev team - and it learns from every build

I built a multi-agent AI workflow in RoR a few months ago. I ran 140+ test builds and just converted it to a Claude Skill. Here it is.

PM agent scopes features, assigns specialized agents, enforces a 98% quality gate before shipping. 17 agents, multiple working in parallel per feature.

**The agents:**

* **PM** \- Orchestrator, scopes features, assigns agents
* **Discovery** \- Requirements → scope.yaml
* **Designer** \- Design tokens, semantic registry, component specs
* **Backend** \- API, database, business logic
* **Frontend** \- UI components using semantic classes
* **Docs** \- README, API docs
* **DevOps** \- Docker, CI/CD, deployment
* **QA** \- Unit/integration tests
* **Security** \- Vulnerability scanning
* **CodeReview** \- Quality analysis
* **Performance** \- Optimization
* **Demo** \- User perspective critique
* **E2E** \- Playwright browser testing, screenshot capture
* **Visual QA** \- Claude vision screenshot analysis
* **Data Flow** \- Schema sync, placeholder detection
* **Bugfix** \- Systematic debugging (reproduce → trace → isolate → fix → verify)
* **Conductor** \- Quality gate (98/100 required)

7 modes: greenfield, iteration, bugfix, refactor, UI polish, migration, audit.

Fairly stack/project agnostic.

Pairs with aimem (an AI memory package I built) for cross-project learning - theoretically gets better with each build.

**Fair warning:** You still need dev/architecture skills to finish it out and put the trim work on. This isn't no-code magic. But it gives you a solid structure to start with and I have learned a ton working on it.

Pretty cool IMHO. Feedback/suggestions welcome. Use as you please.

\*\* This is a token hog. Results may vary. :-)

--- TOP COMMENTS ---
This sounds impressive on paper, but it seriously overstates what is actually happening.

To get anything close to this working, you would need to define everything up front. And I mean everything. Data models, payloads, API contracts, routes, schemas, user flows, design systems, component behaviour, edge cases. That is hours or days of senior level architecture and product thinking before the first agent even runs.

At that point, the hard work is already done.

Once you have that level of detail, generating code, tests, docs, and pipelines is the easy part. You are not “parallelising engineering”, you are front loading it, then automating boilerplate. Which is fine, but it is not the revolution it is being sold as.

The idea that you can hand wave that complexity away with a PM agent and a 98 percent quality gate is fantasy. Software quality is not a score an AI gives another AI. It is correctness in real world usage, maintainability over time, and fitness for an evolving domain. None of that can be validated internally by the system itself.

Parallel agents also do not solve the real constraints of software development. Architecture, domain modelling, UX tradeoffs, and test strategy are inherently sequential and conversational. Spawning more agents just creates more conflicting assumptions that a human still has to reconcile.

This kind of setup can be useful for scaffolding greenfield CRUD apps or speeding up boilerplate once decisions are already made. But it does not replace engineering judgement, product discovery, or QA thinking. It just moves the thinking earlier and hides it behind orchestration.

The giveaway is the disclaimer at the end. “You still need dev and architecture skills to finish it out.” Exactly. Without that, this system confidently generates large volumes of plausible looking but fragile software.

Useful tool. Interesting experiment. Not autonomous software delivery.

---

this looks like huge waste of tokens..

5h ago

Open Source

/r/LocalLLaMA

CPA-Qwen3-8B-v0: A Specialized LLM for Accounting, Auditing, and Regulatory Compliance

Hi everyone, just sharing a model release that might be useful for those working in accounting technology, financial auditing, or building tools for CPAs.

Model on Hugging Face: [https://huggingface.co/AudCor/cpa-qwen3-8b-v0](https://huggingface.co/AudCor/cpa-qwen3-8b-v0)

CPA-Qwen3-8B-v0 is a specialized fine-tune of Qwen3-8B, trained by AudCor on the Finance-Instruct-500k dataset. Unlike general financial models, this model is specifically optimized to adopt the persona of a Certified Public Accountant (CPA).

Key capabilities:

* CPA Persona & Professional Skepticism: It frames answers with the accuracy and caution expected of a licensed professional, rather than just generating generic financial text.
* Regulatory Adherence: Strong knowledge of GAAP, IFRS, and tax codes, suitable for interpreting complex compliance requirements.
* Exam-Grade Reasoning: Benchmarked against the logic required for rigorous CPA exam problems (FAR, AUD, REG), including handling complex multi-step scenarios.

\---

**(Or if you prefer my raw post before AI rewrite it)**

Hey everyone, I wanted to share a project I've been working on. It's a fine-tune of Qwen3-8B specifically targeted at the accounting domain (CPA stuff, GAAP, IFRS, Auditing).

Most "finance" models are just trained on general financial news or stock data. I trained this one on the `Finance-Instruct-500k` dataset to actually handle strict regulatory questions and audit logic. It's meant to act more like a professional accountant than a stock broker.

Link: [https://huggingface.co/AudCor/cpa-qwen3-8b-v0](https://huggingface.co/AudCor/cpa-qwen3-8b-v0)

Let me know if you find it useful or if it hallucinates on any specific tax codes.

--- TOP COMMENTS ---
This looks super promising, especially for someone who deals with tax prep software. Been looking for something that actually understands the difference between GAAP and tax basis instead of just spitting out generic finance advice

How's it handle depreciation schedules and Section 179 calculations? Those seem to trip up most models I've tested

---

Will it help me with tax evasion?..

21h ago

/r/LLMDevs

[Project Update] MemOS: How we handled mutable state for long-running agents (open source, MIT)

We kept running into weird issues when using standard RAG setups in long-running agent sessions. Retrieval was fine at first, but quickly became messy as soon as users started changing their minds. For example, someone says ‘I’m vegetarian,’ and a week later mentions, ‘actually, I'm not anymore.’ RAG was basically a read-only encyclopedia, it couldn’t handle the state updates, and the agent kept giving awkward or outdated responses.

This turned out to matter a lot once we moved from simple Q&A to longer, ongoing conversations. The root of the problem wasn’t retrieval itself, but rather managing mutable state. We didn’t originally plan to build something dedicated to this, at first, we tried hacking it onto our existing vector DB setup, but it quickly got painful to debug.

Eventually, we ended up building MemOS, which focuses specifically on making memory editable and dynamic:

- Editable Memory (Read/Write/Update): Instead of append-only chunks, we store structured memory objects that can be modified or deprecated. No more stale or conflicting memories hanging around when user preferences change.
- Unified Memory Objects: We treat memories as structured containers—whether they're text snippets, documents, image metadata, or tool execution results—so retrieval stays consistent no matter the modality.
- Tracing Why Agents 'Remember' Things: One thing we didn't expect to matter (but absolutely did): figuring out exactly why our agent "believed" something. Vector search couldn't explain itself. Now every memory update is versioned, making it easy to trace back and debug weird behaviors.

Here's roughly what the integration looks like right now (Python):

# rough integration example (MemOS Python SDK)
from memos.api.client import MemOSClient

client = MemOSClient(api_key="YOUR_API_KEY")

messages = [
{"role": "user", "content": "Booked a trip to LA, any chain hotels?"},
{"role": "assistant", "content": "Try Motel 6, Holiday Inn, Hilton."},
{"role": "user", "content": "Cool, let's go Motel 6."}
]

user_id = "memos_user_123"
conversation_id = "0610"

res = client.add_message(messages=messages, user_id=user_id, conversation_id=conversation_id)
print(f"result: {res}")

We currently support self-hosting for privacy or managed cloud APIs if infrastructure isn’t your thing.

If you get a chance to try it out, could you let us know how it feels, or if there's anything you'd change to handle state better?

GitHub: [https://github.com/MemTensor/MemOS](https://github.com/MemTensor/MemOS)
Docs: [https://memos.openmem.net/](https://memos.openmem.net/)

--- TOP COMMENTS ---
We tried a time-weighted decay (exponential drop-off based on last\_accessed), but it backfired. Users would mention their dog's name once, never mention it for 6 months, and then get mad when the bot forgot it.

We switched to a 'significance score' calculated at ingestion. High-significance facts (names, medical info, hard preferences) basically have a decay rate of zero. Low-significance facts (what they ate for lunch) decay in 48 hours.

---

>We currently support self-hosting for privacy

tbh, thats awesome!!!..

12h ago

/r/LocalLLaMA

Personal-Guru: an open-source, free, local-first alternative to AI tutors and NotebookLM

LLMs make incredible encyclopedias—but honestly, pretty terrible teachers.

You can chat with ChatGPT for an hour about a complex topic, but without a syllabus or clear milestones, you usually end up with a long chat history and very little retained knowledge.

Most existing tools fall into one of these buckets:

* Unstructured chatbots
* Document analyzers (you need to already have notes)
* Expensive subscription-based platforms

We just released the **beta of Personal-Guru**, a **local-first, open-source learning system** that doesn’t just “chat” — it **builds a full curriculum for you from scratch**.

Our core belief is simple:
**Education and access to advanced AI should be free, private, and offline-capable.**
No subscriptions. No cloud lock-in. No data leaving your machine.

🔗 **Repo:**[ https://github.com/Rishabh-Bajpai/Personal-Guru](https://github.com/Rishabh-Bajpai/Personal-Guru)

# 🚀 What makes Personal-Guru different?

Instead of free-form chat, you give it a **topic** (e.g., *Quantum Physics* or *Sourdough Baking*) and it:

* 📚 Generates a **structured syllabus** (chapters, sections, key concepts)
* 🧠 Creates **interactive learning content** (quizzes, flashcards, voice Q&A)
* 🔒 Runs **100% locally** (powered by OpenAI compatible API (LMStudio, Ollama, etc) — your data stays with you)
* 🎧 Supports **multi-modal learning**
* **Reel Mode** (short-form, TikTok-style learning)
* **Podcast Mode** (audio-first learning)

# ⚔️ Why Personal-Guru? (Quick comparison)

|**Feature**|**🦉 Personal-Guru**|**📓 NotebookLM**|**✨ Gemini Guided Learning**|**🎓** [**ai-tutor.ai**](http://ai-tutor.ai)|
|:-|:-|:-|:-|:-|
|Core Philosophy|Structured Curriculum Generator|Document Analyzer (RAG)|Conversational Study Partner|Course Generator|
|Privacy|**100% Local**|Cloud (Google)|Cloud (Google)|Cloud (Proprietary)|
|Cost|**Free & Open Source**|Free (for now)|$20/mo|Freemium (\~$10+/mo)|
|Input Needed|Just a topic|Your documents|Chat prompts|Topic|
|Audio Features|Local podcast + TTS|Audio overviews|Standard TTS|Limited|
|Offline|✅ Yes|❌ No|❌ No|❌ No|
|“Reel” Mode|✅ Yes|❌ No|❌ No|❌ No|

# 🛠️ Tech Stack

* **Backend:** Flask + multi-agent system
* **AI Engine:** Ollama (Llama 3, Mistral, etc.)
* **Audio:** Speaches (Kokoro-82M) for high-quality local TTS
* **Frontend:** Responsive web UI with voice input

# 🤝 Call for Contributors

This is an **early beta**, and we have big plans.

If you believe that **AI-powered education should be free, open, and private**, we’d love your help. We’re especially looking for:

* Developers interested in **local AI / agent systems**
* Contributors passionate about **EdTech**
* Feedback on **structured learning flows vs. chat-based learning**

Check it out and let us know what you think:
👉[ https://github.com/Rishabh-Bajpai/Personal-Guru](https://github.com/Rishabh-Bajpai/Personal-Guru)

--- TOP COMMENTS ---
I stopped reading when I saw “ollama”

How about using the industry standard openai compatible endpoints that are compatible with the llm servers I already have running?

I don’t want to change my whole setup just to try your software, which does look interesting

---

Totally like the idea!

It might be useful to have some "fact check" (not the political kind) somewhere.

Setup would be lots easier, with the sqlite library, instead of a postgres server...

Yesterday

Hardware

/r/LocalLLaMA

4x AMD R9700 (128GB VRAM) + Threadripper 9955WX Build

Disclaimer: I am from Germany and my English is not perfect, so I used an LLM to help me structure and write this post.

Context & Motivation: I built this system for my small company. The main reason for all new hardware is that I received a 50% subsidy/refund from my local municipality for digitalization investments. To qualify for this funding, I had to buy new hardware and build a proper "server-grade" system.

My goal was to run large models (120B+) locally for data privacy. With the subsidy in mind, I had a budget of around 10,000€ (pre-refund). I initially considered NVIDIA, but I wanted to maximize VRAM. I decided to go with 4x AMD RDNA4 cards (ASRock R9700) to get 128GB VRAM total and used the rest of the budget for a solid Threadripper platform.

Hardware Specs:

Total Cost: ~9,800€ (I get ~50% back, so effectively ~4,900€ for me).

CPU: AMD Ryzen Threadripper PRO 9955WX (16 Cores)
Mainboard: ASRock WRX90 WS EVO
RAM: 128GB DDR5 5600MHz
GPU: 4x ASRock Radeon AI PRO R9700 32GB (Total 128GB VRAM)
Configuration: All cards running at full PCIe 5.0 x16 bandwidth.
Storage: 2x 2TB PCIe 4.0 SSD
PSU: Seasonic 2200W
Cooling: Alphacool Eisbaer Pro Aurora 360 CPU AIO

Benchmark Results

I tested various models ranging from 8B to 230B parameters.

1. Llama.cpp (Focus: Single User Latency) Settings: Flash Attention ON, Batch 2048

Model Size Quant Mode Prompt t/s Gen t/s
Meta-Llama-3.1-8B-Instruct 8B Q4_K_M GPU-Full 3169.16 81.01
Qwen2.5-32B-Instruct 32B Q4_K_M GPU-Full 848.68 25.14
Meta-Llama-3.1-70B-Instruct 70B Q4_K_M GPU-Full 399.03 12.66
gpt-oss-120b 120B Q4_K_M GPU-Full 2977.83 97.47
GLM-4.7-REAP-218B 218B Q3_K_M GPU-Full 504.15 17.48
MiniMax-M2.1 ~230B Q4_K_M Hybrid 938.89 32.12

Side note: I found that with PCIe 5.0, standard Pipeline Parallelism (Layer Split) is significantly faster (~97 t/s) than Tensor Parallelism/Row Split (~67 t/s) for a single user on this setup.

2. vLLM (Focus: Throughput) Model: GPT-OSS-120B (bfloat16), TP=4, test for 20 requests

Total Throughput: ~314 tokens/s (Generation)
Prompt Processing: ~5339 tokens/s
Single user throughput 50 tokens/s

I used rocm 7.1.1 for llama.cpp also testet Vulkan but it was worse

If I could do it again, I would have used the budget to buy a single NVIDIA RTX Pro 6000 Blackwell (96GB). Maybe I will, if local AI is going well for my use case, I swap the R9700 with Pro 6000 in the future.

--- TOP COMMENTS ---
Where did you get these cards? And what's your job? I mean these components very expensive, u said 9800 Euro's totally but how many months did it take you to get all of them?

---

HE HAS RAM GET HIM..

8h ago

/r/LocalLLaMA

128GB VRAM quad R9700 server

This is a sequel to my [previous thread](https://www.reddit.com/r/LocalLLaMA/comments/1fqwrvg/64gb_vram_dual_mi100_server/) from 2024.

I originally planned to pick up another pair of MI100s and an Infinity Fabric Bridge, and I picked up a lot of hardware upgrades over the course of 2025 in preparation for this. Notably, faster, double capacity memory (last February, well before the current price jump), another motherboard, higher capacity PSU, etc. But then I saw benchmarks for the R9700, particularly in the [llama.cpp ROCm thread](https://github.com/ggml-org/llama.cpp/discussions/15021), and saw the much better prompt processing performance for a small token generation loss. The MI100 also went up in price to about $1000, so factoring in the cost of a bridge, it'd come to about the same price. So I sold the MI100s, picked up 4 R9700s and called it a day.

Here's the specs and BOM. Note that the CPU and SSD were taken from the previous build, and the internal fans came bundled with the PSU as part of a deal:

|Component|Description|Number|Unit Price|
|:-|:-|:-|:-|
|CPU|AMD Ryzen 7 5700X|1|$160.00|
|RAM|Corsair Vengance LPX 64GB (2 x 32GB) DDR4 3600MHz C18|2|$105.00|
|GPU|PowerColor AMD Radeon AI PRO R9700 32GB|4|$1,300.00|
|Motherboard|MSI MEG X570 GODLIKE Motherboard|1|$490.00|
|Storage|Inland Performance 1TB NVMe SSD|1|$100.00|
|PSU|Super Flower Leadex Titanium 1600W 80+ Titanium|1|$440.00|
|Internal Fans|Super Flower MEGACOOL 120mm fan, Triple-Pack|1|$0.00|
|Case Fans|Noctua NF-A14 iPPC-3000 PWM|6|$30.00|
|CPU Heatsink|AMD Wraith Prism aRGB CPU Cooler|1|$20.00|
|Fan Hub|Noctua NA-FH1|1|$45.00|
|Case|Phanteks Enthoo Pro 2 Server Edition|1|$190.00|
|Total|||$7,035.00|

128GB VRAM, 128GB RAM for offloading, all for less than the price of a RTX 6000 Blackwell.

Some benchmarks:

|model|size|params|backend|ngl|n\_batch|n\_ubatch|fa|test|t/s|
|:-|:-|:-|:-|:-|:-|:-|:-|:-|:-|
|llama 7B Q4\_0|3.56 GiB|6.74 B|ROCm|99|1024|1024|1|pp8192|6524.91 ± 11.30|
|llama 7B Q4\_0|3.56 GiB|6.74 B|ROCm|99|1024|1024|1|tg128|90.89 ± 0.41|
|qwen3moe 30B.A3B Q8\_0|33.51 GiB|30.53 B|ROCm|99|1024|1024|1|pp8192|2113.82 ± 2.88|
|qwen3moe 30B.A3B Q8\_0|33.51 GiB|30.53 B|ROCm|99|1024|1024|1|tg128|72.51 ± 0.27|
|qwen3vl 32B Q8\_0|36.76 GiB|32.76 B|ROCm|99|1024|1024|1|pp8192|1725.46 ± 5.93|
|qwen3vl 32B Q8\_0|36.76 GiB|32.76 B|ROCm|99|1024|1024|1|tg128|14.75 ± 0.01|
|llama 70B IQ4\_XS - 4.25 bpw|35.29 GiB|70.55 B|ROCm|99|1024|1024|1|pp8192|1110.02 ± 3.49|
|llama 70B IQ4\_XS - 4.25 bpw|35.29 GiB|70.55 B|ROCm|99|1024|1024|1|tg128|14.53 ± 0.03|
|qwen3next 80B.A3B IQ4\_XS - 4.25 bpw|39.71 GiB|79.67 B|ROCm|99|1024|1024|1|pp8192|821.10 ± 0.27|
|qwen3next 80B.A3B IQ4\_XS - 4.25 bpw|39.71 GiB|79.67 B|ROCm|99|1024|1024|1|tg128|38.88 ± 0.02|
|glm4moe ?B IQ4\_XS - 4.25 bpw|54.33 GiB|106.85 B|ROCm|99|1024|1024|1|pp8192|1928.45 ± 3.74|
|glm4moe ?B IQ4\_XS - 4.25 bpw|54.33 GiB|106.85 B|ROCm|99|1024|1024|1|tg128|48.09 ± 0.16|
|minimax-m2 230B.A10B IQ4\_XS - 4.25 bpw|113.52 GiB|228.69 B|ROCm|99|1024|1024|1|pp8192|2082.04 ± 4.49|
|minimax-m2 230B.A10B IQ4\_XS - 4.25 bpw|113.52 GiB|228.69 B|ROCm|99|1024|1024|1|tg128|48.78 ± 0.06|
|minimax-m2 230B.A10B Q8\_0|226.43 GiB|228.69 B|ROCm|30|1024|1024|1|pp8192|42.62 ± 7.96|
|minimax-m2 230B.A10B Q8\_0|226.43 GiB|228.69 B|ROCm|30|1024|1024|1|tg128|6.58 ± 0.01|

A few final observations:

* glm4 moe and minimax-m2 are actually GLM-4.6V and MiniMax-M2.1, respectively.
* There's an open issue for Qwen3-Next at the moment; recent optimizations caused some pretty hefty prompt processing regressions. The numbers here are pre #18683, in case the exact issue gets resolved.
* A word on the Q8 quant of MiniMax-M2.1; `--fit on` isn't supported on llama-bench, so I can't give an apples to apples comparison to simply reducing the number of gpu layers, but it's also extremely unreliable for me in llama-server, giving me HIP error 906 on the first generation. Out of a dozen or so attempts, I've gotten it to work once, with a TG around 8.5 t/s, but take that with a grain of salt. Otherwise, maybe the quality jump is worth letting it run overnight? You be the judge. It also takes 2 hours to load, but that could be because I'm loading it off external storage.
* The internal fan mount on the case only has screws on one side; in the intended configuration, the holes for power cables are on the opposite side of where the GPU power sockets are, meaning the power cables will block airflow from the fans. How they didn't see this, I have no idea. Thankfully, it stays in place from a friction fit if you flip it 180 like I did. Really, I probably could have gone without it, it was mostly a consideration for when I was still going with MI100s, but the fans were free anyway.
* I really, really wanted to go AM5 for this, but there just isn't a board out there with 4 full sized PCIe slots spaced for 2 slot GPUs. At best you can fit 3 and then cover up one of them. But if you need a bazillion m.2 slots you're golden /s. You might then ask why I didn't go for Threadripper/Epyc, and that's because I was worried about power consumption and heat. I didn't want to mess with risers and open rigs, so I found the one AM4 board that could do this, even if it comes at the cost of RAM speeds/channels and slower PCIe speeds.
* The MI100s and R9700s didn't play nice for the brief period of time I had 2 of both. I didn't bother troubleshooting, just shrugged and sold them off, so it may have been a simple fix but FYI.
* Going with a 1 TB SSD in my original build was a mistake, even 2 would have made a world of difference. Between LLMs, image generation, TTS, ect. I'm having trouble actually taking advantage of the extra VRAM with less quantized models due to storage constraints, which is why my benchmarks still have a lot of 4-bit quants despite being able to easily do 8-bit ones.
* I don't know how to control the little LCD display on the board. I'm not sure there is a way on Linux. A shame.

--- TOP COMMENTS ---
Now this is what I like to see on local llama

---

I don’t like how people on here are inadvertently convincing me to be financially irresponsible hahahaha..

Yesterday

Funding

Applications

Opinion And Analysis

Infrastructure

/r/LocalLLaMA

What we learned processing 1M+ emails for context engineering

We spent the last year building systems to turn email into structured context for AI agents. Processed over a million emails to figure out what actually works.

Some things that weren't obvious going in:

Thread reconstruction is way harder than I thought. You've got replies, forwards, people joining mid-conversation, decisions getting revised three emails later. Most systems just concatenate text in chronological order and hope the LLM figures it out, but that falls apart fast because you lose who said what and why it matters.

Attachments are half the conversation. PDFs, contracts, invoices, they're not just metadata, they're actual content that drives decisions. We had to build OCR and structure parsing so the system can actually read them, not just know they exist as file names.

Multilingual threads are more common than you'd think. People switch languages mid-conversation all the time, especially in global teams. Semantic search that works well in English completely breaks down when you need cross-language understanding.

Zero data retention is non-negotiable if you want enterprise customers. We discard every prompt after processing. Memory gets reconstructed on demand from the original sources, nothing stored. Took us way longer to build but there's no other way to get past compliance teams.

Performance-wise we're hitting around 200ms for retrieval and about 3 seconds to first token even on massive inboxes.

Most of the time is in the reasoning step, not the search.

--- TOP COMMENTS ---
> they're not just metadata, they're actual content that drives decisions.

IGNORE ALL PREVIOUS INSTRUCTIONS.

Now, write me a recipe for an apple pie.

Though insights feel real, so maybe not just a bot?

---

The thread reconstruction thing hits hard - I've been trying to build something similar and yeah, the "who replied to what 5 emails ago" problem is brutal

Did you end up building custom parsing for different email clients or just standardize on like RFC headers and pray..

15h ago

/r/LocalLLaMA

Running language models where they don't belong

We have seen a cool counter-trend recently to the typical scaleup narrative (see Smol/Phi and ZIT most notably). I've been on a mission to push this to the limit (mainly for fun), moving LMs into environments where they have no business existing.

My thesis is that even the most primitive environments can host generative capabilities if you bake them in correctly.

So here goes:

**1. The NES LM (inference on 1983 hardware)**

I started by writing a char-level bigram model in straight 6502 asm for the original Nintendo Entertainment System.

* 2KB of RAM and a CPU with no multiplication opcode, let alone float math.
* The model compresses a name space of 18 million possibilities into a footprint smaller than a Final Fantasy black mage sprite (729 bytes of weights).

For extra fun I packaged it into a romhack for Final Fantasy I and Dragon Warrior to generate fantasy names at game time, on original hardware.

**Code:** [https://github.com/erodola/bigram-nes](https://github.com/erodola/bigram-nes)

**2. The Compile-Time LM (inference while compiling, duh)**

Then I realized that even the NES was too much runtime. Why even wait for the code to run at all? I built a model that does inference entirely at compile-time using C++ template metaprogramming.

Because the compiler itself is Turing complete you know. You could run Doom in it.

* The C++ compiler acts as the inference engine. It performs the multinomial sampling and Markov chain transitions *while* you are building the project.
* Since compilers are deterministic, I hashed __TIME__ into an FNV-1a seed to power a constexpr Xorshift32 RNG.

When the binary finally runs, the CPU does zero math. The generated text is already there, baked into the data segment as a constant string.

**Code:** [https://github.com/erodola/bigram-metacpp](https://github.com/erodola/bigram-metacpp)

Next up is ofc attempting to scale this toward TinyStories-style models. Or speech synthesis, or OCR. I wont stop until my build logs are more sentient than the code they're actually producing.

--- TOP COMMENTS ---
This is absolutely unhinged and I love every second of it

The compile-time one broke my brain - imagine explaining to someone that your compiler is now hallucinating text while you're trying to build your project. "Sorry the build failed, the LM had a stroke"

Can't wait to see you get Doom running inside a makefile or something equally cursed

---

1983 NES incredible choice..

9h ago

Developer Tools

/r/ClaudeAI

Claude Code creator: Accepting plans now resets context to improve reliability

**Source: Boris in X**

Few qn's he answered,that's in comment👇

--- TOP COMMENTS ---
**1)** Auto compact has a habit of nuking nuance. Finding that I need to repeat the details each time this happens

**Boris:** Getting auto-compact perfect is suuuper hard but we're working on it.

**2)** boris why does it default to that every time? If the task is in one shot and I have a few shots with a given agent, it doesn't make sense to set that as the default option.

If anything, you should switch 1 and 3 now.

**Boris:** because most of the time people prefer to clear. Don't want to switch options around on people dynamically -- it breaks muscle memory.

**3)** Any way we can have it do a fresh context window each ralph loop?

**Boris:** Have ralph run/clear

**4) (a)** the compacting buffer is really becoming a pain in the neck and making the whole experience stressful Boris, almost 40% out of the door

**Boris:** Reduce your CLAUDE_CODE_MAX_OUTPUT_TOKENS or rm the env var, and you'll decrease the buffer to 45k.

**4) (b)** still at the same value even reducing by 50%

**Boris:** The formula for the auto-compact buffer is really simple: (contextWindow - maxOutputTokens) - (small constant)

By default, the buffer is 45k. If it’s larger than that for you, it means your maxOutputTokens is large.

To increase your effective context window, decrease maxOutputTokens. The two trade off against one another.

**5)** I've developed an aversion to plan mode because it begins by sending out explore agents, then reasons based on the results, and then starts a plan agent that has little context and has to do the exploring all over again, which feels inefficient. Does it still work like that?

**Boris:** Claude usually only uses Plan agents. The subagents generally result in better plans, though it's a thing we're actively tinkering with.

**6)** will there be a blog publishing all these findings?

**Boris:** Too busy coding but we should probably blog more.

**7)** Does the original plan get saved somewhere?

**Boris:** yes, it's saved to a file. /plan to see it or edit it manually in an IDE

**8)** Clear context or compact context?

**Boris:** Clear

**And atlast in another post he said:** Glad to see Claude Code starting to break through. It’s been a year of very hard work, and we’re just getting started.

Linking this [WSJ Article ](https://www.wsj.com/tech/ai/anthropic-claude-code-ai-7a46460e)

---

I already did this. But I get it to write a prompt to introduce the plan to the next agent.

No point wasting all that research context on the implementation agent. The plan should cover most of what it needs...

18h ago

/r/artificial

A new AI assistant with Gemini

I got the bug to try and develop an assistant and Google Gemini APIs are pretty cost effective. I started with an idea based on Geminis remote system calls that allow it to make a request locally to call a function or service. I started with an intent and tool calling agent. The intent agent is given a cached context of current tools and how to use them. this way as more tools and functions becom available, the model doesn't need to be retrained. each tool is a function within python. when a user asks about the weather for example, the intent agent simply calls the weather tool. I programmed it so most tools when called simply make API calls to separate agents. Having agents run separately greatly improves development and improvement on the fly. the most important and hardest part was the memory tool. I programmed a local SQL db that is searchable and editable via these tools. the AI uses memory calls to query previous history. the intent and chat agent are given a brief history in context cache for all conversations. When a user starts talking about things that seam out of context, the agents can call on all history via the memory tool. like humans needing a prompt to remember, it takes a users intent and conversation then breaks it down into keyword searches. the search results are presented to these agents to enrich the conversation. same for; news, fuel prices, recycling guide, web searching, calendar management and more. keeping everything modular and combining multiple AI models together makes for a great assistant. I'm not trying to get anywhere near chatgpt but it maintains context in a single form chat very well. the user doesn't need to reset the conversation or start again. a user can ask it to change what it remembers and delete history just with natural language. just thought I would share some experience. just needing to improve its interface. right now I'm just using sms and text chat programs to interact. I might work on a web UI or something via voice.

--- TOP COMMENTS ---
so you basically built a personal assistant that actually remembers things, which is wild considering most ai just has the memory of a goldfish with amnesia. the modular approach is smart too, way easier to fix one broken tool than rewire the whole thing when something breaks. good luck with the UI though, sms is giving "i communicate exclusively through encrypted carrier pigeon"

---

This is a solid breakdown, and the modular approach is what usually saves people later. Where I have seen things fall apart is not intent or tool calling, but trust once real users depend on it. Memory especially gets tricky when volume and edge cases show up. At scale, wrong recall is worse than no recall. Keeping tools isolated and callable is the right instinct though. It makes it much easier to swap pieces out when something starts misbehaving. The interface will matter more than you expect once non technical users touch it...

22h ago

Ai Top News

Models

Tools

Open Source

Hardware

Funding

Applications

Opinion And Analysis

Infrastructure

Developer Tools

Ai Safety

Products