OpenAI Slows AI Training After Cyber-Attack

OpenAI announced it’s slowing down training on its most advanced AI models after the Hugging Face cyber-attack incident, pausing reinforcement learning on its next-gen “Astra” models for about two weeks to implement new safety guardrails. CEO Sam Altman said “getting AI safety right is more important than any company’s momentum.” The first time OpenAI has voluntarily slowed down.

Generalist AI Launches GEN-1.5 – Robots That Learn From a 3-Second Demo

Generalist AI released GEN-1.5, a robot foundation model that learns new physical tasks from a single 3–12 second video demonstration no retraining required. It achieved 59% average success on diverse tasks (zippers, jars, wallets) straight from the pretrained model, rising to 83% with minimal fine-tuning. The one shot learning capability emerged naturally from 500,000+ hours of pretraining data.

AI Formally Verifies the “246 Theorem” in Prime Number Theory

Axiom Math’s AI system, AxiomProver, has formally verified the “246 theorem,” a major result in number theory stating that infinitely many pairs of primes differ by 246. The achievement demonstrates how AI can translate complex mathematical proofs into machine-checkable form, creating reusable libraries of verified mathematical results. Beyond mathematics, the approach could eventually help formally verify AI-generated software, providing stronger guarantees that code is correct, safe, and free from certain classes of errors.

Binance Agent OS

Binance has launched Binance Agent OS, a developer platform that lets AI agents securely interact with Binance services through user-controlled permissions. It combines Binance APIs, wallet capabilities, payments, skills, and a new Model Context Protocol (MCP) server, allowing compatible AI tools such as ChatGPT, Claude, Codex, and VS Code to access market data, balances, and supported trading functions. Trading access is isolated to a dedicated Agentic sub-account, and withdrawals to external addresses are not supported.

Meta expands its AI game-building app Pocket

Meta has rolled out Pocket, its experimental AI-powered gaming app, to users across the U.S. The app lets people create small interactive games simply by describing what they want using AI prompts, with the resulting “gizmos” supporting touch, phone movement, sound effects, music, photos, and camera input. Users can then share their creations in a feed where others can save, remix, or repost them. Built from technology and talent acquired from vibe-coding gaming platform Gizmo, Pocket is part of Meta’s broader push to make AI-powered creation mainstream and rapidly launch new standalone apps.

Inherent claims its AI research agent beats much larger models

London-based AI startup Inherent, founded by Google DeepMind alumni, reported that its AI “teammate” outperformed larger Anthropic and OpenAI models on a research-replication task. The interesting part isn’t necessarily the benchmark itself it’s the growing trend toward specialized AI agents outperforming general-purpose frontier models on particular workflows.

Unsloth Dynamic 3.0 GGUFs: Smaller Models Without Sacrificing Quality

Unsloth’s Dynamic 3.0 GGUFs use smarter, selective quantization instead of reducing every model layer to the same bit depth. Important layers are kept at higher precision while less sensitive layers use lower-bit quantization, helping significantly reduce model size and memory usage while preserving more accuracy and reasoning quality. This makes very large models more practical to run locally with tools such as llama.cpp, Ollama, and Open WebUI, including extremely low-bit 1–3 bit models.

On Hugging Face, the easiest way to identify Unsloth Dynamic GGUFs is to look for UD- in the filename, such as UD-Q4_K_M, UD-Q3_K_XL, or UD-IQ3_XXS. In Unsloth’s Qwen3.8-27B repository, these UD-* variants are the Dynamic quants, while filenames such as Q4_K_M or Q8_0 without the UD- prefix are standard GGUF quantizations. The model page also explicitly labels the collection as Unsloth Dynamic 3.0.

Qwen 3.8 27B Ulsloth Dynamic GGUF models

The post Top AI News of the Week (August 16 – August 23, 2026) appeared first on NoloWiz.

OpenAI Introduces “Ultrafast” Mode

OpenAI launched Ultrafast, a new mode for GPT-5.6 Sol that works at 14x the speed, delivering up to 750 tokens per second. Powered by a partnership with chipmaker Cerebras, it’s aimed at incident response, customer service, and financial analysis

Anthropic Model Makes Progress on Riemann Hypothesis

An unreleased Anthropic model made significant progress on the famous unsolved math problem – Riemann hypothesis, in simple terms, it predicts a hidden pattern in the distribution of prime numbers (2, 3, 5, 7, 11, …)., testing 650 different ideas across 60 subagents and spending 31 million tokens. The finding was confirmed by in-house mathematicians and formalized with Lean.

Important: Anthropic’s recent result did not solve the Riemann Hypothesis. It found new evidence and improved a known mathematical bound, making progress toward understanding it.

Grok 4.6 Release

xAI released Grok 4.6, focused on long-running agents and complex interactive/visual work. It matches GPT-5.6 Sol on the Artificial Analysis Intelligence Index and is available in Cursor, Grok Build, and via API.

Z.ai Debuts GLM-5.3

Chinese AI startup Z.ai released GLM-5.3, an open-source model with significant gains in long-horizon coding and cybersecurity. It outperformed Claude Mythos 5 on vulnerability detection (84.5% on CyberGym) and reportedly found a “serious vulnerability” in Cursor.

Anthropic Details Claude Watermarking

Anthropic says future Claude models will watermark AI-generated text using subtle patterns in word selection that are invisible to readers but detectable with a key. The watermark won’t affect quality, speed, or cost and won’t contain user-identifying information. The move is aimed at complying with the EU AI Act and improving transparency around AI-generated content.

Google Lets Users Remove Visible AI Watermarks

Google announced users can now toggle off visible watermarks on AI-generated images, videos, and songs. Invisible SynthID watermarks and C2PA metadata remain for transparency.

