GLM-5.3·Qwen3.8 공개형 모델 확산과 Agent 실행 구조·GPU 병목·Benchmark 신뢰성

GLM-5.3 × ZCode Weekend Build Eligible new users: log in to ZCode for the first time from Aug 16, 00:00 to Aug 17, 09:00 (UTC+8) to automatically get 100M free GLM-5.3 tokens. Limited availability; ZCode only. Try it: https:// zcode.z.ai

Qwen3.8-27B GGUF has reached 1,000 likes in less than 24 hours! It's now the #3 trending model on Hugging Face with 1M overall downloads. Run on 17GB RAM/VRAM setups via Unsloth! Model: https:// huggingface.co/unsloth/Qwen3. 8-27B-GGUF … GitHub: https:// github.com/unslothai/unsl oth …

Harrison Chase

@hwchase17

gave a talk "owning your intelligence" - ty @sequoia @sonyatweetybird for having me talked about harnesses and evals and the role they play in owning your intelligence TLDR: > agents = model + harness + context > model - own the weights using something like @FireworksAI_HQ > context - memory needs to be portable > harness - needs to be model agnostic. also needs to be good at bringing right context to llm. "right" context may depend on your use case, which is why an open/configurable harness helps > how to use middleware in langchain/deepagents to configure your harness > how to use langgraph to fully own your cognitive architecture > why evals/obs matters - some quotes from @satyanadella - “Create your private evals, because evals define what “good” looks like inside the organization” - “retain ownership of your organization’s memory, traces, feedbacks, decisions, and institutional context” - “you create your own continuous learning loop (i.e. hill climbing machine) that will allow your AI investments to compound the value of your firm” > how to use harbor for evals > tracing is important > evals + observability only matter so you can set up a data flywheel > data flywheel = run agent -> collect traces -> find interesting traces -> use those to improve > demo of langsmith engine which does exactly this! full video: https:// youtube.com/watch?v=HI2q3c i3Iuc&list=PLaqC3GACblSs&index=2 …

Greg Brockman

@gdb

towards never having to manually select a model again

GPU architecture, clearly explained. The usual assumption is that a faster GPU means more compute, so a chip rated for more operations per second should generate more tokens per second. That rarely holds. You can rent a top-end chip, load a model, watch utilization sit high, and still get a few dozen tokens per second out of hardware capable of a thousand trillion operations. The arithmetic units are not the limit. They spend most of their time waiting for numbers to arrive. Memory bandwidth is how fast those numbers can be delivered, and it grows far more slowly than arithmetic capability with each new generation. The H100 makes this concrete. It does 989 trillion operations per second at 16-bit precision, while its memory delivers 3.35 trillion bytes per second. Divide one by the other and you get about 295. That is how many operations the chip has to perform on every byte it fetches just to keep its arithmetic units busy. Generating a token comes nowhere close. Each weight gets multiplied by one number and added into a running total, so two operations per weight, and each weight costs 2 bytes to read at 16-bit precision. That works out to 1 operation per byte, roughly three hundred times short of what the chip needs. Once you see that, the layout of a GPU stops looking arbitrary. All of it is organized around distance, because every trip to fetch a value is the expensive part. Execution is nested in four steps, smallest first. → Thread. The smallest unit of work, doing arithmetic on its own handful of values. → Warp. A group of 32 threads that move in lockstep and share a single instruction, which is what the hardware actually schedules. → Thread block. A batch of warps, up to 32 of them or 1024 threads, handed to one compute unit and staying there until it finishes. → SM. The streaming multiprocessor, a small self-contained machine with its own arithmetic units, its own storage, and its own scheduler. An H100 has up to 132 of them. Memory is nested along the same lines, and that is the part that decides your speed. → Registers. 256 KB per SM, split so each thread gets a private slice nobody else can read. A value here already sits next to the thing that needs it, so reading it costs nothing worth measuring. → Shared memory and L1. A few hundred KB per SM. Shared memory is the only level you place things into yourself, and every thread in a block can read it, which is where the name comes from. → L2 cache. Around 50 MB sitting below all the SMs, and the first level every one of them can see. Reaching it means leaving your own SM. → HBM (High Bandwidth Memory). Around 80 GB, holding model weights, the KV cache, and activations. It sits outside the processing chip entirely, and reaching it is the slowest thing a GPU does. The nesting is what buys you speed. Anything that stays inside one SM is fast because nobody outside needs to see it, and anything the whole chip has to agree on pays for the trip down. Add up the registers across every SM and you get roughly as much storage as the L2 underneath them, which is nothing like the neat pyramid you see on a CPU. So making a GPU faster is mostly about how many round trips to HBM you can avoid. FlashAttention is the clearest case, since ordinary attention writes a large intermediate result all the way down and reads it back, while the tiled version keeps it up on the SM and runs far faster doing the same arithmetic. I wrote the full breakdown of how a GPU works, from this layout up to the ratio that sets your token rate. The article is quoted below. I have also put together a 10-week, 30-minutes-a-day roadmap for engineers who want to actually run LLM inference in production, not just read about it. Check this out: https:// github.com/patchy631/time -to-first-token … (don't forget to star ) Stay tuned for more on this!

