Qwen3.8-27B 경량 실행, GPU 메모리 병목, 에이전트 지침 누적, AGI 아키텍처 전환

how do you know whether your GPU is compute-bound or memory-bound? here's a simple explanation: your model weights sit in HBM (high bandwidth memory), the large pool of memory on the GPU board. no arithmetic happens there. before any multiplication can run, those weights have to travel from HBM into the arithmetic units, and that trip is the slowest thing the chip does. so the real question is how much work you get out of each weight once it has made the trip. that gives you one ratio. count how many arithmetic operations something performs, then count how many bytes it pulled out of HBM to perform them. divide the first by the second and you get its work per byte, which is the horizontal axis in the visual. every chip has a break-even value for that ratio, and it is just peak arithmetic divided by peak memory bandwidth. take an H100. it performs 989 trillion operations per second at 16-bit precision, and it can pull 3.35 trillion bytes per second out of memory. divide one by the other and you get 295 operations per byte, which is the 300 marked on the chart below. that number says the chip can afford about 300 operations for every byte it fetches. anything cheaper leaves the arithmetic units idle, waiting on the next delivery. generating one token for a single request sits at the far left of the red line. every weight is fetched from HBM, gets one multiply and one add (2 operations), and is then dropped. each weight takes two bytes at 16-bit precision, so that is one operation per byte, roughly 300 times below break-even. this is why the red segment slopes. along it your speed is set entirely by how fast bytes arrive, so a chip with more arithmetic capability buys you nothing. batching is how you move right. run 32 requests together and each weight, fetched exactly once, does its multiply and add against 32 different values before being dropped. the traffic out of HBM is unchanged, and the work you got from it went up 32 times. a long prompt does the same thing, except the many values come from the tokens of one sequence instead of separate requests. past the break-even point the line goes flat, which is the green region. processing a long prompt and training both land there, since each fetched byte now feeds enough operations that the arithmetic units become the slow stage and the memory path has capacity to spare. so the two halves ask for opposite fixes. left of the line you cut bytes moved or reuse each fetch harder, and right of it you need faster arithmetic or better algorithms. the threshold belongs to the hardware. where your workload sits relative to it belongs to you. I wrote the full breakdown of how a modern GPU works, and the article is quoted below. stay tuned for more on this!

Congrats Qwen team! Qwen3.8-27B has now reached 4.5M total downloads in less than 2 days!

Locally Qwen3.8-27B cooked an entire interactive volcano simulation on only 17GB RAM. Geology, Thermodynamics, Fluid flow, lava viscosity, steam explosions, and groundwater interaction in Real-time 4-bit GGUF.

Your CLAUDE.md is rotting and we finally know why A new paper tracked 247,000+ instructions across 1,867 real repos and found something ugly: Agent instruction files more than triple in size over their lifetime. They gain 5 new instructions every single commit. Almost nobody ever deletes anything. They call it catastrophic remembering the opposite of catastrophic forgetting. Why it happens: - Adding a rule is cheap - Safely deleting one means remembering why it was added - That reasoning fades fast to people just leave it 77% of deletions only happen during one giant rewrite then the file starts growing again. The fix is almost too simple: Write a short comment next to every instruction explaining why it exists. In their tests this cut excess growth from +211% to +1.4% and improved instruction-following by up to 23%. - http:// arxiv.org/abs/2608.11095

This 260-page relevant paper is the new bible for AGI builders. Google DeepMind researchers officially said today systems next-token prediction alone will never reach AGI. The most important AI paper most people haven’t read yet, Modular intelligence to pure scaling. They don’t say stop building LLMs. They say something more precise and more powerful: LLMs are an incredible next-token engine. But true intelligence needs a full vehicle not just the engine. Current LLMs still lack: - Persistent, evolving memory An internal world model that simulates consequences before acting - Dynamic goal & reward systems for long-horizon autonomy - Continuous self-evolution without human retraining - Multi-agent societies where intelligence emerges from collaboration The new blueprint is Foundation Agents modular, brain-inspired architectures that map directly onto human cognitive systems: 1. World Model to internal simulation of reality 2. Dynamic Memory & Perception to lifelong learning from real feedback 3. Reward & Goal Processing to autonomous planning across long horizons 4. Collaborative Multi-Agent Ecosystems to negotiation, competition, emergence Four core pillars of the paper: - Modular brain-inspired foundations - Self-enhancement & adaptive evolution - Evolutionary multi-agent systems - Safety & alignment that must scale with capability Key insight: Simply scaling transformers further is hitting diminishing returns for AGI-level agency. The next leap requires architecture, not just more data and compute. This is one of the most comprehensive roadmaps yet for moving from chatbots to genuine autonomous intelligence. This same things I heard about @ylecun before Paper : http:// arxiv.org/pdf/2504.01990

Yann LeCun’s clear roadmap for AGI: “If you are interested in human-level AI, don’t work on LLMs.” His full architecture recommendations: - Abandon, Generative models to Joint-embedding models - Abandon, Probabilistic architectures to Energy-based models - Abandon, Contrastive methods to Regularized methods - Abandon, Reinforcement Learning to Model-predictive control While the entire industry is scaling LLMs Yann LeCun is telling us to walk away from them.