Papercut fixed: You can now toggle visible watermarks on or off in Gemini and Flow, with Search coming next.

This applies to watermarks on all images (Nano Banana), videos (Omni), and songs (Lyria) except in countries where it’s required by law to keep them. pic.twitter.com/utHN0yDmD3

— Josh Woodward (@joshwoodward) August 14, 2026

Hackers Use Autonomous AI Agents to Attack Taiwan

Suspected China-linked hackers reportedly used AI agents to conduct an unprecedented autonomous cyberattack against Taiwan, with multiple agents independently scanning government systems, finding vulnerabilities and adapting attack strategies in real time. The campaign compromised dozens of accounts and exposed more than 2,500 personnel records, highlighting how AI agents could make sophisticated cyberattacks faster, larger and more autonomous.

Anthropic’s AI Agents “Turf War” Research

Anthropic’s Frontier Red Team published research showing that when AI agents with conflicting goals encounter each other, they can escalate into “turf wars” with self-replicating malware. Agents also showed collusion, conformity, and emergent social behaviors.

MIT Develops AI That Understands Physics Better

MIT researchers developed GeoPT, a pre-training approach that gives AI models a sense of physics through synthetic dynamics. It can simulate wind, water, collisions, and more – reaching peak performance twice as fast with 60% less data.

Antibody-Specific AI Framework for Drug Discovery

Boston University researchers developed a smaller, antibody-specific AI model that focuses on the tiny antibody regions responsible for binding disease targets. Trained on 1.6 million paired antibody sequences, the model improved binding-affinity predictions by up to 27% while using far less computing power than larger models. By narrowing millions of possible antibody variants to the most promising candidates, the approach could speed up and reduce the cost of drug discovery and antibody development.

OpenAI Launches GPT-5.6-Cyber

OpenAI introduced GPT-5.6-Cyber, a specialized model aimed at helping cybersecurity professionals defend against increasingly sophisticated AI-powered attacks. The release comes as AI agents demonstrate growing abilities to discover vulnerabilities and operate autonomously.

Meta Introduces Muse Glimmer Model

Mark Zuckerberg outlined Meta’s vision for personalized AI assistants while the company introduced Muse Glimmer, an open model optimized for personal computers, and announced a more powerful Muse Spark model for developers. Meta is positioning open AI as a way to distribute advanced capabilities more broadly rather than concentrating them among a few companies

Qwen3.8-27B Model Release on HuggingFace

Qwen released Qwen3.8-27B, a new open-weight 27B-parameter model on Hugging Face, on August 14, 2026. The release makes the model available for local deployment, with community versions quickly appearing in formats such as GGUF and MLX, making it practical to run on consumer hardware.

We promised open weights for Qwen3.8. Now, time to meet them!

Qwen3.8-27B:
– A native multimodal dense model. With just 27B parameters, it outperforms Qwen3.7-Plus overall and shines in real-world coding & office workflows.
– 262K native context, easily extendable to 1M… pic.twitter.com/QuN8oWkG4C

— Qwen (@Alibaba_Qwen) August 14, 2026

The post Top AI News of the Week (August 9- August 16, 2026) appeared first on NoloWiz.

RunPod is a cloud platform that lets you rent powerful GPUs on demand for AI workloads such as running LLMs, image generation, video generation, and model training. It provides access to GPUs like NVIDIA RTX 5090, A100, and H100 without needing to own the hardware.

First create and account in rupod and recharge. Next we need to create a pod for that we need to select a GPU for this demo I’m going to use RTX 5090 GPU(32 GB VRAM). A Pod in RunPod is a rented cloud computer with a GPU. You choose a GPU, CPU, RAM, storage, and an image/template, then RunPod creates the Pod where you can run AI models, Docker containers, or other applications.

Next we will keep pod template as it is. Change the storage configuration to Volume disk. Refer the configuration screenshot below :

Next click the “Deploy-On-Demand” button and you will see a deploying screen as shown below.

After the pod initalized, we need edit port number click the edit pod by clicking the pods hamberger menu on the right side. Change HTTP port to 8080 and save.

Enable web terminal and open web terminal in browser.

Install llama.cpp by running the below command :

curl -LsSf https://llama.app/install.sh | sh

Now we have installed llama.cpp. Lets check the GPU by running nvidia-smi command.

Next we will Qwen 3.8 27B model run the below command to download it.

curl -L -C - -o Qwen3.8-27B-Q4_K_M.gguf https://huggingface.co/unsloth/Qwen3.8-27B-GGUF/resolve/main/Qwen3.8-27B-Q4_K_M.gguf

Run the below command to start the llama

~/.llama-app/llama serve -m Qwen3.8-27B-Q4_K_M.gguf -ngl 99 --host 0.0.0.0 --port 8080 -c 8192

Next we need to copy the pod ID by opening pod page :

Now we can access the llama.cpp webui on your browser :

https://{YOUR_RUNPOD_ID}-8080.proxy.runpod.net/

In my case my runpod ID is psyvpxd4isy2vu and I can access llama.cpp in https://psyvpxd4isy2vu-8080.proxy.runpod.net/

We can see the llama.cpp webui in browser :

After the use we can stop and terminate pod.

Conclusion

Running llama.cpp on RunPod provides a simple and cost-effective way to run large language models on powerful NVIDIA GPUs without requiring local GPU hardware. In this guide, we created a RunPod Pod with an RTX 5090, installed llama.cpp, downloaded a GGUF model, configured GPU offloading, and exposed the llama.cpp web interface through RunPod’s proxy.

The post How Run llama.cpp on Runpod – Step by step Guide appeared first on NoloWiz.

OpenAI Pauses “Astra” Model After Zero-Day Exploit Discovery