Interesting new research from IBM. If you pick models from benchmark deltas, some of that delta belongs to the phrasing rather than the model. BenchDrift generates meaning-preserving variations of benchmark problems along linguistic, referential, pragmatic, and structural axes, holding the answer fixed, then measures how often correctness flips. Phrasing sensitivity does not fade as models improve. It changes sign. Weak models gain more from rephrasing than they lose, while strong models lose far more than they gain, so the top models on a benchmark are the ones whose scores depend most on the wording they happened to receive. Fragility also belongs to the rephrasing. Across eight models on GSM8K, MMLU, and MATH-Hard, they largely agree on which rephrasings cost the most correct answers even while differing in how much they drift overall. Rephrasing breaks answers models were confident about, whether the problem gets shorter or longer. Paper: https:// arxiv.org/abs/2608.11694 Track more trending AI papers in our academy: https:// academy.dair.ai

New work from Google DeepMind and collaborators. Agentic algorithm discovery keeps getting demonstrated on problems with fast rewards. Microarchitecture has vast search spaces, strict hardware budgets, and simulation times measured in hours, which is why the original ArchAgent stopped at single-level cache replacement. ArchAgent v2 scales to multi-level data prefetching with two additions. Cascaded evolutionary search subdivides the space by sequentially evolving and freezing prefetchers at individual cache levels. A hardware-realizability feedback loop embeds real-time size estimation into evolution, so candidates that cannot fit the budget get pruned during search. Under identical 4th Data Prefetching Championship rules, the discovered three-level prefetcher beats the winning hand-designed solution. 3.8% geometric mean IPC speedup over baseline, 0.3% over prior champion BertiGO, widening to 4.6% against 2.6% on low-bandwidth single-core configurations. Multi-core evolution remains blocked by simulation latency slowing the evolution loop. Paper: https:// arxiv.org/abs/2608.09874 Track more trending AI papers in our academy: https:// academy.dair.ai

A short illustration of how the Claude's watermarking is supposed to work (based on my read of their released materials). In general, when we are generating tokens, there can be multiple high-scoring tokens at certain next-word positions. Usually, we sample with top-k or top-p sampling so the highest-scoring token is most often selected (if we repeat the sampling many times), but other tokens may be selected as well. With watermarking, there is a key that says which of the (ideally equally) highest-scoring tokens to select. Or, more concretely, the secret key and previous token influence the randomness here. Now, if we repeat this at many token positions, this creates the watermark as it will be a pattern that is statistically unlikely to get otherwise (due to combinatorics). One thing I am confused about: They basically say that they HAVE to do this for everyone due to EU regulation. Why? Sure, but this is an inference-time technique that doesn't require retraining or training a separate model, so, if they wanted, they could only do that for EU users?

RIP Claude Watermarks, An engineer got so tired of decoding Claude’s writing that he built a plugin to translate it into plain English. Every finished Claude message over 200 characters gets rewritten by a local model running on Ollama. The clean version appears under the original with an In plain English: label. Claude never sees the rewrite. The transcript stays pure, If Ollama is down, it fails open you still get the original answer. He tried telling Claude to write simpler. He even tried aerospace writing standards. Nothing worked as well as pointing a second AI at the first one.

You don’t need to waste an hour digging through your Mac’s settings trying to figure out what’s wrong with your laptop Grok Build is insanely capable....just tell Grok Build what’s broken and let it investigate the machine for you You can try things like: • Trackpad suddenly behaving weird • Battery draining ridiculously fast • Microphone isn't working in calls. Diagnose it • Some random website sending Chrome notifications every 10 seconds • External monitor runs at 60Hz but supports 144Hz. Fix it • Mac running hot or slowing down • An app constantly crashing • Something keeping your Mac awake or eating all your CPU? You might have absolutely no idea where the setting is or even what’s causing the problem Grok Build can inspect the system, find the culprit and, with the right tools/skills, actually take action Instead of Googling the problem → opening 20 tabs → digging through Settings → trying random fixes.... Just tell Grok Build what’s wrong and let it figure out the rest

Getting started with Databricks Apps can be as simple as giving your coding agent the right prompt. DevHub prompts can help check your environment, set up what you need, scaffold an app, and deploy it to your Databricks workspace. Then, use templates to keep building without starting over. For example, the Genie Analytics app template adds a chat interface so users can query data in your Databricks workspace using natural language. Explore now: https:// developers.databricks.com/?utm_source=tw itter&utm_medium=organic-social …