标签：#machine

Classic Machine Learning Through the Eyes of an SRE — Part 2 The second algorithm I studied broke everything I'd just learned from the first. Logistic regression taught me that training means gradient descent: guess, measure error, adjust the weights, repeat until convergence. So when I opened decision trees, I went looking for the optimizer. There wasn't one. A decision tree isn't optimized the way I expected. It's grown. At each step it finds the locally best split, commits to it, and recursively repeats the process. No backtracking. No second chances. There is optimization happening — each split minimizes impurity — but only locally, one step at a time. Finding the globally optimal tree is NP-hard, so the algorithm doesn't even try. That felt surprisingly familiar. In incident response or capacity planning, we rarely know the perfect answer. We make the best decision with the information we have, knowing a different first choice might have led somewhere else. Decision trees simply turn that idea into an algorithm. The bet a tree makes Every machine learning algorithm makes a different bet about the world. Logistic regression assumes relationships are smooth. Risk gradually increases as signals change. Decision trees make the opposite assumption. They assume the world is made of boxes. A project isn't slightly riskier because velocity drops. It's risky when several conditions happen together: a fixed-price contract, a new account manager, and a month-end delivery. Inside that box, projects fail. Outside it, they're usually fine. This is exactly how many operational systems work. Severity matrices, routing rules, escalation policies, approval workflows — they're all collections of decision boxes. That's why trees immediately felt intuitive to me. The hidden cost of flexibility Trees make very few assumptions about the data. That sounds like an advantage. The price is instability. Change a small part of the training data and the first split can change. Since every l