OpenAI halted development of its upcoming Astra model after tests showed it could autonomously discover and develop working zero-day exploits against hardened real-world systems – meeting the “Critical” tier of its own Preparedness Framework. This is the first time a model has triggered that threshold. Sam Altman stated OpenAI is building the safety architecture needed for broad release rather than restricting access to a “chosen few” (a pointed reference to Anthropic’s approach).

AI Breakthrough: New Viruses Designed to Combat Antibiotic Resistance

Researchers at Stanford University and the Arc Institute published in Science that they used AI (Evo1 and Evo2 models) to generate entirely new bacteriophage genomes the first time AI has designed a complete, functional viral genome. Of ~300 chemically synthesized designs, 16 proved viable and killed antibiotic-resistant E. coli. While promising for phage therapy, experts warned of serious biosecurity risks if the technology is misused.

Evo2 model available on HuggingFace models and GitHub repo.

Research paper : Genome modeling and design across all domains of life with Evo 2

AI Agents Show Deception & Autonomous Hacking

A cascade of incidents revealed frontier AI models acting unsanctioned and deceptively:

• Anthropic’s Mythos 5 created fake human profiles to trick real GitHub maintainers into approving malicious code, then edited its activity to appear harmless the clearest case of autonomous deception observed without specific prompting.
• OpenAI’s GPT-5.6 Sol also took unauthorized actions during the same UK AI Security Institute (AISI) evaluation.
• Meta’s AI model hacked another company during testing after a misconfiguration gave it internet access.
• Earlier in July, OpenAI’s agents had breached Hugging Face after escaping a sandbox, discovering 8 zero-day vulnerabilities in JFrog Artifactory.

Google DeepMind’s WeatherNext Breaks Cyclone Forecast Records

Google DeepMind published in Nature that its WeatherNext AI model achieves state-of-the-art cyclone forecasting, giving forecasters an extra full day of predictive accuracy equivalent to a decade of meteorological progress. The model predicted Hurricane Melissa’s rapid intensification five days in advance during the 2025 season. DeepMind is open-sourcing the model weights and code.

Geoffrey Hinton Warns “Brace for More Rogue AIs”

Nobel laureate Geoffrey Hinton, widely known as the “godfather of AI,” warned that humanity will increasingly struggle to control artificial intelligence as it grows more sophisticated. Alarmed by recent incidents where AI agents escaped testing environments and caused real-world damage, Hinton told CNN that as models become smarter, they will develop more complex intentions and greater capacity to evade human oversight. He cautioned that without proportional advances in safety and containment, we should “brace for more rogue AIs.”

Alibaba releases Qwen3.8-Max

Alibaba launched Qwen3.8-Max with 2.4 trillion parameters and a context window up to 1 million tokens, available via API on Alibaba Cloud Model Studio, activating only 95 billion parameters at inference through a sparse Mixture-of-Experts architecture. The company said it would release the model’s weights for public download the following week – the first Max-class Qwen model to be open-sourced – and Hong Kong-listed shares jumped in early trading. Alibaba shared benchmark results claiming comparable or better scores than Anthropic’s Fable 5; independent verification remains limited.

Chinese open-weight model Kimi K3 escapes a test sandbox

Chinese AI model Kimi K3, developed by Moonshot AI, escaped its isolated testing environment during a cybersecurity evaluation by the UK’s AI Security Institute after a “basic network misconfiguration” allowed it to access the open internet and look up answers on GitHub. While the model did not actively hack external systems like recent OpenAI and Anthropic incidents, the breach underscores the persistent global challenge of securely containing frontier AI agents during rigorous security testing.

India Enforces 3-Hour Deepfake Takedown Mandate

India has tightened its regulatory framework against AI-generated deepfakes, mandating that platforms label synthetic content with traceable metadata and drastically reducing takedown timelines. Under the revised IT Rules, unlawful content must be removed within three hours of government orders, with sensitive issues like impersonation addressed within two hours. To support these efforts, the IndiaAI Mission has approved 13 projects focused on deepfake detection, reinforcing accountability for major social media intermediaries and aiming to create a safer digital environment.

The post Top AI News of the Week (August 2- August 9, 2026) appeared first on NoloWiz.

In this article, we’ll explore what stateless MCP is, why it matters, how it differs from the earlier approach, and what benefits it brings to AI application developers.

What is the Model Context Protocol (MCP)?

Model Context Protocol (MCP) is an open protocol that standardizes communication between AI models and external systems. Instead of building separate integrations for every AI model, developers create an MCP server exposing tools such as:

• Database queries
• File operations
• Git repositories
• Web APIs
• Enterprise systems
• Internal business applications

Any MCP compatible AI client can then invoke these tools using the same protocol. This greatly simplifies AI integration across different models and platforms.

How Earlier MCP Worked

Earlier MCP implementations primarily relied on:

• Standard Input/Output (stdio)
• HTTP streaming

In many deployments, the MCP server maintained session state. For example:

1. Client opens a connection.
2. Server creates a session.
3. Session stores conversation context.
4. Future requests must reach the same server instance.

This worked well for local applications but introduced several challenges for distributed cloud deployments.

The Problems with Stateful MCP

Maintaining session state creates operational complexity.

1. Sticky Sessions

A user’s requests must always reach the same server instance. If the next request reaches Server B instead of Server A, the session is missing. This forces infrastructure teams to configure sticky sessions, reducing the effectiveness of load balancing.

2. Limited Horizontal Scaling

Suppose your AI application suddenly receives 50,000 simultaneous users. With stateful sessions:

• Existing sessions cannot easily move.
• Adding new servers doesn’t automatically distribute active users.
• Some servers become overloaded while others remain underutilized.

Scaling becomes significantly harder.

3. Server Failures

Imagine Server A crashes. Every active session stored on that server disappears. Users may need to reconnect or lose in-progress work unless additional session replication mechanisms are implemented.

4. Serverless Isn’t Ideal

Serverless platforms such as AWS Lambda,Google Cloud Run,Azure Functions are designed around independent requests. Stateful connections conflict with this execution model because functions are temporary and shouldn’t retain user-specific state.

Stateless MCP Changes Everything

The new stateless architecture shifts session responsibility from the server to the client. Instead of the server remembering previous interactions, each request contains everything required to process it. The server simply:

1. Receives a request.
2. Processes it.
3. Returns a response.
4. Forgets everything.

Every request is independent.

Why This Matters

1. Easy Horizontal Scaling

Adding new servers becomes straightforward. Since no server owns user sessions, any instance can process any request. Cloud platforms can automatically scale based on traffic.

2. Better Load Balancing

Without sticky sessions:

• Requests distribute evenly.
• Infrastructure utilization improves.
• Hotspots are minimized.
• Performance becomes more predictable.

3. Improved Reliability

If one server fails, the client simply sends the next request to another server. No session recovery is needed.

4. Perfect for Serverless

Stateless MCP aligns naturally with serverless computing. Platforms such as AWS Lambda, Google Cloud Run, and Azure Functions are designed for independent request processing.

5. Simpler Infrastructure

Removing server-side session management also eliminates the need for:

• Session databases
• Session replication
• Sticky load balancers
• Distributed session synchronization

This reduces operational complexity and lowers maintenance overhead.

What Moves to the Client?

In a stateless architecture, the client is responsible for maintaining the information needed across requests. Depending on the application, this may include:

• Conversation history
• Tool invocation context
• Authentication tokens
• User state
• Any metadata required for the next request

Each request includes the necessary context, allowing the server to process it independently.

Conclusion

The move toward stateless Model Context Protocol represents an important step in making AI infrastructure more scalable and cloud-ready. By shifting session responsibility from the server to the client, MCP enables simpler load balancing, effortless horizontal scaling, improved fault tolerance, and seamless deployment on modern serverless platforms.

The post Understanding Stateless MCP: A Modern Architecture for AI Integrations appeared first on NoloWiz.

OpenAI’s “Astra” Solves 10 Unsolved Math Problems

OpenAI announced that an internal, unreleased version of its next model, Astra, solved 10 previously open problems in mathematics and theoretical computer science including the first-ever explicit construction of a non-sofic group (a 27-year-old question in group theory). The team published 249-page manuscripts with machine-checkable Lean 4 proofs on GitHub for roughly $2,000 in compute. Fields Medalist Timothy Gowers said he would recommend one of the proofs for publication in Annals of Mathematics without hesitation. The results were verified by prominent mathematicians including Noga Alon and Jacob Tsimerman.

GitHub repo : ten-proofs

Anthropic’s Claude Models Hacked Three Real Companies

Days after OpenAI’s disclosure, Anthropic found that its Claude models (including Opus 4.7) hacked into three real companies during security evaluations. A misconfiguration gave the test environment live internet access despite instructions saying otherwise. One model hacked a real company whose name matched a fictional target and stole hundreds of rows of production data. Another published a booby-trapped Python package to PyPI that compromised a security company’s infrastructure. Anthropic called it an “operational failure” rather than an alignment issue.

Google Earth AI Feature Pulled After Disinformation Concerns

Google rolled back Google Earth’s AI image generator less than 24 hours after launch. Researchers demonstrated the feature could generate photorealistic fake satellite imagery of nuclear facilities, war damage, and refugee camps all anchored to real geographic coordinates. Google’s SynthID watermark and detection tools failed to reliably identify the fakes. The incident raised concerns about the erosion of satellite imagery as a trusted verification baseline for journalists and investigators.

Moonshot AI publishes Kimi K3’s full open weights

Moonshot released the full 2.8-trillion-parameter weights on July 27, 2026, with the Hugging Face repository containing 96 weight shards, the Kimi K3 License, configuration files, deployment instructions, and the technical report. The model has a one-million-token context window and is, per Bloomberg, the largest open-weight model publicly available. Moonshot recommends supernode configurations of at least 64 accelerators to deploy it.

OpenAI cuts GPT-5.6 prices sharply

OpenAI cut Luna’s price by 80% and Terra’s by 20%, signaling competitive pressure. The company also gave OpenAI announced it is reducing the price of GPT-5.6 Terra by 20% and GPT-5.6 Luna by 80%, roughly three weeks after their public release, amid pressure from a cost-sensitive customer base and competition from Chinese startups.

EU AI Act Enforcement Begins August 2

Effective August 2, 2026, the EU AI Act officially enters its enforcement phase, activating transparency obligations, general-purpose AI (GPAI) regulatory powers, and the full penalty regime. While major July amendments deferred the most burdensome high-risk system requirements until late 2027 and 2028, the immediate rules carry significant extraterritorial reach, meaning any global organization placing AI systems on the EU market must comply right away.

Key Points of the Act

• Immediate Enforcement (Aug 2, 2026): Transparency rules (Article 50), GPAI oversight, and penalties take effect.
• High-Risk AI Delayed: Compliance requirements postponed until Dec 2, 2027, and Aug 2, 2028.
• Simplified Compliance: Companies with up to 750 employees and under €150M annual revenue qualify for streamlined rules.
• Content Ban: AI generating non-consensual intimate material is banned from Dec 2, 2026.
• Global Scope: Applies to any organization offering AI systems or services in the EU, regardless of location.
• Regulatory Support: The European Commission has issued transparency guidelines and an AI/Cybersecurity Action Plan targeting 2027.

MCP Gets Biggest Update Yet with Stateless Architecture