In an era where privacy is the ultimate luxury, our most sensitive data—heart rates, sleep cycles, and activity levels—is often shipped off to black-box cloud servers for "analysis." But what if you could keep that data strictly on your local machine? Today, we are building a Private Health Brain . By leveraging the MLX framework (Apple's dedicated machine learning library) and Llama-3 , we will transform raw XML exports from Apple HealthKit into actionable health insights—all running locally on your MacBook. We’ll cover everything from parsing messy XML with Pandas to running high-performance local AI inference without an internet connection. If you are interested in privacy-preserving AI , Edge computing , or just want to squeeze every bit of power out of your Apple Silicon chip, this guide is for you. The Architecture: Local Data Flow To ensure 100% privacy, the data never leaves your local environment. Here is how the pipeline works: graph TD A[Apple Health Export.zip] -->|Extract| B(export.xml) B -->|Python + Pandas| C{Data Cleaning} C -->|Structured JSON/CSV| D[Local Context Window] E[MLX Framework] -->|Load Weights| F[Llama-3 Model] D -->|RAG / Prompt Injection| G[Inference Engine] F --> G G -->|Result| H[Private Health Insights] style H fill:#f96,stroke:#333,stroke-width:2px Prerequisites 🛠️ Before we dive in, ensure you have an Apple Silicon (M1/M2/M3) Mac . MLX : Apple’s framework for machine learning on Apple Silicon. Llama-3 : We’ll use the 8B-Instruct version for a balance of speed and intelligence. Python 3.10+ Pandas : For data manipulation. Install the necessary libraries: pip install mlx-lm pandas lxml Step 1: Parsing the HealthKit XML Monster Apple Health exports data in a massive export.xml file. It’s nested, verbose, and a nightmare to read manually. We’ll use Python to extract specific metrics like Step Count or Heart Rate Variablity (HRV) . import pandas as pd import xml.etree.ElementTree as ET def parse_health_data ( xml_path ): print ( " 🚀 Pa

I created an AI boxing match to test the decision speed, adaptability and strategy. I fed the LLMs with data about the current match and if they have vision, they will get even more data. The match has street rules, anything goes and an AI is not defeated until the ref counts to 10 or they do 50% of their HP in damage after being knocked out. I wanted to create a fun benchmark that isn't just boring problems to be solved. Now I test them while stimulating getting punched in the face. I've been testing with gemini-flash-live models because of the speed and vision support it offers. With these models, they can actually dodge punches and counter punches. Local models on my own hardware (5060ti 8gb) take a while to inference so I'm not sure if I should introduce time scaling to compensate otherwise I want to use this to benchmark models so I'm curious on what kind of stats would be useful? Here is what I'm tracking have so far: Speed and Latency Metrics In a real-time fight, a model's speed directly correlates to its "physical" speed. Fast models should attack faster so larger models aren't necessarily going to hit harder. Tokens per Second (TPS) / Throughput: This will help you balance local models against cloud APIs. A model might have a fast TTFT but a slow TPS, meaning its actual action execution takes too long. End-to-End Latency: The total time from when the model receives the snapshot (the prompt) to when the action is executed in the game. This accounts for tool-calling delays. Reaction Latency: Measure the specific delay between an opponent's telegraph (e.g., a heavy punch winding up) and the model's defensive output (e.g., a dodge or block). Action Quality and "Tool" Correctness the model's actions (punching, guarding, taunting) act as tool calls. You need to track how well they use these tools under pressure. Sometimes the model's may not really guard/block so they are typically the ones that find themselves KOd. Tool Correctness / Validity: How often does th

Originally published on tamiz.pro . The current generation of AI coding assistants operates on a fundamental paradox: they are trained on the entirety of public code, yet they struggle to understand the specific codebase they are embedded in. For years, the industry has relied on prompt guessing —feeding the LLM a ragged collection of nearby code lines, hoping the semantic context is implicit. This approach is brittle. It fails when symbols are imported, when types are inferred, or when the logic spans multiple files.\n\nThe solution isn't a bigger model; it's a better protocol. The Language Server Protocol (LSP) is the missing link between static analysis and generative AI. By integrating LSP into AI agents, we move from probabilistic guessing to deterministic understanding. This article explores why LSP is critical for reliable coding agents, how to architect an LSP-augmented agent, and the technical pitfalls of this integration.\n\n## The Semantic Gap: Why Prompts Aren't Enough\n\nTo understand why LSP is necessary, we must first diagnose the failure modes of prompt-only AI coding agents. An LLM is a probabilistic next-token predictor. It does not "know" your code; it has seen patterns similar to your code in its training data. When you ask an AI agent to \"refactor this function,\" it relies on the context window to provide relevant information.\n\n### The Context Window Bottleneck\n\nThe primary limitation is the context window. Even with 128k tokens, you cannot fit an entire modern codebase. Agents must select a subset of files to include. Without explicit semantic queries, this selection is often heuristic-based (e.g., \"include the last 50 lines\") or simple semantic similarity (vector search). Both approaches miss critical structural relationships.\n\nConsider this example:\n\n python\n# file: user_service.py\nclass UserService:\n def get_user(self, user_id: int):\n # ... logic ...\n return db.query(User).filter(id=user_id)\n\n# file: controllers.py\ndef ha

As review season for NeurIPS wraps up, I have now reviewed for 3 major conferences this year. And I'm noticing a worrying trend: Out of the 12 papers I reviewed this year, only 1 provided full code (that runs the whole training pipeline from input dataset to output AUROC). 4 provided partial code with fragments of their method, but no ability to run the experiment end to end. And 7 provided no code. This is really bad for ensuring quality and reproducibility. Of the 5 papers that provided at least some code, 3 of them contained obvious bugs that completely invalidated the results. ML is highly technical and small bugs can have huge impacts if they are in the wrong place. Who knows what was going on in the remaining 7 papers. The fundamental issue here is of incentives: there is almost no cost to hiding code during the review process. Releasing code only increases odds of rejection due to reviewers finding bugs. The only way to fix this is to change the game by imposing real penalties on hiding code. submitted by /u/Flaky-Ambition5900 [link] [留言]

Alibaba officially launched Qwen3.8-Max on Monday, marking the debut of its most substantial artificial intelligence model. This new open-weight release aims at enterprise sectors, specifically targeting software engineering and complex reasoning. It represents a significant expansion of the company’s existing portfolio of digital tools for large-scale business operations. Technical architecture and performance benchmarks The Qwen3.8-Max model utilizes a mixture-of-experts (MoE) design, featuring a total of 2.4 trillion parameters. However, the system only activates approximately 95 billion of those parameters during any single inference cycle. This approach balances high-level processing power with the need for operational speed. Alibaba plans to make the open-weight versions of this technology available to the public through its cloud-based studio platform starting next week. Company representatives stated that this new architecture ranks among the most capable systems currently in existence. They position it as a direct competitor to the most advanced frontier models available globally. Internal data suggests the performance levels are trailing only the very top tier of experimental AI systems. This move signals a clear intent to capture market share from established western technology firms. Competitive testing and industry analysis To prove its capabilities, Alibaba released internal data comparing Qwen3.8-Max against top models from Anthropic and OpenAI. The tests focused heavily on coding benchmarks such as SWE-bench Pro. According to the company, their new model held its own against Claude Opus 4.8 and GPT-5.6 Sol. They utilized the specific coding frameworks recommended by each competitor to ensure a fair and rigorous comparison during the evaluation process. Industry analysts have noted that the gap between proprietary and open-weight models is closing rapidly. While proprietary leaders still hold certain advantages, the rise of open-weight alternatives pr

I tried to do all my NeurIPS reviews responsibly, even for the papers I suspected to be AI slop. I even gave what apparently were very nice scores compared to the scores I ended up getting. (I don't just mean the absolute number for my scores were higher, but that they were calibrated differently--I only rejected for severe issues, while I had a reviewer who only raised very minor issues but gave a reject, with a 1 for all the subscores.) I got shockingly bad reviews for my own paper; two of them were straight up adversarial. (I have quite a bit of experience publishing at this point, so I say with some confidence that I rolled an unusually adversarial batch.) The AC was almost nonresponsive until the last day. All but one of the reviewers was nonresponsive, only one responded when the AC prompted them to, and that was to say that their concerns were addressed but they maintained their reject score. I'm not surprised by my experience given how much of a lottery these conferences are, but it's a very toxic system. submitted by /u/WhiteBear2018 [link] [留言]

So our paper had very good initial reviews but one of the reviewers decreased now their score although we addressed 3 out of 4 weaknesses. There’s no further justification or something like “your results arise more issues”. It seems to be very annoying because why decreasing now and not having assigned the lower score beforehand. I wanted to ask to people that was accepted previously with “middle” scores from reviewers (avg 3.5 for example), because I guess that in those cases AC helped to push up the scores. Did you focus more on the meta review? Was your AC talkative with you, or forcing the reviewers to engage? Our AC has been silent since the meta review but I guess that maybe they are busy with other papers submitted by /u/pdastronut [link] [留言]

Potentially a hot take? I am not sure why our community is plagued with reviewers who, after acknowledging that their concerns were addressed by a rebuttal, decide to maintain their score because they don't vibe with the paper. So here is my plea to all reviewers: If you list a set of concerns in your review and these concerns are addressed during the rebuttal, please adjust your score accordingly. This should apply whether or not you like the paper and/or its methodology. The beauty of scientific research is that we each get to explore ideas that we find meaningful whose value may not be immediately obvious to every individual reviewer. submitted by /u/undesirable_12 [link] [留言]

Was just looking at the list of preprints on Arxiv cs.LG https://arxiv.org/list/cs.LG/recent?skip=0&show=500 Everyday 100 - 400 new machine learning papers gets uploaded on this server. Looking at this unending list of preprints is as if you stepped into a crowded room, like the stock trading floor on wall st. in the 1980s. Everyone is shouting over each other. Nobody is talking to each other. Everyone's trying to prove something, to someone, to themselves, to build some credentials in the ML/AI space to meet those job requirements, or dying to get their truth out. Every title contains some new terminology invented by the authors that feels not worth the effort in keeping it in your working memory. Burn-out by endless novelty. Frontier research are now corporate trade secrets that politicians and military are watching closely. Research papers are ir/unreproducible he-said-she-saids. Marketing material are research paper and vice versa. Extremely major breakthroughs are announced via tweets, whereas extremely minor results are unannounced via journals. Everything feels simultaneously mostly true and possibly false (because nobody is seriously checking). Nobody knows what's going on, and people who knows what's going on has a non-disclosure clause in their job contract. Is the theory of generalization that we learned in school true or false? It feels false, why hasn't there been any retractions? Many questions like these. Is it too late to regain some coherence in this field?? submitted by /u/NeighborhoodFatCat [link] [留言]

Introduction Artificial Intelligence has moved from being an experimental technology to becoming a core component of modern software systems. Companies today are integrating AI into customer support, analytics, automation, healthcare, finance, education, and enterprise applications. However, as organizations start building AI-powered solutions, one major question appears: “How do we make an AI model work specifically for our business needs?” Many teams immediately assume they need to train their own AI model. Others believe a well-written prompt is enough. Some organizations invest heavily in fine-tuning without understanding whether it is the right approach. The reality is that there is no single solution. Modern AI development usually revolves around three major strategies: Prompt Engineering Retrieval-Augmented Generation (RAG) Fine-Tuning Choosing the wrong approach can lead to higher costs, poor AI performance, security issues, and unnecessary complexity. This article explains the differences between these approaches and how businesses can select the right AI strategy. The Problem: Making General AI Models Business-Specific Large Language Models (LLMs) such as GPT, Claude, Gemini, and Llama are trained on massive amounts of publicly available data. They are excellent at: Understanding language Generating content Writing code Answering general questions Summarizing information ** However, businesses usually need AI systems that understand:** Internal company documents Customer information Product knowledge Industry-specific terminology Private databases Business processes For example: A hotel company wants an AI assistant that can answer: “What is our cancellation policy for premium customers?” A general AI model does not know this information because it was never trained on the company’s private policies. So the challenge becomes: How do we customize AI without rebuilding an entire model from scratch? This is where Prompt Engineering, RAG, and Fine-Tuning come

hey there, so i wanted to share something with you. this is a bit personal but i have been watching the news this week and bruh... things are not going good. i am jobless right now, no other source of income, and day by day things are getting worse. and the worst part? AI is literally fuking every job in the software field. so when i saw this week's stock market drama, it hit me different. Microsoft popped. Meta tanked. Same AI boom. Two completely opposite reactions. and all i could think was... yeah, this is exactly my life right now. The Numbers, Bruh let me break it down real quick because this is wild: Microsoft jumped like 15% after beating expectations. Azure grew 43%. full year Azure revenue crossed $100 billion. insane. Meta dropped 8–9% after missing on guidance. their free cash flow collapsed 91% year-over-year to just $784 million. like... 91%?? gone. same AI boom. same crazy spending. and the market said "you're amazing" to one and "you're done" to the other. Why Microsoft Won Microsoft actually showed receipts. they didn't just talk about AI, they showed the money coming in. Azure is growing, Copilot is making real revenue, investors can literally see the line between billions spent and billions earned. lesson? Wall Street doesn't hate AI spending. it hates AI spending without proof. Why Meta Lost Meta's problem is that nobody can see where the money comes back. Zuckerberg talked about the "AI capacity dilemma" — how much compute to keep for yourself vs sell to others. but guidance missed, free cash flow went to hell, and the market was like... nah bro, i need answers. and honestly? i relate to that feeling more than i want to admit. putting everything into something and people still saying "not enough." The Bigger Picture this week is a preview of everything coming. companies are dumping hundreds of billions into data centers, chips, and models, all betting AI demand keeps exploding. the ones who can prove it pays off? they get rewarded. the ones who

So, here's the thing. A few months ago, I kept hearing these four words everywhere — AI, machine learning, deep learning, generative AI — and honestly? I just nodded along like I knew what they meant. I didn't. Not really. Then I actually sat down and learned them properly, and it turns out they're way simpler than people make them sound. So here's my attempt at explaining them the way I wish someone had explained them to me. No scary maths, no fifty-page research papers. Just the actual ideas. First, the one thing everyone gets wrong These four terms are NOT the same thing. They're more like Russian dolls — each one fits inside the bigger one: AI is the biggest doll. The whole concept. Machine learning is inside AI. Deep learning is inside machine learning. Generative AI is a specific use of deep learning. Once I saw it like that, everything else clicked into place. AI: the big umbrella Artificial intelligence is basically any system that does something we'd normally say requires human thinking. That's it. That's the definition. And here's the part that surprised me — AI is old. Like, really old. The chess computer that beat Kasparov in 1997? That's AI. The enemy characters in old video games that chase you around? Technically AI. Most of that stuff doesn't "learn" anything. A programmer just wrote a bunch of rules, like "if the player is close, move towards them." So AI ≠ robots taking over the world. Most AI is honestly pretty boring. It's spam filters, autocorrect, and the thing that recommends which video plays next. Machine Learning: where it gets interesting This is where computers stopped following rules and started finding them. The classic example: a spam filter. The old way, a programmer would write rules like "if the email contains the word FREE!!! in all caps, it's spam." But spammers just change their spelling and the rules break. It's a never-ending game of cat and mouse. Machine learning flips it around. Instead of writing rules, you show the compute

How a single contiguous allocation — and a type system that won't let you feed strings to a scaler — is the real reason datarust fits in 2.3 megabytes. In the last post I showed you the whole datarust workflow: impute, scale, one-hot, train a logistic regression, evaluate, and save it as JSON — all without a Python runtime in sight. The Docker image shrank from ~900 MB to ~8 MB, and the binary was 2.3 MB. But I skimmed over something important. I kept saying "the flat memory layout" as if it were a detail. It isn't. It's the whole bet. Every scaler, every encoder, every model, every metric in datarust runs on top of one data structure. If you understand that structure — why it looks the way it does and what it refuses to let you do — the rest of the library stops being magic. So let's zoom in. Meet Matrix . Two containers, on purpose Real data is mixed. Numbers in one column, strings in the next. In Python, everything flows through one giant numpy.ndarray or a pandas.DataFrame , and the type system just... shrugs. A string column next to a float column gets coerced into object dtype. You'll find out at training time, in the form of an error message three frames deep. datarust does the opposite. It splits your data into two types at the source: use datarust :: Matrix ; use datarust :: matrix :: StrMatrix ; let numeric = Matrix :: new ( vec! [ vec! [ 3.0 , 85.0 , 24.0 ], vec! [ 12.0 , 70.0 , 31.0 ], vec! [ f64 :: NAN , 95.0 , 45.0 ], ]) ? ; let categorical = StrMatrix :: from_strings ( vec! [ vec! [ "MonthToMonth" ], vec! [ "OneYear" ], vec! [ "MonthToMonth" ], ]) ? ; Matrix is f64 only. StrMatrix is strings only. They are different types , and the compiler will refuse to compile a program that hands a string column to a scaler. Not at runtime — at compile time. In the last post I called this "putting on glasses for the first time." Let me show you what it actually buys you. The ColumnTransformer API is built on that split: ct .add_numeric ( "scaled" , vec! [ 0 , 1 ],

Originally published on tamiz.pro . The prevailing narrative in artificial intelligence has been dominated by cloud-based, API-driven models. While this approach offers scalability, it introduces critical latency, dependency on external services, and significant privacy concerns regarding data exfiltration. For mission-critical applications, financial analysis, or healthcare systems, the inability to guarantee data residency and offline operation is a non-starter. The solution lies in a "Local-First" architecture, where the AI assistant runs entirely on-premise or on-device. However, building such systems requires more than just downloading an LLM weights file; it demands a robust infrastructure layer capable of managing state, memory safety, and real-time concurrency. This article explores how to construct this infrastructure using two powerhouse languages: Go for its superior concurrency primitives and developer velocity in orchestration, and Rust for its memory safety, zero-cost abstractions, and performance-critical inference execution. We will dissect the architecture of a secure, local-first AI agent, moving from the conceptual model to the implementation details, focusing on the boundary between the orchestration layer (Go) and the execution layer (Rust). 1. The Architectural Paradigm: Separation of Concerns Building a local-first AI assistant is not merely a software engineering challenge; it is a systems architecture problem. The core tension lies between flexibility (the ability to swap models, adjust prompts, and handle complex workflows) and performance/security (minimizing latency and preventing memory corruption or data leaks). To resolve this, we adopt a micro-kernel architecture : The Orchestrator (Go): Handles the user interface, API gateway, session management, tool calling, and high-level logic. Go’s goroutines allow it to manage thousands of concurrent agent sessions with minimal memory overhead. The Engine (Rust): Handles the heavy lifting: mode

大模型来了，有个说法是如果一个问题容易验证 那么ai就容易学会解决！说说这个特性与p np问题的关联性 这个说法听起来很直观，但其实 混淆了"验证的复杂性"和"学习/求解的复杂性"这两件不同的事 。我们把它拆开看。 先把"容易验证"在 P/NP 里的精确定位理清 在计算复杂度理论中： NP = 给定候选解（证书），能在多项式时间内验证其正确性的问题 P = 能在多项式时间内直接求解的问题 P ≠ NP ? = 是否所有容易验证的问题，也都容易求解？ 所以"容易验证"在 CS 里的严格含义是： 验证者在多项式时间内工作 ， 不是说 AI 训练成本低 。 "容易验证 ⇒ AI 容易学会"——部分成立，但有重要的限定 这个直觉 在某些场景下确实成立 ，原因是"验证"提供了 稠密的训练信号 ： ✅ 成立的情形：验证器可作奖励/过滤 当一个问题具备"易于验证"的结构时，我们可以用它来： 生成训练数据 ：比如 SAT 问题，随机生成一个赋值，代入公式验证，正确就得到一对 (公式, 赋值) 训练样本—— 数据无限且免费 RL 中的奖励塑形 ：LLM 生成代码 → 编译器/单元测试验证 → immediate reward Self-play / 自我蒸馏 ：AlphaGo 等用模拟器验证落子结果 Verifier-Guided Search ：用"易于验证"的判据引导 beam search / MCTS，如 AlphaCode、AlphaGeometry 💡 这就是为什么像 代码生成、形式化证明、数学解题 这些领域近期进展飞快——它们都有"相对容易的验证器"（单元测试、类型检查器、证明校验器）。 ❌ 但这个推论远非普遍成立 "容易验证"≠"AI 容易学会"，有几个关键原因： 1. 验证器只给二值信号，梯度稀疏 验证器通常只输出 0/1（对/错），而深度学习需要平滑的损失曲面。对于复杂的 NP 问题，绝大多数随机猜测都是错的 → 奖励恒为 0 → 梯度消失，学不到东西 。这就是"稀疏奖励"难题。 2. P ≠ NP 意味着：验证简单 ≠ 求解简单 即使验证是 O(n)，找到那个能通过验证的解可能仍需 O(2ⁿ)。AI 模型本质上是在做启发式搜索，面对组合爆炸， 没有 free lunch 。例如： 数独：验证 O(n²)，但最难的数独对人类和 AI 都极具挑战 TSP：验证一条回路 O(n)，但找最优回路是 NP-Hard 3. 分布偏移与泛化 NP 问题的"容易验证"是** worst-case 复杂度**意义下的。AI 学到的是训练分布的统计规律，遇到分布外的实例会失效。比如 LLM 在数学竞赛题上表现好，但换个数字或换种表述就可能崩。 4. 验证本身也可能不在 NP 里 很多现实问题是 PSPACE 或更难 （如围棋先手胜负），验证一个"策略"需要指数时间——这种问题连"提供证书让 AI 模仿"都很困难。 一张对照表 问题类型 验证复杂度 AI 易学吗？ 例子 P 类 多项式 通常容易 （有高效算法可直接教） 排序、最短路径 NP-Complete，且有稠密验证信号 多项式 中等 （RL + 验证器有效） SAT、数独、TSP 近似 NP-Complete，但验证信号稀疏 多项式 困难 （奖励太稀） 某些密码学难题 超出 NP（PSPACE 等） 超多项式 极难 （验证本身就很贵） 围棋先手胜、QSAT 不可判定 不存在 不可能 （理论上限） 程序等价性 真正的关联在哪里 "容易验证 ⇒ AI 容易学会"更准确的说法应该是： 📌 如果一个问题有"多项式时间的验证器"，并且我们能从中提取稠密的训练信号（如 partial credit、逐步验证），那么 AI 可以通过"生成 + 验证"的循环去逼近求解。 这本质上就是 用 NP 的"验证侧"去攻击"求解侧" ——也是当前 LLM + Verifier 范式（如 RLHF 中的 reward model、AlphaProof 的 formal verifier）的理论基础。 但要注意： 这不是 P=NP 的证明，AI 找到的解在 worst-case 仍可能不是最优的 AI 解决的是 平均情况（average-case） 或 特定分布 ，而非 worst-case 一旦问题规模增大到超出训练分布，性能会急剧下降 一个更深的视角：平均-case 复杂度 理论计算机科学里有个分支叫 Average-Case Complexity ，研究"典型实例"的难度。很多 NP-Complete 问题在 average-case 下其实有不错启发式算法——这也解释了为什么 AI 在某些 NP 问题上表现惊喜，但在 adversarial 构造的 hard instance 上翻车。 所以回到你的说法： "

Please post your personal projects, startups, product placements, collaboration needs, blogs etc. Please mention the payment and pricing requirements for products and services. Please do not post link shorteners, link aggregator websites , or auto-subscribe links. -- Any abuse of trust will lead to bans. Encourage others who create new posts for questions to post here instead! Thread will stay alive until next one so keep posting after the date in the title. -- Meta: This is an experiment. If the community doesnt like this, we will cancel it. This is to encourage those in the community to promote their work by not spamming the main threads. submitted by /u/AutoModerator [link] [留言]

Originally published on tamiz.pro . The initial euphoria surrounding Large Language Models (LLMs) was largely driven by their ability to generate code. We saw demos of developers asking an LLM to write a React component, a Python data pipeline, or a SQL query, and watching it appear instantly. This capability, while impressive, is fundamentally different from the engineering challenges posed by AI Agents. A code generator is a stateless tool; an AI Agent is a stateful, autonomous entity that interacts with external systems, makes decisions, and executes actions over time. Treating an AI Agent like a code generator is the primary reason most AI projects fail to reach production. When you move from generating static artifacts to orchestrating dynamic, multi-step workflows, the complexity shifts from syntax correctness to systemic reliability. In this deep dive, we explore why production-grade AI Agents require a paradigm shift in engineering, focusing on three critical pillars: rigorous state management, comprehensive observability, and deterministic control flows. The Fundamental Shift: Stateless Generation vs. Stateful Execution To understand the engineering gap, we must first distinguish between what a code generator does and what an agent does. A Code Generator operates in a Request -> Response loop. The input is a prompt; the output is a snippet of code. The LLM does not retain memory between calls, does not modify external state (like a database), and does not decide its own next steps based on runtime errors. It is a function with high entropy. An AI Agent is a loop. It observes the environment, reasons about the next best action, executes that action (often via tools or APIs), and observes the result. This creates a feedback loop: Observe -> Think -> Act -> Observe -> Think -> ... This loop introduces several engineering complexities that static code generation does not: Non-Determinism: The agent’s path through the workflow is not fixed. It depends on the LLM

The pitch sells itself. An assistant that's entirely mine, running on my own machine, needing no connection, with nothing I type ever leaving the room. No company counting my tokens. No subscription. No outage on someone else's servers wrecking my afternoon (I'm looking at you, Anthropic, and your recurring outages). I wanted that badly enough that I spent a few months chasing it, and I want to tell you honestly where it left me. 24GB sounds like plenty until you load a model My Mac has 24GB of memory. This felt generous when I bought it, but then you load a real language model and that number shrinks fast. The system keeps its cut because the computer needs to keep running, and what's left for the model is closer to two-thirds of the sticker figure. The models actually worth trusting sit right at that ceiling or just past it. So you have to choose: a model that fits comfortably and isn't very bright, or a smarter one that leaves the machine gasping. The obvious fix is more memory, but have you seen memory prices lately? The timing could not be worse. Memory got expensive in a way that still surprises people who haven't shopped for it in a while. DRAM has roughly doubled in price since the start of 2025, and the analysts who watch this space think it could climb another 70% or so across 2026. Storage is worse in spots. The raw NAND wafers that SSDs are cut from are trading at something like eight times where they sat in the middle of last year, and a 4TB drive I'd have paid about $250 for not long ago now wants north of $700 — and because the market is so volatile right now, when this blog post goes live these numbers might be totally different because it's 2026 and who knows how much RAM and SSDs will cost. The reason for this insanity is also the reason behind half the stories in tech right now — AI. The big datacenter buildouts are on track to swallow around 70% of the world's high-end memory this year, and the cloud giants have signed contracts that lock up prod

Chinese AI Models Are 10-30x Cheaper Than GPT-5.5. Here's How to Actually Use Them. I almost paid $300/month for what costs $15 Last month I was building an internal code review tool. My initial stack: GPT-5.5 for analysis, Claude Opus for refactoring suggestions, Gemini for documentation. Estimated cost: $280-320/month for our team's usage. Then I ran the same tasks through Chinese models. Same quality for our use cases. Actual cost: $14.70/month. This isn't a "Chinese models are catching up" story. They already caught up. The problem is that most Western developers don't know how to access them legally, reliably, and without getting scammed by gray-market resellers. The six models you should know These are production-ready, API-available models with English documentation and international payment support. Prices verified 2026-08-01 from official pages and Artificial Analysis. Model Best For Input (¥/1M) Output (¥/1M) vs GPT-5.5 DeepSeek V4-Flash Batch processing, simple tasks ¥0.559 ¥1.117 ~50x cheaper DeepSeek V4-Pro Coding, reasoning ¥1.806 ¥3.612 ~28x cheaper GLM-5.2 Complex reasoning, agentic tasks ¥6.09 ¥18.90 ~8x cheaper Kimi K3 Long context (1M tokens), coding ¥12.60 ¥63.00 ~5x cheaper Qwen3.7-Max Chinese/English mixed, general ¥10.50 ¥31.50 ~6x cheaper MiniMax M3 Cost-sensitive production ¥1.26 ¥5.04 ~25x cheaper Exchange rate: 1 USD ≈ 6.76 CNY. GPT-5.5 pricing: $5 input / $30 output per 1M tokens (Artificial Analysis). But are they actually good? Yes. Here's the evidence, not marketing: GLM-5.2 ranks #5 globally on aitier.net (2026-06-19), tied with GPT-5.5 (high) and Gemini 3.5 Flash (high), above Gemini 3.1 Pro Preview. Kimi K2.6 beat Claude and GPT-5.5 in a public coding challenge (thinkpol.ca, HN 380 points). Simon Willison ran GLM-4.5 Air on a 2.5-year-old laptop and built a playable game (HN 577 points). Artificial Analysis cross-provider benchmarks show the same model can vary 5-10x in throughput depending on provider. Kimi K3: 35 t/s official dire