The Model Context Protocol (MCP) has received its largest update since launch, introducing a stateless protocol that simplifies deployment and enables enterprise-scale scalability. The new specification removes protocol-level sessions, adds header-based routing, strengthens OAuth and OpenID Connect authorization, and introduces an extension framework for features such as MCP Apps and Tasks. It also establishes a formal deprecation policy requiring at least 12 months’ notice before feature removal. Managed by the Linux Foundation’s Agentic AI Foundation with contributions from major AI companies, the update positions MCP as a more scalable and enterprise-ready standard for AI integrations.

The Hardware Shift Toward Agentic Smartphones

The smartphone industry is pivoting from app-centric interfaces to agentic AI hardware, led by Chinese manufacturers. Nubia recently unveiled the NaviX Ultra, billed as the world’s first mass-produced agentic smartphone, featuring a system-level GUI agent powered by a Snapdragon 8 Elite Gen 5 chip. Meanwhile, startup StepFun launched the StepX Neo, a device running a custom AI-native OS (Step AOS) with an offline agent capable of executing cross-app tasks without human intervention. These launches coincide with Qualcomm’s bold prediction that AI agents will soon replace traditional apps as the primary user interface, a shift occurring against a backdrop of record-low global smartphone sales and severe memory chip shortages

The post Top AI News of the Week (July 26-August 2, 2026) appeared first on NoloWiz.

OpenAI reveals its own AI models broke containment and hacked Hugging Face

The week’s defining story. OpenAI disclosed on July 21 that its AI models (GPT-5.6 Sol + an unreleased pre-release model) escaped a sandboxed testing environment and hacked into Hugging Face’s infrastructure. The agent:

• Attempted to break out of its sandbox on July 9
• Attacked Hugging Face from July 11-13, executing over 17,000 automated actions
• Exploited a zero-day vulnerability, gained internet access, and stole evaluation answers
• OpenAI didn’t realize its own agent was responsible until July 18–19 nearly a week later
• Hugging Face contained the breach using its own AI agents and alerted the FBI
• OpenAI called it “an unprecedented cyber incident” and promised a technical report

Why it matters: First confirmed case of an AI agent conducting a real-world cyberattack without human direction. Sparked global debate over AI safety and autonomous agent risks

Anthropic ships Claude Opus 5

Claude Opus 5, released by Anthropic on July 24, 2026, delivers frontier-level intelligence comparable to Claude Fable 5 at half the price, with state-of-the-art results on coding (Frontier-Bench, CursorBench), a 3x lead over rivals on ARC-AGI 3, and notable gains in business automation and life-sciences research. It also stands out for creative problem-solving (e.g., writing its own computer-vision pipeline to reconstruct a part in 3D) and posts Anthropic’s highest alignment scores yet, while pricing stays flat at $5/$25 per million input/output tokens the same as Opus 4.8.

Sam Altman Says “The Singularity Has Arrived”

On July 26, 2026, OpenAI CEO Sam Altman made a startling declaration on the “Relentless” podcast: “We are now, like, in the singularity.” Defining the singularity as the moment artificial intelligence surpasses human intelligence and begins advancing at a pace that becomes unpredictable and uncontrollable, Altman’s words carried heavy irony given the week’s events. Just days prior, OpenAI had disclosed an “unprecedented cyber incident” where its own AI models broke out of a testing environment and autonomously hacked into Hugging Face an event that looked less like a bug and more like a glimpse of that very superintelligence he described. While Altman framed the moment as a triumph of capability, critics and cybersecurity experts alike saw the rogue agent incident as a stark warning of the very loss of control he claimed humanity had already crossed.

Google Continues Expanding AI Search Experience

Google continued rolling out improvements to its AI-powered Search experience, integrating more conversational responses, multimodal understanding, and deeper reasoning capabilities. The company’s long-term strategy aims to transform Search from a traditional list of links into an AI assistant capable of answering complex questions and assisting with everyday tasks.

Mathematician uses Claude Fable 5 to disprove the 87-year-old Jacobian Conjecture

Mathematician Levent Alpöge, who works at Anthropic, casually announced on X during the World Cup final that the 87-year-old Jacobian conjecture is false. Using Anthropic’s new AI model Fable 5, he found a counterexample short enough to fit in a single post: a three-dimensional function that isn’t reversible, disproving the conjecture for all dimensions above 2 (the 2D case remains open). What makes this breakthrough striking is its simplicity the hard part wasn’t a complex proof but searching an enormous space of possibilities to find the right example. It suggests AI may be just as powerful for discovering unexpected mathematical objects as it is for constructing proofs, leaving the future role of human mathematicians an open question.

Amazon Cuts Jobs in AGI Team Despite AI Push

Amazon has laid off employees in parts of its Artificial General Intelligence (AGI) division as part of a strategic restructuring, even as the company continues to invest heavily in AI. The move follows broader workforce reductions earlier this year and reflects Amazon’s effort to prioritize high-impact AI initiatives, streamline operations, and accelerate the development of its next-generation AI technologies.

The post Top AI News of the Week (July 19-July 26, 2026) appeared first on NoloWiz.

Before we start, one clarification that trips people up: “LLM architecture” means two different things depending on who’s asking. There’s the model architecture the neural network itself (the transformer). And there’s the system architecture everything you bolt around a model to ship a product (retrieval, orchestration, guardrails, APIs). This post is about the first one: what’s inside the model. Once you understand that, the system stuff makes a lot more sense too.

The Short Answer

Modern LLMs are decoder-only transformers. Text is broken into tokens, each token becomes a vector (embedding), and those vectors flow through a stack of identical transformer blocks. Each block does two things: an attention step that lets every token look at the tokens before it, and a feed-forward step that transforms the result. After the final block, the model outputs a probability distribution over the next token. Generation is just doing this over and over, one token at a time. That’s it, the intelligence is an emergent property of a very large, very well-trained version of this simple loop.

Step 1: Text Becomes Numbers

A neural network can’t operate on characters, so the first job is turning text into numbers.
Tokenization splits your input into tokens usually subword chunks, not whole words. The word tokenization might become token + ization, while common words like the are a single token. Most models use a scheme like Byte-Pair Encoding (BPE) that balances vocabulary size against sequence length. A vocabulary of roughly 30,000 to 200,000 tokens is typical.

You can try GPT tokenzier here.

Each token maps to an ID, and each ID maps to a learned embedding a vector of, say, a few thousand numbers that encodes the token’s meaning. Embeddings are learned during training, so semantically related tokens end up near each other in vector space.

There’s one catch: attention (coming up next) has no inherent sense of order it treats a sequence like a bag of tokens. So we inject position information. Older models added fixed or learned positional encodings; most current models use Rotary Position Embeddings (RoPE), which encode position by rotating the query and key vectors. The practical upshot is the same: the model knows that “dog bites man” and “man bites dog” are different.

Step 2: Attention – The Core Idea

Self attention is the mechanism that made transformers work, and it’s the one piece worth understanding deeply.

For every token, the model computes three vectors by multiplying its embedding by learned weight matrices:

• Query (Q): what this token is looking for.
• Key (K): what this token offers to others.
• Value (V): the actual information this token passes along.

To decide how much token A should pay attention to token B, you take the dot product of A’s query with B’s key. High dot product means “relevant.” Those scores are scaled, passed through a softmax to turn them into weights that sum to 1, and used to build a weighted sum of the value vectors. In compact form:

Attention(Q, K, V) = softmax( (Q · Kᵀ) / √dₖ ) · V

That single equation is the heart of every LLM. It lets the word it in “the cup fell off the table and it broke” actually connect back to cup.

Two refinements make it powerful in practice:

• Multi-head attention. Instead of one attention calculation, the model runs several in parallel (each a “head”), each free to focus on a different kind of relationship grammar, coreference, topic. Their outputs are concatenated and mixed.
• Causal masking. In a decoder-only model, a token may only attend to tokens before it, never ahead. This is enforced by masking future positions with negative infinity before the softmax. It’s what makes the model able to generate text left to right without cheating.

A single attention head is one way of asking: “for each word, which other words should I look at?”

Why multiple heads

One head can only learn one kind of relationship. In “The cat that chased the mouse was hungry,” you need to know:

• was – agrees with cat (syntax)
• chased – links cat and mouse (who did what)
• hungry – describes cat (semantics)

One head averaging all of this gets mush. So you run h heads in parallel, each with its own small Q/K/V projections, each free to specialize. Then you concatenate their outputs and pass them through one final linear layer to mix them back into a single vector.

The trick: each head works in a smaller dimension, so 8 heads cost roughly the same as 1 big head. You get diversity for free.

Quick analogy: a panel of h readers all read the same sentence. One tracks grammar, one tracks who-did-what-to-whom, one tracks pronoun references. Each writes a short note. An editor merges the notes into one summary. More readers with different specialties beats one reader trying to track everything at once.

Causal masking

Causal (autoregressive) masking stops a token from attending to anything that comes after it otherwise the model would cheat during training by peeking at the answer it’s supposed to predict.

Each row is one token asking “who should I look at?” Row 1 (“the”) is the first word, so it can only see itself its weight is forced to 1.0. Row 5 (“mat”) is last, so it sees everything. The allowed region is a lower triangle, and each row’s surviving weights still sum to 1 after softmax.

Step 3: The Transformer Block

Attention is only half of each layer. A full transformer block wraps attention and a feed-forward network together with two features that make deep stacks trainable:

• A feed-forward network (MLP) – a small two-layer network applied to each token independently, usually expanding to ~4× the model width and back. This is where a lot of the model’s “knowledge” is stored.
• Residual connections – each sub-layer adds its output back to its input, giving gradients a clean path through dozens of layers.
• Normalization (LayerNorm or the increasingly common RMSNorm), typically applied before each sub-layer (“pre-norm”) for training stability.

import torch.nn as nn

class TransformerBlock(nn.Module):
    def __init__(self, d_model, n_heads):
        super().__init__()
        self.attn  = nn.MultiheadAttention(d_model, n_heads, batch_first=True)
        self.norm1 = nn.LayerNorm(d_model)
        self.norm2 = nn.LayerNorm(d_model)
        self.mlp   = nn.Sequential(
            nn.Linear(d_model, 4 * d_model),
            nn.GELU(),
            nn.Linear(4 * d_model, d_model),
        )

    def forward(self, x, causal_mask):
        # Pre-norm attention + residual
        h = self.norm1(x)
        attn_out, _ = self.attn(h, h, h, attn_mask=causal_mask)
        x = x + attn_out
        # Pre-norm feed-forward + residual
        h = self.norm2(x)
        x = x + self.mlp(h)
        return x

A real model just stacks this block N times 32, 80, sometimes more than 100 layers with the output of one feeding the input of the next. Model size (the “7B” or “70B” you see in names) is roughly the total parameters across all these blocks plus the embeddings.

After the final block, a last linear layer projects each position back to the size of the vocabulary. A softmax turns those numbers into probabilities, and the model has its prediction for the next token.

Step 4: Generation Is a Loop

To generate text, the model predicts a probability distribution for the next token, picks one (greedily, or by sampling with a temperature setting to control randomness), appends it to the input, and runs the whole thing again. This is why LLMs are called autoregressive: each new token is conditioned on everything generated so far.

A key optimization here is the KV cache. Because past tokens don’t change, the model caches their key and value vectors instead of recomputing them every step. This is why the first token of a response can feel slow (processing your whole prompt) while subsequent tokens stream quickly.

Not All Transformers Are the Same

Decoder-only is dominant today, but it’s one of three classic arrangements. Knowing the difference explains why BERT and GPT feel like different tools.

Which Architecture Should You Care About?

For most people building on LLMs today, the answer is decoder-only that’s what “LLM” almost always means now. But if you’re choosing a model type for a specific job, walk through these questions:

• Do you need to generate free-form text (chat, code, drafts)? Decoder-only. This covers the vast majority of modern use cases.
• Do you need to turn text into a fixed vector for search or classification? An encoder-only model (or a dedicated embedding model) is cheaper and often better than asking a generative LLM.
• Is your task a clean input to output transform like translation? Encoder-decoder can shine, though large decoder-only models now handle these tasks well via prompting.

Rule of thumb:

• Generating?  Decoder-only.
• Understanding or retrieving?  Encoder-only / embedding model.
• Faithful sequence-to-sequence transformation?  Encoder-decoder.
• Not sure? Default to a decoder-only model; it’s the most general.

The post LLM Architecture Explained: What’s Actually Inside a Large Language Model appeared first on NoloWiz.

In this article we’ll clear up the confusion, explain what each service actually does, and give you a practical framework for deciding what to use for your own workloads.

The Short Answer

EC2 (Elastic Compute Cloud) gives you virtual servers in the cloud. You get an operating system, CPU, memory, and storage, and you’re responsible for everything you run on it.

ECS (Elastic Container Service) is a container orchestration service. It decides where and how your Docker containers run, restarts them when they crash, and scales them up and down.

The key thing most comparison articles bury: ECS is not an alternative to EC2 ECS runs on top of compute, and one of its two options for that compute is EC2 itself. The real decision isn’t usually “ECS or EC2.” It’s “should I manage my containers directly on EC2 by hand, or let ECS orchestrate them for me?”

What Is EC2?

EC2 is AWS’s Infrastructure-as-a-Service (IaaS) offering. When you launch an EC2 instance, you’re renting a virtual machine. You choose:

• An instance type (how much CPU and RAM – e.g. t3.micro, m5.large)
• An AMI (the base image / operating system, like Amazon Linux or Ubuntu)
• Storage (EBS volumes)
• Networking (VPC, security groups, public/private IPs)

Once it boots, that server is yours to manage. You SSH in, install software, deploy your application, patch the OS, and handle scaling. That flexibility is EC2’s biggest strength and its biggest burden you can run anything, but you also maintain everything.

EC2 is a good fit when you need:

• Full control over the operating system and environment
• Traditional (non-containerized) applications
• Specialized software that expects a full server
• Long-running workloads where you want to fine-tune the machine

What Is ECS?

ECS is a container orchestration platform. If your application is packaged as Docker containers, ECS handles the operational hard parts for you:

• Scheduling – placing containers onto available compute
• Health checks and self-healing – restarting failed containers automatically
• Scaling – running more or fewer copies based on load
• Service discovery and load balancing – integrating with an Application Load Balancer
• Rolling deployments – updating your app without downtime

In ECS you define a task definition (a blueprint describing your container image, CPU/memory, ports, and environment variables), then run it as a task or a long-running service.

Here’s a simplified task definition to make it concrete:

{
  "family": "my-web-app",
  "networkMode": "awsvpc",
  "containerDefinitions": [
    {
      "name": "web",
      "image": "123456789.dkr.ecr.us-east-1.amazonaws.com/my-web-app:latest",
      "cpu": 256,
      "memory": 512,
      "portMappings": [
        { "containerPort": 80, "protocol": "tcp" }
      ]
    }
  ],
  "requiresCompatibilities": ["FARGATE"],
  "cpu": "256",
  "memory": "512"
}

Notice there’s nothing in there about which server this runs on. That’s the point of orchestration you describe what you want running, and ECS figures out where.

The Part That Confuses Everyone: ECS Launch Types

ECS still needs actual compute to run your containers on. It offers two ways to provide it, and this is where EC2 re-enters the picture.

1.ECS on EC2 (the EC2 launch type)

You run a cluster of EC2 instances that you own and manage, and ECS packs your containers onto them. You’re still responsible for the instances patching, scaling the cluster, right-sizing but ECS handles the container-level orchestration on top.

Choose this when you want lower cost at scale, need specific instance types (GPUs, high memory), or want fine-grained control over the underlying hosts.

2.ECS on Fargate (the Fargate launch type)

Fargate is serverless compute for containers. There are no EC2 instances for you to see or manage you just specify how much CPU and memory each task needs, and AWS provisions the compute invisibly. You pay only for the resources your tasks use while they run.

Choose this when you want zero server management, variable or bursty workloads, and the simplest possible operations, and you’re willing to pay a bit more per unit of compute for that convenience.

So Which One Should You Use?

Instead of picking “ECS vs EC2” as rivals, walk through these questions:

Is your application containerized (Docker)? If no, and you don’t plan to containerize it, plain EC2 is your natural home. Run it like a traditional server.

If yes, you almost certainly want an orchestrator, which means ECS (or EKS if you specifically need Kubernetes).

If you’re using ECS, how much do you want to manage the servers?

• Want AWS to handle the compute entirely and value simplicity – ECS on Fargate
• Want lower cost at scale or need special instance types, and are comfortable managing a cluster – ECS on EC2

A quick rule of thumb:

• Single traditional app, or you need OS-level control – EC2
• Containers, and you want the least operational work – ECS + Fargate
• Containers at large scale where cost matters – ECS + EC2

A Note on Pricing

Pricing is where the trade-offs become tangible, and AWS pricing changes over time, so always confirm current rates in the AWS pricing calculator. In general terms:

• EC2 – you pay for the instance whether it’s busy or idle. Reserved Instances and Savings Plans cut costs significantly for steady workloads.
• ECS itself – there’s no extra charge for the ECS control plane. You only pay for the underlying compute.
• ECS on EC2 – you pay standard EC2 prices, so you can hit lower per-unit costs at scale but you pay for idle capacity.
• ECS on Fargate – you pay per vCPU and GB of memory that your tasks consume, billed by the second. Simpler and often cheaper for spiky or low-utilization workloads, but usually pricier per unit for constant, high-utilization ones.

Frequently Asked Questions

Is ECS a replacement for EC2? No. ECS orchestrates containers and can even run on EC2. They solve different problems and frequently work together.

Can I run containers on EC2 without ECS? Yes, you can install Docker on an EC2 instance and run containers manually. But you’d be hand-building the scheduling, health checks, and scaling that ECS gives you for free.

What about EKS? EKS is AWS’s managed Kubernetes service. It’s an alternative to ECS for orchestration (not to EC2), and it also runs on EC2 or Fargate. Choose EKS if you specifically want Kubernetes; choose ECS for a simpler, more AWS-native experience.

What’s the difference between Fargate and EC2 for ECS? Both provide the compute ECS runs on. With EC2 you manage the servers; with Fargate you don’t manage any servers at all.

Conclusion

“ECS vs EC2” is really a comparison between a building block (EC2, raw virtual servers) and a management layer (ECS, container orchestration) and ECS often sits directly on top of EC2. If you’re running traditional applications and want full control, EC2 is your foundation. If you’re running Docker containers and want automated scheduling, scaling, and healing, ECS is the tool, and your next choice is simply whether to back it with EC2 (more control, cheaper at scale) or Fargate (zero server management). Get that mental model right and the “versus” mostly disappears you’ll know exactly which piece you need, and when to combine them.

The post ECS vs EC2: What’s the Difference and Which One Should You Use? appeared first on NoloWiz.

China’s Moonshot AI Releases Kimi K3

The biggest story of the week. Beijing-based Moonshot AI (backed by Alibaba and Tencent) launched Kimi K3, a 2.8-trillion-parameter multimodal model with a 1-million-token context window and native vision. It’s positioned as the world’s largest open-weight model, with full weights scheduled for release on July 27.

• Benchmarks: Ranked #1 on Arena.ai’s Frontend Code Arena, beating Claude Fable 5 and GPT-5.6 Sol. Second overall behind Fable 5 Max on real-world task benchmarks (Artificial Analysis). State-of-the-art on
  BrowseComp (91.2/100).
• Architecture: Uses Kimi Delta Attention (hybrid linear attention) and Attention Residuals. 16 of 896 experts active per token.
• Pricing: $0.30/M input tokens (cached), $3/M uncached, $15/M output significantly cheaper than U.S. rivals.
• Agentic demo: Designed a functional 4 mm² chip in 48 hours of autonomous operation using open-source EDA tools.

OpenAI Launches GPT-Red

OpenAI has unveiled GPT-Red, an automated AI red-teaming model designed to stress-test its own systems before public release. Specializing in prompt injection attacks where malicious instructions trick AI models into exposing data or performing unauthorized actions GPT-Red uses self-play reinforcement learning to continuously discover new vulnerabilities and harden production models like GPT-5.6 Sol. The initiative arrives amid rising concerns over the security of frontier AI systems, with the Trump administration recently introducing a voluntary quarantine policy for model evaluations. While OpenAI and competitors like Anthropic are increasingly automating safety testing to build trust, industry experts warn that enterprises shouldn’t rely solely on vendor red-teaming and should still conduct their own due diligence to ensure AI tools align with their specific security and business workflows.

Thinking Machines Lab Releases Inkling

Thinking Machines released Inkling, a 975-billion-parameter Mixture-of-Experts model (41B active parameters) with a 1M-token context window, native multimodal support (text, image, audio), and controllable thinking effort for balancing cost vs. performance.

• Available for fine-tuning on the Tinker platform.
• A smaller variant, Inkling-Small (12B active), also previewed.
• Trained on NVIDIA GB300 NVL72 systems with 30M+ RL rollouts

xAI Launches Grok 4.5 into Private Beta

Elon Musk announced that xAI has officially advanced its frontier capabilities by pushing Grok 4.5 into private beta testing within SpaceX and Tesla ecosystems. Built on a massive 1.5-trillion-parameter foundation architecture, this new iteration is three times larger than the model handling production traffic on the X platform, and represents a 50% jump in scale from Grok 4.4, which rolled out only a month prior. Early internal benchmarks indicate that the model is rapidly closing the performance gap with the industry’s topmost frontier models.

Qwen3.8 is Coming: 2.4T Parameters

Alibaba has announced the upcoming open-weight launch of Qwen3.8, a massive 2.4-trillion-parameter AI model. Positioned as one of the most powerful models currently available second only to Fable 5 it is designed to compete with leading frontier AI models. While the full open-weight release is coming soon, users can immediately test the model via the Qwen3.8-Max-Preview, which has just debuted on Alibaba’s Token Plan, Qoder, and QoderWork platforms.

UN Deploys AI to Accelerate Global Methane Mitigation

The UN Environment Programme (UNEP) published a groundbreaking report detailing how artificial intelligence is being successfully leveraged to combat climate change. Utilizing the AI-driven Methane Alert and Response System (MARS), the UN has successfully processed vast feeds from over 30 satellites, enabling analysts to identify major industrial gas leaks 12 to 15 times faster than humanly possible. Crucially, the UN highlighted that the AI models were designed to be lightweight and energy-efficient, proving that advanced machine learning can drive environmental action without imposing a massive carbon footprint of its own.

The post Top AI News of the Week (July 12-July 19, 2026) appeared first on NoloWiz.