AI News Archive: August 22, 2026 — Part 3
Sourced from 500+ daily AI sources, scored by relevance.
- Beyond The Honeymoon Period: Ambient AI And The Next Frontier
Ambient scribing technology can significantly improve operational efficiency and physician workloads.
Score: 20🌐 MovesAug 22, 2026https://www.forbes.com/sites/saibala/2026/08/22/beyond-the-honeymoon-period-ambient-ai-and-the-next-frontier/ - Prompt Injection and Agent Security: The Unsolved Problem
Your agent can’t tell your instructions from an attacker’s. Continue reading on Towards AI »
- e2e-assure Sets Out a Maturity Test for AI SOCs and Argues Most of the Market Is Stuck at Stage One
e2e-assure Sets Out a Maturity Test for AI SOCs and Argues Most of the Market Is Stuck at Stage One USA Today
- The Developer’s Guide to NeMo Guardrails for Enterprise AI Safety
The Developer’s Guide to NeMo Guardrails for Enterprise AI Safety MarkTechPost
Score: 19🌐 MovesAug 22, 2026https://www.marktechpost.com/2026/08/22/the-developers-guide-to-nemo-guardrails-for-enterprise-ai-safety/ - Tech Bros Can't Agree on Why Everyone Hates Data Centers
Tech Bros Can't Agree on Why Everyone Hates Data Centers Business Insider
Score: 19🌐 MovesAug 22, 2026https://www.businessinsider.com/why-everyone-hates-data-center-ai-industry-debate-2026-8 - VCs Are Building Digital Brains To Compound Edge, Here Is How
Andrej Karpathy's LLM wiki pattern turned the digital brain into a VC category. Here is who is funding AI memory, how firms like Bain Capital use it, and how to build one in an afternoon.
- From Voicebots to Voice Agents: Why Enterprise Voice AI Is Moving from Conversations to Actions
By Alok Anibha For years, voice technology in customer service has mostly been about automating conversation. Traditional IVR systems walked customers through predefined menus, and early voicebots recognised a limited set of questions and answered with scripted responses. They let enterprises handle higher volumes of interactions but their role largely stopped at the conversation itself. […] The post From Voicebots to Voice Agents: Why Enterprise Voice AI Is Moving from Conversations to Actions appeared first on CXOToday.com .
- Decoding AI’s Open-Source Course Maps Three Ways to Run an Agent Loop and the Provider Economics Behind Each
Decoding AI’s Open-Source Course Maps Three Ways to Run an Agent Loop and the Provider Economics Behind Each MarkTechPost
- This Is Probably Not the AI-Generated Version of “The Odyssey” That Elon Musk Was Imagining
Or in all likelihood, that *anyone* was imagining. The post This Is Probably Not the AI-Generated Version of “The Odyssey” That Elon Musk Was Imagining appeared first on Futurism .
- The Complete Guide to Reading a Model’s Hidden Layers with Anthropic’s Jacobian Lens
Reading a Model’s Hidden Layers with Anthropic’s Jacobian Lens When a language model answers a question, most of the computation happens in the middle of the network( the hidden layers) , long before you see the answer. And knowing exactly what happens in those hidden layers is one of the harder problems in mechanistic interpretability, largely because the standard techniques like the logit lens fail due to a basis mismatch. So, in July 2026, Anthropic published Verbalizable Representations Form a Global Workspace in Language Models , arguing that a small, low-dimensional slice of those hidden layers— what they call J-space — behaves like a global workspace. This global workspace means the concepts or “thoughts” a model is leaning toward saying, even if it never actually says them out loud. For example: In the paper, researchers gave the model an email-based blackmail scenario as a test. Before the model wrote a single word of its reply, this hidden space already contained words like “blackmail” and “fake” — meaning the model had silently recognized the setup and was already weighing that response, even though its final written reply never mentioned either idea. When the researchers then suppressed that hidden space and reran the same scenario, the model’s behaviour actually changed: it became more likely to attempt the blackmail it had previously only “considered” internally. That’s the causal evidence — not just correlation — that this hidden space is doing real work in the model’s decision. That’s a genuinely new kind of interpretability result, and it hinges on a new tool: the Jacobian lens (J-lens) , which corrects for the basis mismatch that causes the older logit lens to produce garbage in early layers. This article stays narrower than the paper. We’ll load a small open model, apply both the logit lens and the Jacobian lens to identical activations, watch where the correct answer to a simple factual question first becomes legible, and fit a lens of our own — all runnable on a free Colab T4. In this article, we’ll look into the hidden layers of a Qwen model using the Jacobian lens . We’ll compare it directly against the older logit lens on identical activations, plot where the correct answer emerges, and fit a lens from scratch. Note: The entire setup runs on a free Colab T4, so you can follow along without paying for compute. The Theoretical Framework To understand the Jacobian Lens, we must first examine the limitations of the baseline Logit Lens . The Logit Lens The logit lens is the original approach to this problem. It takes a hidden state from some intermediate layer and pushes it straight through the model’s output matrix, as if the layer you’re probing were the last one. Logit lens formula The logit lens relies on a strong assumption: that downstream layers won’t significantly change the representation. Early in the network, this assumption fails. Because in a 30-layer model, layer 5 is still 25 layers away from the output space and hasn’t been rotated into the expected vocabulary basis. Forcing this unrefined state through the unembedding matrix produces garbled output such as punctuation marks, unrelated foreign characters, or strings of underscores. The Jacobian Lens The Jacobian lens replaces that identity assumption with a learned correction. For each layer, it fits a matrix that approximates what the remaining layers actually do, then applies that matrix before unembedding. Jacobian Lens Because the correction is fit by averaging real gradients across many prompts, it captures what a given activation is generally disposed to push the model toward, rather than what happened in one specific context. jlens jlens is the companion library released with the paper. It handles fitting lenses, applying them to prompts, and visualising the results. It also ships the interactive slice-stack viewer used in the paper's figures. Note: It isn’t published to PyPI, so it installs from GitHub at the time of this writing. How the Jacobian Lens Works Let h_l be the hidden state at layer l (a d-dimensional vector), and W_U be the unembedding matrix (mapping d hidden dimensions to vocabulary size V). The logit lens decodes h_l by applying W_U directly: P_logit = softmax( W_U · LayerNorm(h_l) ) The Jacobian lens fits a projection matrix J_l (dimension d × d), defined as the expected gradient of the final hidden state h_L with respect to the probed layer state h_l: J_l ≈ E[ ∂h_L / ∂h_l ] The hidden state is transported through J_l before unembedding: P_jacobian = softmax( W_U · LayerNorm(J_l · h_l) ) That single matrix multiplication is the entire architectural difference between the two methods. The diagram below shows the three paths out of the same hidden state: the model’s real forward pass, the logit lens shortcut, and the Jacobian lens shortcut. flow diagram of how logit lens and jacobian lens works Probing a Model with the Jacobian Lens Prerequisites Before starting, make sure your environment has the following: A GPU. A single NVIDIA T4 with 16GB VRAM is enough. On Colab, set this with Runtime → Change runtime type → T4 GPU before installing anything, or you'll need a runtime restart and a second model download. Python 3.9+ A Hugging Face account , with an access token from huggingface.co/settings/tokens. Required Python libraries: torch, transformers, pandas, accelerate, matplotlib, and jlens. You can find the Colab notebook here A Note on Model Selection I used Qwen/Qwen3.5-4B in this tutorial, which is about 8GB in bfloat16 and ungated. Larger models cause two problems on a T4. meta-llama/Meta-Llama-3-8B is gated, so loading it without an accepted license and a token raises OSError: You are trying to access a gated repo. It is also roughly 16GB in bf16, which is the full capacity of a T4, so it raises an out-of-memory error while moving weights to the GPU even after authentication is sorted out. If you want to use a larger or gated model, you’ll need a bigger GPU, 4-bit quantization, or both. 1. Setting up your Environment Install the required packages. jlens installs from its GitHub repository since it isn't on PyPI. !pip install -q torch transformers pandas accelerate matplotlib !pip install -q git+https://github.com/anthropics/jacobian-lens#egg=jlens Next, log in to Hugging Face . This is required for gated models and avoids download rate limits on ungated ones. from huggingface_hub import login login() 2. Loading the Model Load the base model and wrap it for jlens. The library works through its own wrapper rather than the raw Hugging Face model object. import torch import pandas as pd from transformers import AutoModelForCausalLM, AutoTokenizer import jlens model_id = "Qwen/Qwen3.5-4B" tokenizer = AutoTokenizer.from_pretrained(model_id) hf_model = AutoModelForCausalLM.from_pretrained( model_id, dtype=torch.bfloat16, ).cuda() model = jlens.from_hf(hf_model, tokenizer) Note that the keyword is dtype, not torch_dtype. jlens pins a version of transformers that renamed this argument, and the older name will throw. 3. Loading a Pre-Fitted Lens A fitted lens is one matrix per layer, stored as a .pt file. Pre-fitted lenses for several models are hosted on the Hub, so there's no need to fit your own to get started. lens = jlens.JacobianLens.from_pretrained( "neuronpedia/jacobian-lens", filename="qwen3.5-4b/jlens/Salesforce-wikitext/Qwen3.5-4B_jacobian_lens_n1000.pt", revision="qwen-n1000", ) Two things to keep in mind here. A lens is bound to the exact model it was fit on. Changing model_id in the previous step without changing this filename produces either a shape error or plausible-looking nonsense. There is no universal transport matrix, since J_l describes one specific network's internals. This particular lens was also fit on layers 0 through 30 rather than the model’s full depth. Check lens.source_layers before probing to avoid a ValueError. 4. Probing Intermediate Layers The function below reads the final token position at every layer the lens supports, running the same activations through both lenses. prompt = "The capital of the country where the Eiffel Tower is located is" def probe_trajectory(model, lens, prompt, tokenizer): # Restrict probing to layers the loaded lens actually covers layers = sorted(set(range(1, model.n_layers)) & set(lens.source_layers)) logits_jac, _, _ = lens.apply( model, prompt, layers=layers, positions=[-1], use_jacobian=True ) logits_std, _, _ = lens.apply( model, prompt, layers=layers, positions=[-1], use_jacobian=False ) results = [] for l in layers: top_std = tokenizer.decode([logits_std[l][0].argmax().item()]) top_jac = tokenizer.decode([logits_jac[l][0].argmax().item()]) results.append({"Layer": l, "Logit Lens": top_std, "Jacobian Lens": top_jac}) return pd.DataFrame(results) df = probe_trajectory(model, lens, prompt, tokenizer) print(df.iloc[1:30]) Thepositions=[-1] reads the last token, which is the point just before the model commits to an answer. The use_jacobian flag is the whole comparison: same forward pass, same weights, same activations, with only the transport step changing. 5. Reading the Output Slice output As you can see, the logit lens never recovers. Across all 29 layers shown, it produces no French word, no place name, nothing geography-adjacent, but the Jacobian lens gets it on the 26th layer. This is the failure the Jacobian lens was built to address, and it appears exactly as described. The Jacobian lens is also mostly noise. Its column is full of ... and ____, so this is not a method that makes every intermediate layer legible. At layers 26 and 30, though, it returns “Paris.” Those are the only two cells in the table, in either column, where the correct answer surfaces before the model’s final output. It’s worth being precise about what this supports. A single top-1 hit is not a picture of what the model was thinking at that instant, and most layers here remain unreadable. What the table does support is the comparison: on identical activations, one method surfaced the answer twice, and the other surfaced it zero times. 6. Plotting Token Rank Across Layers Evaluating only Top-1 argmax tokens masks continuous probability shifts in intermediate layers. Tracking the absolute vocabulary rank of a target token on a logarithmic scale provides a clear metric of emerging confidence across network depth. import matplotlib.pyplot as plt def token_rank_trajectory(model, lens, prompt, target_token, tokenizer): layers = sorted(set(range(1, model.n_layers)) & set(lens.source_layers)) target_id = tokenizer.encode(target_token, add_special_tokens=False)[0] logits_jac, _, _ = lens.apply( model, prompt, layers=layers, positions=[-1], use_jacobian=True ) logits_std, _, _ = lens.apply( model, prompt, layers=layers, positions=[-1], use_jacobian=False ) ranks_jac, ranks_std = [], [] for l in layers: ranks_jac.append( (logits_jac[l][0].argsort(descending=True) == target_id).nonzero().item() ) ranks_std.append( (logits_std[l][0].argsort(descending=True) == target_id).nonzero().item() ) return layers, ranks_jac, ranks_std layers, ranks_jac, ranks_std = token_rank_trajectory( model, lens, prompt, target_token=" Paris", tokenizer=tokenizer ) plt.figure(figsize=(9, 5)) plt.plot(layers, ranks_std, marker="o", label="Logit lens", color="tab:gray") plt.plot(layers, ranks_jac, marker="o", label="Jacobian lens", color="tab:blue") plt.yscale("log") plt.gca().invert_yaxis() plt.xlabel("Layer") plt.ylabel('Rank of " Paris" (log scale)') plt.title("Rank of the correct answer across layers") plt.legend() plt.grid(alpha=0.3) plt.show() Note the leading space in " Paris". This tokenizer, like most, encodes a space-prefixed word as a different token from the bare word. If a rank curve looks flat and wrong, check this first. 7. Visualising the Full Prompt Next, we can also visualise representations across the entire prompt sequence and layer stack, because it jlens integrates interactive visualizers and dictionary gloss mappings used in the Jacobian Lens paper. !mkdir -p assets !wget -q https://raw.githubusercontent.com/anthropics/jacobian-lens/main/assets/qwen_gloss.json.gz -P assets/ import urllib.request, gzip, json, os # Download Qwen token gloss lookup table URL = "https://raw.githubusercontent.com/anthropics/jacobian-lens/main/assets/qwen_gloss.json.gz" os.makedirs("assets", exist_ok=True) urllib.request.urlretrieve(URL, "assets/qwen_gloss.json.gz") print(os.path.getsize("assets/qwen_gloss.json.gz")) # expect 655852 gloss = {int(k): v for k, v in json.load(gzip.open("assets/qwen_gloss.json.gz")).items()} print(len(gloss), "glosses") # expect 91695 slice_data = compute_slice(model, lens, prompt, layer_stride=2, mask_display=True) page, _, _ = build_page( slice_data, prompt, title="Eiffel Tower probe", description="Multi-hop factual recall, probed at the final token position.", alt_token=gloss, ) notebook_iframe(page) slice-stack viewer screenshot Setting mask_display=True filters raw output tokens into human-readable subwords, removing noise such as standalone punctuation or formatting tokens. You can click on any cell pin to track its rank across every layer at once. A public copy of this viewer with pre-loaded examples is available at transformer-circuits.pub/2026/workspace/public/slice-stack/ . It is a useful reference for what a strong readout looks like compared to the mixed one above. For longer prompts, switch to mode="fetch", which writes rank data to sidecar files instead of inlining it into the page. Limitations Two constraints are worth carrying forward, particularly given how mixed the Step 5 output looked. It’s a linear approximation of a nonlinear system. J_l is a single matrix standing in for everything downstream — attention routing included — and it can't represent the sharp, discontinuous decisions attention makes. The expectation in E[∂h_final/∂h_l] is taken across many contexts, which means it offers no guarantee for any one particular context. This is plausibly part of why most layers in the table were unreadable. A lens doesn’t transfer. Not across base models, and not across fine-tunes of the same base. Fine-tuning changes internal representations, so J_l has to be recomputed. The fitting procedure in Step 8 is identical regardless of the model, but it costs compute every time. It only captures single-token concepts cleanly, and mid-network depths specifically. Multi-token ideas and very early- or very-late-layer content are harder for this method to surface — the useful readouts concentrate in the middle third to two-thirds of the network’s depth. Conclusion The Jacobian lens doesn’t give you a clean window into a transformer’s intermediate reasoning — on the prompt tested here, most layers stayed unreadable under both methods. But what it does provide is a readout that can surface the correct answer at points where the logit lens structurally cannot, on identical activations. That’s also the mechanism behind the paper’s larger claim: that a specific, low-dimensional subspace of a model’s activations holds the concepts it’s currently poised to verbalise, separate from the much larger volume of automatic processing happening in parallel — and that this subspace can be read, and in some cases edited, before the model ever writes a word. For interpretability and safety work where the alternative is decoding noise, that difference is the point. References Anthropic, Verbalizable Representations Form a Global Workspace in Language Models — Transformer Circuits Thread, July 6, 2026 jlens Reference implementation: github.com/anthropics/jacobian-lens Pre-fitted lenses: huggingface.co/neuronpedia/jacobian-lens Interactive demo: neuronpedia.org/jlens Model used in this guide: huggingface.co/Qwen/Qwen3.5–4B The Complete Guide to Reading a Model’s Hidden Layers with Anthropic’s Jacobian Lens was originally published in Towards AI on Medium, where people are continuing the conversation by highlighting and responding to this story.
- As Hong Kong boosts governance efficiency with AI, balance is key
Hong Kong has never had the luxury of abundant land for development. A small territory supporting a large and highly urbanised population must constantly make difficult choices about housing, transport and infrastructure. This is especially true when every decision carries an environmental cost that is often irreversible. Yet the way forward is not to stand still, but to ensure that development is necessary, properly designed and compatible with the protection of the city’s natural heritage. The...
- Volume Nine Launches Free GEO Grader to Help Brands Prepare for AI Search
Volume Nine Launches Free GEO Grader to Help Brands Prepare for AI Search USA Today
- How to Find the Optimal Coding Agent Interface
The interface that you use to interact with your coding agents is very important. There is a large variety of options out there that you… Continue reading on Towards AI »
- OpenAI's chief economist says researchers on his team need to be 'comfortable with being uncomfortable'
OpenAI's chief economist says researchers on his team need to be 'comfortable with being uncomfortable' Business Insider
Score: 16🌐 MovesAug 22, 2026https://www.businessinsider.com/openai-chief-economist-studying-ai-impact-work-team-2026-8 - How to Benchmark LLMs: Five Mistakes That Skew Your Results
Highlights common pitfalls in LLM benchmarking that can lead to misleading outcomes.
Score: 15🌐 MovesAug 22, 2026https://opentools.ai/news/how-to-benchmark-llms:-five-mistakes-that-skew-your-results - Multi-Document RAG: A Folder of Unrelated PDFs Is One Long Document with a Nested Outline
Enterprise Document Intelligence [Vol.1 #14B] - No shared fields means no index to build. One summary line per file plus each file’s own table of contents, and retrieval routes down two levels The post Multi-Document RAG: A Folder of Unrelated PDFs Is One Long Document with a Nested Outline appeared first on Towards Data Science .
- Robot horse and rider steal the spotlight at Chinese conference
More than 300 companies are showcasing the latest advances in robotics at the five-day event in Beijing, China, organisers say.
Score: 15🌐 MovesAug 22, 2026https://www.bbc.co.uk/news/videos/cy4k4d3lj21o?at_medium=RSS&at_campaign=rss - AI Continues To Bypass Half Of The Workforce
Lack of AI training and disconnected systems elude workers outside the office
Score: 15🌐 MovesAug 22, 2026https://www.forbes.com/sites/joemckendrick/2026/08/22/ai-continues-to-bypass-half-of-the-workforce/ - Protecting Digital Privacy In The Artificial Intelligence Era
The AI era is rapidly advancing, bringing transformative capabilities but also escalating privacy and security threats.
- Google: Beyond The Next Move: Seeing The Whole Board With Agentic AI
Google: Beyond The Next Move: Seeing The Whole Board With Agentic AI Gartner
- Gleb Tsipursky: More Canadian workers are using AI. But business leaders need to learn how to manage it
Gleb Tsipursky: More Canadian workers are using AI. But business leaders need to learn how to manage it Toronto Star
- Why We Fine-Tuned SigLip (And Why That’s Not Always the Right Call)
LoRA fine-tuning solved our under-labeling problem. Whether it makes sense for you depends on three questions. The post Why We Fine-Tuned SigLip (And Why That’s Not Always the Right Call) appeared first on Towards Data Science .
Score: 14🌐 MovesAug 22, 2026https://towardsdatascience.com/why-we-fine-tuned-siglip-and-why-thats-not-always-the-right-call/ - Prosci Launches New AI Integration Program to Help Organizations Turn AI Investment Into Business Results
Prosci Launches New AI Integration Program to Help Organizations Turn AI Investment Into Business Results azcentral.com and The Arizona Republic
- My AI Agent Got Me Banned From Resy. Another Agent Got Me Reinstated.
My AI Agent Got Me Banned From Resy. Another Agent Got Me Reinstated. Business Insider
Score: 14🌐 MovesAug 22, 2026https://www.businessinsider.com/ai-agent-banned-resy-account-reinstated-2026-8 - You can instantly curate your Discover feed now by telling Google exactly what you want
If you're not happy with the algorithm on your Discover page, you'll love this new feature.
Score: 14🌐 MovesAug 22, 2026https://www.zdnet.com/article/how-to-fix-your-google-discover-feed-algorithm/ - I went into testing this portable, AI-powered personal trainer with a skeptical mindset — but came out seriously impressed at its movement mapping technology
This is like having a personal trainer, but an on-demand one that goes with you as needed and is always improving.
- 7 New AI Tools That Run a One-Person Business in 2026 — No Staff, No Code.
7 New AI Tools That Run a One-Person Business in 2026 — No Staff, No Code. entrepreneur.com
- AI’s Three-Body Problem: no single force can dictate the outcome
AI’s Three-Body Problem: no single force can dictate the outcome Fortune
Score: 12🌐 MovesAug 22, 2026https://fortune.com/2026/08/22/ais-three-body-problem-no-single-force-can-dictate-the-outcome/ - What Meta, Zuckerberg, and AI Reveal About the Values We Claim to Have
Winning doesn’t change your principles. It reveals them.
- Workato: The Orchestration Imperative: Execute AI Strategy with a Trusted Action Plane
Workato: The Orchestration Imperative: Execute AI Strategy with a Trusted Action Plane Gartner
- One Formula to Map the Positional Encoding Landscape
Where Sinusoidal Embeddings, RoPE, and ALiBi Actually Live Inside the Attention Equation — and a 2×2 Grid to Keep Them All Straight Every survey of positional encoding I have read presents the methods as a chronological parade: sinusoidal, then learned, then relative, then RoPE, then ALiBi. That framing hides the most useful insight. Almost every technique is just a different answer to one question: where, inside the attention computation, do you inject position? In this article, I summarize the landscape through that lens. First, I revisit where positional encoding sat in the original Transformer paper. Second, I expand the attention formula fully and color-code the three places position information can enter. Third, I collapse the zoo of methods into a single 2×2 grid — absolute vs. relative on one axis, fixed vs. learned on the other — that has served me better than any timeline. Why Position Needs to Be Injected at All Self-attention is a set operation. As the ICLR 2025 blog post on positional embeddings puts it, “On its own, the Transformer architecture is position-invariant, i.e., it processes its input as an unordered set” [2]. Shuffle the tokens of a sentence and, without positional information, every attention score comes out the same. Shirley Li summarizes the fix concisely: “Positional encoding addresses, if not entirely solves, this issue by adding information about the token’s position within the sequence to its representation” [4]. The word addresses is doing real work in that sentence — as we will see, adding to the representation turned out to be only one of at least three options. 1. Where Positional Encoding Sat in the Original Transformer In Attention Is All You Need , positional encoding is almost a footnote to the architecture: a vector p_i added to each token embedding x_i once, at the very bottom of the stack, before the first encoder or decoder layer. The input to the network is simply x_i + p_i. Vaswani et al. chose fixed sinusoidal vectors — sine and cosine waves of geometrically increasing wavelength — and hypothesized that this form “would allow the model to easily learn to attend by relative positions,” since the encoding of position pos + k is a linear function of the encoding of pos [5]. They also tried a learned lookup table instead and, in Li’s words, observed “nearly identical results” [4]. Two properties of this original design matter for everything that came after. Position is injected exactly once, and it then propagates upward entangled with the token’s semantic content. Later research questioned both choices: sinusoidal encodings turned out not to capture relative position effectively in practice [6], and they extrapolate poorly to sequences longer than those seen in training [8]. 2. Three Ways to Inject Position — One Expanded Formula The clearest way I know to compare methods is to stop writing attention as softmax(QKᵀ/√d)V and instead expand it fully for a single pair of tokens: the attention weight a_mn between query token m and key token n, followed by the output z_m. Every positional encoding technique touches exactly one colored region of this formula. The fully expanded attention computation. Each color marks one place where position information can enter. Source: Image by the author. Yellow — additive positional embeddings. Sinusoidal (and learned absolute) encodings modify the yellow term by replacing x_m with x_m + p_m before the projections W_Q, W_K are applied. Position enters before attention and rides along inside the embedding. This is the original Transformer recipe, and also that of BERT and GPT-2. Blue — manipulating the query and key matrices. RoPE injects position during the dot product, by rotating queries and keys according to their positions. Because a rotation by mθ against a rotation by nθ leaves behind only the angle (m − n)θ, the score q_m · k_nᵀ depends on relative position by construction [7]. Nothing is added to the embeddings; the projection outputs themselves are transformed. Arun Prakash arrives at the same idea from the decomposition of the pre-attention matrix: “one can add positional information directly in the attention layer as well!” [3]. Shaw et al.’s earlier relative position embeddings live here too: instead of adding position vectors to the input embeddings, they inject trainable relative-offset embeddings into the keys and values while attention is being computed [2], [6]. Pink — a bias on the attention score before softmax. ALiBi skips embeddings and transformations entirely and adds a scalar penalty b_mn = −slope · |m − n| to the raw score, just before the softmax. Prakash captures its spirit: “The idea is very simple. Just add a bias (hand-crafted) after the query-key product” [3]. The farther apart two tokens are, the more their score is pushed down — a built-in recency bias that is the secret behind ALiBi’s famous length extrapolation [8]. T5’s learned relative bias occupies the same pink slot, but with a trained scalar per distance bucket instead of a hand-crafted slope. What I like about this view is that RoPE and ALiBi, usually presented as rivals, are revealed as siblings: both refuse to touch the yellow term. As the ICLR 2025 blog post argues, the philosophy they share is that positional and semantic information are different things that should not be mixed into one vector — so both methods leave the word embeddings alone and instead modify the attention weights computed at every layer [2]. 3. The 2×2 Grid: Absolute vs. Relative, Fixed vs. Learned The injection point tells you where position enters; two more questions tell you what kind of position it is. Is position measured from the start of the sequence (absolute, as in Vaswani et al. [5]) or between pairs of tokens (relative, as in Shaw et al. [6])? And is the encoding fixed — deterministic, unchanged during training — or learned, a lookup table updated by gradient descent? Irani and Metsis organize their survey of the field along exactly these lines, examining “a variety of methods, including fixed, learnable, relative, and hybrid approaches” [1]. Crossing the two questions gives a grid that fits the whole landscape on a napkin. The positional encoding landscape in one grid. Source: Image by the author. The fixed + absolute corner holds the sinusoidal encoding of the original Transformer. The learned + absolute corner is where BERT and GPT-2 sit, trading extrapolation for task-adapted flexibility; in PyTorch this quadrant is literally one line: import torch.nn as nn # learned absolute positions: one trainable vector per position pos_embedding = nn.Embedding(max_seq_len, d_model) The learned + relative corner belongs to Transformer-XL and T5, which train embeddings or scalar biases for pairwise offsets, following the direction Shaw et al. opened in 2018 [6]. And the fixed + relative corner — RoPE and ALiBi — is where most modern LLMs live: relative by construction, with no positional parameters to train, and with the best length-extrapolation behavior of the four quadrants [2]. Overlaying the grid on the colored formula completes the map. The left column (absolute) mostly operates in yellow; the right column (relative) operates in blue and pink. The trend of the last several years is a steady migration from the top-left corner of the grid toward the right column — out of the embeddings and into the attention computation. Conclusion Positional encoding started as a single additive vector in the 2017 Transformer and grew into a design space of its own. My summary of that space needs only two artifacts: an expanded attention formula with three colored injection points — add to the embeddings (yellow), transform the queries and keys (blue), or bias the score before softmax (pink) — and a 2×2 grid crossing absolute vs. relative with fixed vs. learned. New methods keep appearing, but so far every one I have encountered still lands in one colored region and one quadrant. If you keep those two pictures in mind, the landscape stops being a parade of papers and becomes a small set of design choices. References [1] H. Irani and V. Metsis, “ Positional encoding in transformer-based time series models: A survey ,” arXiv preprint arXiv:2502.12370, 2025. [2] “ Positional embeddings in transformer models: Evolution from text to vision domains ,” ICLR Blogposts Track, 2025. [3] A. Prakash, “ Positional encoding in transformers ,” Arun’s Blog, Feb. 2, 2024. [4] S. Li, “ Understanding positional encoding in transformers and beyond with code ,” Medium, Dec. 25, 2024. [5] A. Vaswani et al., “ Attention is all you need ,” in Advances in Neural Information Processing Systems (NeurIPS), 2017. [6] P. Shaw, J. Uszkoreit, and A. Vaswani, “ Self-attention with relative position representations ,” in Proc. NAACL-HLT, 2018. [7] J. Su, Y. Lu, S. Pan, A. Murtadha, B. Wen, and Y. Liu, “ RoFormer: Enhanced transformer with rotary position embedding ,” arXiv preprint arXiv:2104.09864, 2021. [8] O. Press, N. A. Smith, and M. Lewis, “ Train short, test long: Attention with linear biases enables input length extrapolation ,” in Proc. ICLR, 2022. One Formula to Map the Positional Encoding Landscape was originally published in Towards AI on Medium, where people are continuing the conversation by highlighting and responding to this story.
- Chat Bots Compared Launches to Help Users Discover the Perfect AI Companionship Options
Chat Bots Compared Launches to Help Users Discover the Perfect AI Companionship Options USA Today
- Founders Are Asking a Helpful Machine to Judge Their Ideas. That’s the Problem
Unfortunately, AI is very good at telling you what you want to hear.
Score: 11🌐 MovesAug 22, 2026https://www.inc.com/diana-bocco/founders-ai-prompting-business-ideas-confirmation-bias/91394909 - Unlocking Rotational Dynamics via data-RoPE
A look at the modular hybridization trend redefining sequence models. A physical gyroscopic model illustrating how data-dependent RoPE restores continuous complex rotational dynamics to real-valued state space architectures. Late one evening in early 2024, sitting over a rapidly cooling cup of masala tea, I stared in sheer disbelief at a GPU cluster terminal log. We were running a standard evaluation suite on a state-of-the-art Mamba-2 checkpoint, expecting it to effortlessly navigate simple synthetic formal language checks. Instead, on a fundamental binary parity tracking test — a task rooted in the basic TC⁰ complexity class — the model registered an abysmal 0.9% accuracy (Lahoti et al., 2026). It wasn’t just struggling; it was performing dramatically worse than a random coin flip. In that precise moment, critics of linear-time architectures felt entirely vindicated in declaring sub-quadratic models fundamentally broken for discrete formal logic. 📊 Executive Summary: Mamba-3 introduces data-dependent Rotary Position Embeddings (data-RoPE), second-order Generalized Exponential-Trapezoidal discretization, and Multi-Input Multi-Output (MIMO) rank expansion (R=4) to linear sequence modeling. This architecture solves historical TC⁰ formal reasoning failures — achieving 100% accuracy on binary parity tracking — while eliminating KV cache memory overhead and outperforming Transformer baselines by +2.2 points at the 1.5B scale (Lahoti et al., 2026). Yet, enterprise application teams today face a parallel crisis on the opposite side of the architectural spectrum. As production LLMs transition from brief, single-turn prompts to autonomous, long-horizon agentic workflows, the self-attention mechanism’s quadratic scaling penalty (O(L²)) has hit a physical brick wall (Dao & Gu, 2024). Processing a standard 32,000-token context window on a 7B parameter Transformer demands roughly 33 GB of VRAM, with 17 GB consumed exclusively by the Key-Value (KV) cache (Spheron Network, 2026). Doubling context length quadruples operational compute requirements, forcing multi-million-dollar GPU clusters to sit chronically idle as memory buses choke on massive data transfers (Spheron Network, 2026). Enter Mamba-3, presented at ICLR 2026 as the architectural paradigm shift designed to break this deadlock (Lahoti et al., 2026). By incorporating data-dependent Rotary Position Embeddings (data-RoPE), Generalized Exponential-Trapezoidal Discretization, and Multi-Input Multi-Output (MIMO) rank expansion, Mamba-3 restores continuous rotational dynamics to real-valued hardware (Gu & Dao, 2023; Lahoti et al., 2026; Su et al., 2024). The result is an inference-optimized engine that achieves 100% formal logic accuracy, completely eliminates the memory-bloating KV cache, and outpaces optimized Transformer baselines by +2.2 accuracy points at the 1.5B scale (Lahoti et al., 2026). Welcome to the definitive playbook for mastering the post-attention epoch. I. The Stakes: The 17GB Memory Wall and the TC⁰ Logic Failure To understand why linear models collapsed on synthetic arithmetic, we must first examine the mechanical divergence between Transformers and Structured State Space Models (SSMs). Standard Transformers achieve remarkable context recall by preserving an explicit, raw log of history inside the KV cache (Dao & Gu, 2024). When an enterprise agent generates its 64,000th token, the underlying hardware must fetch every previously cached key and value vector from High Bandwidth Memory (HBM) to compute tensor operations (Spheron Network, 2026). This shuttling process creates a severe “memory wall” where enterprise GPUs like the NVIDIA H100 spend vast compute cycles waiting for memory buses to deliver cached tokens (Spheron Network, 2026). “Memory stores static context; dynamic rotation unlocks active machine reasoning.” — Mohit Sewak, Ph.D. Conversely, state space models compress continuous sequence histories into a fixed-size, continuous latent state (Gu & Dao, 2023; Gu et al., 2022). An SSM consumes the exact same memory footprint whether it is processing token 10 or token 100,000, establishing theoretical infinite-context execution on constrained hardware (Gu & Dao, 2023; Spheron Network, 2026). However, early linear architectures paid a massive reasoning tax for this memory efficiency. When evaluated on formal languages within the TC⁰ computational complexity class, models like Mamba-2 suffered severe structural failures (Dao & Gu, 2024; Lahoti et al., 2026). Aside from its 0.9% parity tracking failure, Mamba-2 collapsed to 47.81% accuracy on modular arithmetic, effectively reducing complex state tracking to random guessing (Lahoti et al., 2026). 🔍 Fact Check: Standard selective state space models like Mamba-2 suffer a severe topological barrier in real-valued dynamics, collapsing to 0.9% accuracy on binary parity tracking and 47.81% on modular arithmetic (Lahoti et al., 2026). TRANSFORMER (Explicit Storage) STATE SPACE MODEL (Continuous Compression) Token 1 ──> [ K1, V1 ] Token 1 ──┐ Token 2 ──> [ K2, V2 ] Token 2 ──┼──> [ Fixed-Size Hidden State Matrix ] ... ... │ (Static VRAM Footprint) Token L ──> [ KL, VL ] (VRAM Grows O(L)) Token L ──┘ A tangible architectural visual contrasting the O(L) memory growth of Transformer KV caches against the O(1) static footprint of state space models. This reasoning limit was not caused by linear-time dynamics, but rather by a fundamental topological constraint inherent to real-valued transitions. In earlier SSMs, the transition matrix (A) operating on the hidden state was restricted strictly to real numbers (ℝ) (Gu & Dao, 2023; Lahoti et al., 2026). Think of a real-valued matrix like a linear dimmer switch on a light: it can scale a vector’s magnitude up or flip its polarity by 180 degrees, but it cannot rotate it smoothly in latent space (Lahoti et al., 2026). To track periodic or cyclic phenomena — such as toggling between odd and even parity states as bits stream past — a network mathematically requires complex-valued eigenvalues (ℂ) to induce smooth, continuous phase angles (Lahoti et al., 2026). Without complex rotational dynamics, real-valued state spaces simply lack the topological dimension needed to represent cyclic logic transitions. II. Core Pillar I: Eliminating Truncation Error via Trapezoidal Discretization and Implicit Convolutions The core mathematical engine of any state space model is its discretization rule — the mathematical bridge translating continuous differential dynamics into discrete token updates (Gu & Dao, 2023; Lahoti et al., 2026). Historically, selective SSMs relied on the “exponential-Euler” method (Dao & Gu, 2024; Lahoti et al., 2026). Euler discretization is a first-order numerical technique that calculates continuous-to-discrete state transitions by anchoring its integration to a single boundary endpoint (Lahoti et al., 2026). While lightweight to compute on tensor cores, Euler approximations introduce a local truncation error of O(Δₜ²) at every single token step (Lahoti et al., 2026). As sequence lengths stretch into thousands of tokens, these numerical errors compound rapidly, yielding a global sequence error bound of O(Δₜ) that progressively degrades the model’s temporal fidelity (Lahoti et al., 2026). 💡 ProTip: When implementing second-order trapezoidal discretization, remove external 1D causal convolution layers completely. The trapezoidal recurrence natively absorbs local context mixing into a data-dependent, 2-wide implicit convolution inside the core loop (Lahoti et al., 2026). To eliminate this compounding degradation, Mamba-3 replaces first-order Euler heuristics with second-order control theory via Generalized Exponential-Trapezoidal Discretization (Lahoti et al., 2026). Instead of estimating the integral over a time step using a crude single-point rectangle, the trapezoidal rule constructs a convex combination utilizing both the current and prior interval boundaries (Lahoti et al., 2026). Parameterized by a data-dependent interpolation scalar, λₜ, the update scheme balances past and present boundary states (Lahoti et al., 2026): hₜ = exp(-Δₜ A) hₜ₋₁ + Δₜ · [λₜ · Bₜ xₜ + (1 — λₜ) · exp(-Δₜ A) Bₜ₋₁ xₜ₋₁] By evaluating both interval endpoints, this second-order formulation slashes the local truncation error down to O(Δₜ³) and tightens the global sequence error bound to O(Δₜ²) (Lahoti et al., 2026). The model effectively gains a high-resolution, second-order view of temporal evolution, retaining sharp state representations over long horizons without numerical drift. EXPONENTIAL-EULER (First-Order) EXPONENTIAL-TRAPEZOIDAL (Second-Order) Single boundary endpoint rectangle Convex combination of past & present State │ ┌──────────┐ State │ ┌──────────/ │ │ │ │ │ / │ │ │ Euler │ │ │ Trap. / │ │ │ Area │ │ │ Area / │ └────┴──────────┴──> Time └────┴──────┴────┴──> Time t-1 t t-1 t Local Error: O(Δt²) Local Error: O(Δt³) A physical macro photographic model comparing first-order Euler approximation errors against second-order Exponential-Trapezoidal continuous discretization. Beyond numerical stability, this discretization shift unlocks a structural simplification of the neural network architecture itself. In prior Mamba generations, engineers had to bolt an external 1D short causal convolution layer (Conv1D) onto the front of the state-space block to force local token mixing prior to recurrence (Gu & Dao, 2023). However, when you mathematically expand the trapezoidal recurrence equation, it naturally decomposes into a decay mask multiplied by a size-two convolutional mask (Lahoti et al., 2026). This algebraic property natively induces a data-dependent, width-2 convolution on the state-input within the core recurrence loop (Lahoti et al., 2026). Because the trapezoidal rule natively absorbs local context mixing, Mamba-3 completely removes the external Conv1D layer from its block design, pairing this streamlined core with QKNorm-style RMSNorm and learnable channel-wise biases directly on the B and C projection matrices (Lahoti et al., 2026). III. Core Pillar II: Constructing Dynamic Latent Compasses via Data-Dependent RoPE While expanding the state space to complex numbers (ℂ) solves the topological constraint on formal reasoning, executing native complex arithmetic directly on modern GPUs is a practical disaster (Lahoti et al., 2026). Native complex operations double VRAM bandwidth consumption, introduce severe instability during backpropagation, require bespoke CUDA kernels, and run entirely counter to low-level Tensor Core matrix acceleration (Lahoti et al., 2026). To capture the power of complex dynamics without paying the hardware penalty, the Mamba-3 research team leveraged a profound mathematical isomorphism: a discretized complex-valued state space is mathematically identical to a real-valued state space that applies block-diagonal 2 × 2 rotation matrices to its dynamics (Lahoti et al., 2026). This breakthrough gives rise to the data-dependent RoPE Trick (Lahoti et al., 2026; Su et al., 2024). Rather than running expensive complex-number operations inside the hidden state recurrence, Mamba-3 applies real-valued 2 × 2 block-diagonal rotation matrices directly to the input (B) and output © projections prior to state interaction (Lahoti et al., 2026): R(θₜ) = [cos(θₜ) -sin(θₜ) ; sin(θₜ) cos(θₜ)] Through the lens of State Space Duality (SSD), the B and C matrices correspond directly to the Key (K) and Query (Q) projections in standard attention (Dao & Gu, 2024; Lahoti et al., 2026). This mechanism structurally mirrors the Rotary Position Embeddings (RoPE) popular in models like Llama (Lahoti et al., 2026; Su et al., 2024). However, standard Transformer RoPE uses a static rotation schedule dictated strictly by an absolute sequence index t (Su et al., 2024). In contrast, Mamba-3 calculates its rotation angles dynamically based on the input token content itself: θₜ = f(xₜ) (Lahoti et al., 2026). 🔍 Fact Check: Data-dependent RoPE converts real-valued state updates into continuous latent rotation matrices, raising Mamba-3’s binary parity tracking accuracy from 0.90% to 100.00% and modular arithmetic accuracy from 47.81% to 98.50% (Lahoti et al., 2026). TRANSFORMER RoPE (Static) MAMBA-3 data-RoPE (Dynamic) Angle = f(Position t) Angle = f(Input Content xₜ) Token 1 (Pos 1) ──> Rotate(1 × θ) "Bit 1" ──> Calculate θ(x₁) ──> Rotate State Token 2 (Pos 2) ──> Rotate(2 × θ) "Bit 0" ──> Calculate θ(x₂) ──> Rotate State Token 3 (Pos 3) ──> Rotate(3 × θ) "Bit 1" ──> Calculate θ(x₃) ──> Rotate State (Fixed clock tick) (Dynamic compass tracking content) A physical mechanical compass installation demonstrating how data-dependent RoPE computes rotational angles directly from token content. By computing rotations dynamically from token content, data-RoPE functions like a dynamic latent compass (Lahoti et al., 2026). When processing a sequence of formal logic or arithmetic, the model dynamically shifts phase angles to navigate state transitions in latent space (Lahoti et al., 2026). The empirical results on formal logic benchmarks speak for themselves: Model Architecture Task Variant Parity Tracking Accuracy Modular Arithmetic Accuracy Mamba-2 Real-Valued (ℝ) 0.90% 47.81% Mamba-3 Fixed-Frequency RoPE 1.56% 51.20% Mamba-3 Data-Dependent RoPE 100.00% 98.50% Table 1: Formal language tracking evaluation showing the leap in accuracy unlocked by data-dependent RoPE (Lahoti et al., 2026). As demonstrated, fixed-frequency rotations completely fail to handle state transitions because static clock ticks cannot adapt to non-stationary data changes (Lahoti et al., 2026; Su et al., 2024). By tying the rotation directly to the input token content, data-RoPE enables real-valued hardware to process complex rotational logic with zero latency overhead (Lahoti et al., 2026). IV. Core Pillar III: Decoupling Memory from Compute through Rank Expansion (MIMO) Even with solved logic dynamics, single-input single-output (SISO) linear models encounter a major hardware bottleneck during autoregressive decoding: severe memory-boundedness (Gu & Dao, 2023; Lahoti et al., 2026). In a standard SISO state space layer, updating the hidden state requires calculating an outer product between an N-dimensional state vector (B) and a P-dimensional input vector (x) (Lahoti et al., 2026). This outer product requires O(N × P) floating-point operations (FLOPs), but it simultaneously requires fetching O(N × P) bytes from VRAM memory (Lahoti et al., 2026). A 1:1 ratio of compute-to-memory byte transfers is disastrous for GPU efficiency; high-performance Tensor Cores sit completely idle while waiting for VRAM memory buses to stream data (Lahoti et al., 2026; Spheron Network, 2026). 💡 ProTip: Set your MIMO rank expansion parameter to R=4 during sequence model initialization. This quadruples Tensor Core floating-point operations while maintaining a fixed hidden state size in VRAM, turning memory-bound decoding into high-throughput compute (Lahoti et al., 2026). To break out of this memory-bound bottleneck, Mamba-3 introduces a Multi-Input, Multi-Output (MIMO) rank expansion formulation (Lahoti et al., 2026). Instead of projecting the input sequence to a flat vector xₜ ∈ ℝᵖ, MIMO projects the input to a rank-expanded matrix Xₜ ∈ ℝ^{P×R} (Lahoti et al., 2026). Concurrently, the projection vector B is expanded into an N × R matrix (Lahoti et al., 2026). A tactile photographic visual detailing how MIMO rank expansion (R=4) quadruples compute operations while keeping VRAM state memory transfers fixed. SISO FORMULATION (Memory-Bound) MIMO FORMULATION (Compute-Bound, R=4) Vector Outer Product Dense Matrix-Matrix Multiplication B Vector (N×1) ⊗ x Vector (1×P) B Matrix (N×R) × X Matrix (R×P) Compute: O(N × P) FLOPs Compute: O(R × N × P) FLOPs [4x FLOPS!] Memory: O(N × P) Bytes Memory: O(N × P) Bytes [1x VRAM!] Ratio: 1 FLOP / Byte (Idle GPU) Ratio: 4 FLOPs / Byte (Saturated GPU) By substituting the vector outer product with a dense matrix-matrix multiplication, setting the rank parameter to R=4 quadruples the floating-point operations (4× FLOPs) performed per step (Lahoti et al., 2026). Crucially, the underlying hidden state matrix stored in VRAM remains strictly fixed at N × P (Lahoti et al., 2026). Memory traffic across the bus stays flat, while arithmetic intensity quadruples — pushing execution out of memory-bound stalls and into compute-bound GPU saturation (Lahoti et al., 2026; Spheron Network, 2026). To maintain parameter parity with SISO baselines, MLP inner dimensions are slightly trimmed (Lahoti et al., 2026). 🔍 Fact Check: Mamba-3 MIMO (R=4) trained on 100 billion FineWeb-Edu tokens achieves a +2.2 percentage point downstream accuracy advantage over dense Transformer baselines while matching Mamba-2 perplexity at half the latent state size (d_state = 64 vs 128) (Lahoti et al., 2026). This hardware-aware mathematical shift drives significant performance improvements across downstream tasks. Evaluated at the 1.5B scale on 100 billion FineWeb-Edu tokens, Mamba-3 MIMO achieves clear margins over alternative architectures (Lahoti et al., 2026; Yang et al., 2025): 1.5B Downstream Accuracy Gain vs. Standard Baselines (100B FineWeb-Edu) ───────────────────────────────────────────────────────────────────────────── GDN Baseline │ Reference (0.0) Mamba-3 SISO │ █▌ +0.6 pts Mamba-3 MIMO (R=4) │ █████▋ +1.8 pts vs GDN Mamba-3 MIMO vs Mamba2│ ██████ +1.9 pts vs Mamba-2 Mamba-3 MIMO vs Trans │ ███████ +2.2 pts vs Transformer Baseline Furthermore, state size ablation studies demonstrate dramatic Pareto efficiency gains. A Mamba-3 MIMO model with a state dimension of d_state = 64 matches the validation perplexity of a Mamba-2 baseline operating at d_state = 128 (Lahoti et al., 2026). By doubling computational intensity without altering state memory footprint, Mamba-3 cuts the required latent state memory footprint in half for any given quality target (Lahoti et al., 2026). V. Core Pillar IV: Production Infrastructure, 1.58-Bit Quantization, and Architectural Disambiguation Deploying Mamba-3 at enterprise scale fundamentally alters infrastructure economic planning (Spheron Network, 2026). Consider a standard 7B parameter deployment running a 32,000-token context window (Spheron Network, 2026). A traditional Transformer architecture demands 33 GB of VRAM (16 GB for model weights plus 17 GB for the expanding KV cache) (Spheron Network, 2026). Scaling that same Transformer context to 128,000 tokens causes KV cache memory overhead to explode, requiring costly multi-node GPU tensor parallelism just to fit sequence memory (Spheron Network, 2026). An architectural studio visual comparing enterprise GPU VRAM footprints across Transformer, Mamba-3, and 1.58-bit edge quantized models. 💡 ProTip: Optimize enterprise infrastructure ROI by deploying pure SSM models on NVIDIA H100 SXM5 GPUs instead of high-bandwidth-memory H200s. Mamba-3’s static state memory footprint eliminates KV cache transfers, shifting performance gains entirely to raw tensor compute (Spheron Network, 2026). Mamba-3, by contrast, operates on a completely static memory footprint (Lahoti et al., 2026; Spheron Network, 2026). The same 7B model requires a fixed 19 GB of total VRAM (16 GB for weights plus 3 GB for the recurrent state) — and that footprint remains anchored at 19 GB whether processing token 100 or token 128,000 (Spheron Network, 2026). VRAM Consumption at 32K Context (7B Parameter Model) ┌─────────────────────────────────────────────────────────────┐ │ Transformer: 33 GB Total [16 GB Weights + 17 GB KV Cache] │ ├─────────────────────────────────────────────────────────────┤ │ Mamba-3: 19 GB Total [16 GB Weights + 3 GB Fixed State] │ └─────────────────────────────────────────────────────────────┘ This structural shift transforms hardware procurement strategies. Because Mamba-3 eliminates the memory bandwidth wall created by KV cache transfers, enterprises no longer need to pay steep market premiums for memory-bandwidth-centric GPUs like the NVIDIA H200 (4.8 TB/s bandwidth) (Spheron Network, 2026). Instead, deployments achieve optimal cost-efficiency on standard NVIDIA H100 SXM5 units, maximizing raw tensor compute performance (1.98 PFLOPS BF16) where Mamba-3’s high arithmetic intensity thrives (Spheron Network, 2026). The open-source production stack natively supports this infrastructure efficiency. The official release includes custom TileLang kernels for high-speed MIMO prefill and low-level CuTe DSL fused kernels for decoding, establishing Mamba-3 as the fastest decoding primitive in the sub-quadratic class (Lahoti et al., 2026). For localized agents and edge devices, Quantization-Aware Training (QAT) via knowledge distillation compresses Mamba-3 models down to ternary 1.58-bit precision, shrinking a 1.3B model to 744 MB in under 4 GPU-hours without catastrophic perplexity loss (Lahoti et al., 2026). 🔍 Fact Check: Quantization-Aware Training with knowledge distillation compresses 1.3B Mamba models to 1.58-bit ternary precision in under 4 GPU-hours, reducing disk and memory footprint from 2.6 GB to 744 MB without severe perplexity loss (Lahoti et al., 2026). PRODUCTION RUNTIME STACK ┌─────────────────────────────────────────────────────────────────┐ │ High-Level Serving Frameworks (vLLM / SGLang / TensorRT-LLM) │ ├─────────────────────────────────────────────────────────────────┤ │ Custom Prefill Kernels (TileLang) | Decode Kernels (CuTe DSL) │ ├─────────────────────────────────────────────────────────────────┤ │ Deterministic Edge Runtimes (mamba-rs NVRTC CUDA Kernels) │ └─────────────────────────────────────────────────────────────────┘ When evaluating architectures, engineers must avoid two common industry confusions regarding model naming and long-context capabilities: A physical milestone roadmap visualization outlining the three-step transition strategy for enterprise post-attention inference systems. Architectural Disambiguation (Mamba-3 vs. MiniMax M3): Do not confuse the Mamba-3 state-space model primitive with MiniMax M3, a ~428B Mixture-of-Experts (MoE) model released by MiniMax (MiniMax AI, 2026). MiniMax M3 does not use recurrent state space models; instead, it uses MiniMax Sparse Attention (MSA) tailored for multimodal desktop application automation (MiniMax AI, 2026). Mamba-3 is an open-source, sub-quadratic sequence primitive designed to replace dense Transformer blocks (Lahoti et al., 2026). Context Limits and Hybrid Convergence: On the rigorous RULER benchmark, which tests multi-hop factual extraction across extreme context lengths, pure SSMs encounter an information bottleneck past 32K tokens due to continuous state compression (Hsieh et al., 2024). Consequently, top-tier enterprise systems deploy hybrid topologies. Architectures like NVIDIA Nemotron 3 Ultra (550B MoE) and AI21 Jamba interleave Mamba layers with sparse Grouped Query Attention (GQA) at a ~7:1 ratio, utilizing SSM layers for bulk sequence processing while retaining GQA for exact long-context factual recall (Dao & Gu, 2024; NVIDIA Corporation, 2026). VI. Strategic Synthesis: Execution Roadmap for Next-Gen Inference Systems The shift toward inference-time scaling and long-horizon agentic execution marks a clear turning point in enterprise AI design (Lahoti et al., 2026; Spheron Network, 2026). The era of blindly scaling dense Transformer self-attention for every sequence modeling task has come to a close (Dao & Gu, 2024). By integrating second-order discretization, content-driven complex phase angles via data-RoPE, and hardware-optimized MIMO rank expansion, Mamba-3 proves that linear-time sequence models can overcome historical reasoning limits while delivering superior throughput (Lahoti et al., 2026). “We must stop scaling raw memory to solve structural logic deficits.” — Mohit Sewak, Ph.D. To modernize your organization’s deployment infrastructure for post-attention execution, follow this three-step implementation playbook: ENTERPRISE EXECUTION ROADMAP [ Step 1: Audit ] ──> Identify agentic workflows throttled by KV cache memory bus limits. │ [ Step 2: Evaluate ] ──> Benchmark Mamba-3 primitives (`state-spaces` HF) using CuTe DSL. │ [ Step 3: Deploy ] ──> Adopt pure Mamba-3 for high-throughput state tracking, or GQA-SSM hybrids (e.g., 7:1 ratio) for long-context retrieval. Audit Enterprise Inference Bottlenecks: Analyze your current agentic workloads to isolate tasks where KV cache memory footprint restricts batch sizes, increases latency, or caps GPU utilization during long-turn generation (Spheron Network, 2026). Evaluate Open-Source Mamba-3 Primitives: Benchmark the official Mamba-3 checkpoints available on the state-spaces Hugging Face repository using integrated TileLang prefill and CuTe DSL decode kernels to establish latency and memory savings (Lahoti et al., 2026). Deploy Hybrid Topologies for Mixed Workloads: Use pure Mamba-3 layers for latency-critical state-tracking and autonomous tool-use workflows. For large-scale enterprise applications requiring exact multi-hop factual retrieval across 100K+ token contexts, deploy hybrid architectures like Nemotron 3 Ultra that fuse Mamba layers with periodic GQA blocks (NVIDIA Corporation, 2026; Spheron Network, 2026). By adopting these rotational dynamics, engineering teams can build high-throughput, low-latency inference systems that scale effortlessly through the post-attention epoch. References & Further Reading Block 1: Foundations of State Space Models and Dualities Dao, T., & Gu, A. (2024). Transformers are SSMs: Generalized models and efficient algorithms through structured state space duality. Proceedings of the 41st International Conference on Machine Learning (ICML 2024) , PMLR 235 , 10041–10071. https://doi.org/10.48550/arXiv.2405.21060 Gu, A., & Dao, T. (2023). Mamba: Linear-time sequence modeling with selective state spaces (arXiv:2312.00752). arXiv. https://doi.org/10.48550/arXiv.2312.00752 Gu, A., Goel, K., & Ré, C. (2022). Efficiently modeling long sequences with structured state spaces. Proceedings of the International Conference on Learning Representations (ICLR 2022) . https://doi.org/10.48550/arXiv.2111.00396 Block 2: Methodological Advances in Sub-Quadratic Architectures Lahoti, A., Li, K. Y., Chen, B., Wang, C., Bick, A., Kolter, J. Z., Dao, T., & Gu, A. (2026). Mamba-3: Improved sequence modeling using state space principles. Proceedings of the International Conference on Learning Representations (ICLR 2026) . https://doi.org/10.48550/arXiv.2603.15569 Su, J., Ahmed, M., Lu, Y., Pan, S., Bo, W., & Liu, Y. (2024). RoFormer: Enhanced transformer with rotary position embedding. Neurocomputing , 568 , Article 127063. https://doi.org/10.1016/j.neucom.2023.127063 Yang, S., Wang, B., Shen, Y., Panda, R., & Kim, Y. (2025). Gated delta networks: Improving Mamba2 with delta rule. Proceedings of the International Conference on Learning Representations (ICLR 2025) . https://doi.org/10.48550/arXiv.2412.06464 Block 3: Benchmarking, Hybridization, and Infrastructure Economics Hsieh, C.-P., Sun, S., Kriman, S., Acharya, S., Rekesh, D., Jia, F., Zhang, Y., & Ginsburg, B. (2024). RULER: What’s the real context size of your long-context language models? Proceedings of the First Conference on Language Modeling (COLM 2024) . https://doi.org/10.48550/arXiv.2404.06654 MiniMax AI. (2026). MiniMax-M3: Advancing long-context multimodality and autonomous software engineering with sparse attention (Technical Report). MiniMax AI Research. https://www.minimax.io NVIDIA Corporation. (2026). Nemotron-3 Ultra 550B: High-throughput hybrid state-space and attention architectures for enterprise inference (NVIDIA Technical Whitepaper). NVIDIA AI Enterprise. https://www.nvidia.com Spheron Network. (2026). The memory wall in LLM inference: Hardware economics of state space models vs. dense transformers (Enterprise Deployment Whitepaper). Spheron AI Infrastructure Research. https://spheron.network Disclaimer: The views and opinions expressed in this article are personal and do not necessarily reflect the official policy or position of any associated agencies, organizations, or the India AI Mission. AI assistance was utilized in the research, drafting, and ideation of this article. Licensed under CC BY-ND 4.0. Unlocking Rotational Dynamics via data-RoPE was originally published in Towards AI on Medium, where people are continuing the conversation by highlighting and responding to this story.
- Building a Proper Backend for My LangGraph AI Agent
Turning a demo agent into something that can keep real booking data The post Building a Proper Backend for My LangGraph AI Agent appeared first on Towards Data Science .
Score: 11🌐 MovesAug 22, 2026https://towardsdatascience.com/building-a-proper-backend-for-my-langgraph-ai-agent/ - AI Can Give People the Answer. Technical Leaders Need to Help Them Decide What to Do
The new technical superpower? Making complexity actionable.
- The Anomaly Detector That Learns by Counting
10,000 Bayesian models, no training loop: how conjugate priors caught red-team activity in a billion-event authentication log Bayesian statistics gives you a principled way to combine prior knowledge with observed data. The catch is computational: updating beliefs usually means numerical integration, MCMC sampling, or an optimization loop you have to babysit. There is a family of cases where none of that is necessary. Choose the prior from the right mathematical family — a conjugate prior — and the belief update collapses to arithmetic. No gradients, no convergence checks, no retraining. This article works through the theory and then puts it to a real test: anomaly detection on the Los Alamos National Laboratory (LANL) cybersecurity dataset, which contains over one billion authentication events (1.6 billion events across all its sources). We train on a 29.4-million-event subset and build 10,413 independent per-computer models — each one updated by incrementing two integers. The Foundation: Bayesian Inference Every Bayesian analysis has three components. The prior P(θ) captures what you believe about the parameters before seeing data. The likelihood P(data | θ) says how probable the observed data is under given parameter values. The posterior P(θ | data) is your updated belief after observing the data. Bayes’ theorem connects them: P(θ | data) = P(data | θ) · P(θ) / P(data) The denominator is where the trouble starts. The marginal likelihood P(data) = ∫ P(data | θ′) · P(θ′) dθ′ rarely has a closed-form solution, which is why practitioners reach for MCMC sampling, variational approximation, or numerical integration. All three work, and all three bring approximation error, convergence monitoring, and computational overhead. What Conjugacy Buys You A prior P(θ) is conjugate to a likelihood P(data | θ) if the posterior P(θ | data) belongs to the same distributional family as the prior. When that holds, the intractable integral never has to be computed — Bayes’ theorem reduces to a parameter update you can write on one line. The Dirichlet–Categorical Conjugate Pair For categorical data — authentication types, user identities, event classes — the natural conjugate pair is Dirichlet–Categorical. Likelihood (Categorical): P(xᵢ = k | θ) = θₖ, where θ = (θ₁, …, θ_K) and θ₁ + … + θ_K = 1. Prior (Dirichlet): up to a normalizing constant, Dir(α) ∝ θ₁^(α₁−1) · θ₂^(α₂−1) · … · θ_K^(α_K−1) Posterior: also Dirichlet. If the data contains n₁ observations of category 1, n₂ of category 2, and so on: θ | data ~ Dir(α₁ + n₁, α₂ + n₂, …, α_K + n_K) Add the observed counts to the prior parameters. That is the entire update. It translates directly into code — two increments per event: def update(self, observations): for obs in observations: self.counts[obs] += 1 # n_k += 1 for the observed category self.total += 1 # N += 1 -- total event count No matrix operations, no learning rate, no batch size. Each authentication event increments two integers. Posterior predictive. For a new observation, the probability of category k is P(next = k | data) = (α + nₖ) / (K·α + N) where K is the number of categories, N is the total number of observations, and α is the symmetric prior pseudo-count used throughout this article. Understanding the Prior Parameter α The parameter α controls how strongly you believe categories are equally likely before seeing any data. With α = 1 (a uniform prior), every category starts with one pseudo-observation and no category is favored. A larger α, say 10, takes more data to pull beliefs away from uniform — useful when you expect balance. An α below 1 encodes sparsity: most categories should be rare. The choice matters most for categories the model has never seen. For a computer with N = 1,000 events across 4 auth types, the probability assigned to an unseen type is P(unseen) = α / ((K+1)·α + N): alpha P(unseen) Score Effect 0.1 9.99 x 10-5 9.21 Very sensitive to novelty 1.0 9.95 x 10-4 6.91 Balanced 10.0 9.52 x 10-3 4.65 Conservative, harder to flag With large training data (N = 29.4M at the global level), different α values produce nearly identical scores — the prior washes out. At the per-computer level (N = 100–10,000 events), α meaningfully controls sensitivity. That is why α = 1 is a sensible default: it regularizes the small per-computer models without distorting the global picture. Case Study: Enterprise Authentication Anomaly Detection The Dataset The LANL Comprehensive Multi-Source Cyber-Security Events dataset [6] records 58 days of activity from Los Alamos National Laboratory’s internal network: 1.6 billion events in total across its sources, of which the authentication log (auth.txt) contains just over one billion events covering 12,425 users and 17,684 computers. A red team exercise ran during the collection window, and its 749 attack events are documented in a separate ground-truth file. All user and computer identifiers are anonymized by the lab. The dataset is released by LANL for public use under a CC0 license (approved for public release, LA-UR-15–23810), which permits commercial use. Each authentication event contains: timestamp, source_user, dest_user, source_computer, dest_computer, auth_type, logon_type, auth_orientation, success_status The Modeling Approach We model two categorical distributions per computer, each with its own Dirichlet–Categorical model. Model 1 covers the authentication type : which protocols (Kerberos, NTLM, …) does this machine normally see? Model 2 covers the source user : which users normally authenticate to this machine? These two features carry complementary signals. Machines specialize: domain controllers speak almost pure Kerberos, legacy servers lean on NTLM, workstations show mixed local-system authentications. And machines have social circles: a personal workstation is dominated by its owner, a server by its administrator group. An attacker moving laterally tends to violate both patterns at once — an unusual protocol from an unusual user. We use α = 1 for all models: no domain bias, and no zero probabilities for categories a computer has never seen. Implementation and Evaluation Strategy Temporal split. The model trains only on data before the first red team attack and is evaluated during and after the attack period. Never training on future data is what makes the evaluation resemble real deployment. Labels. Exact timestamp matching located only 3 of the 749 red team events in the authentication log — most attacks touched machines outside it. We therefore label any access to a compromised computer during the attack window as suspicious, which yields 1,247 suspicious-window events, enough signal for a reliable evaluation. Scoring. Each test event receives auth_score = −log P(auth_type | computer history) user_score = −log P(source_user | computer history) combined_score = (auth_score + user_score) / 2 Higher score means more surprising, means more anomalous. The scoring function maps directly to code; note how the K → K+1 adjustment for unseen categories (explained in the worked example below) appears as a single conditional: def anomaly_score(self, category): n_k = self.counts.get(category, 0) # 0 if never seen K = len(self.counts) if category not in self.counts: K += 1 # unseen: K -> K+1 alpha_0 = K * self.alpha_prior + self.total # denominator prob = (self.alpha_prior + n_k) / alpha_0 return -np.log(prob) The full implementation, including per-computer models and a global fallback, is in the companion notebook on GitHub. A Worked Example: Scoring One Authentication Event Before looking at results at scale, let’s trace exactly what the algorithm computes for a single event. The setting is real: destination computer C457 and source computer C663 appear in authentication records discussed by Heard and Rubin-Delanchy [5], whose study of this same network identified C17693 as one of four confirmed red-team source machines (ranked 5th most anomalous out of 16,230). The training counts below are illustrative — round numbers chosen so the arithmetic is easy to follow — but the record structure, the machines, and the scoring formula are exactly those used in the full experiment. Notation for this section: α is the symmetric prior pseudo-count (= 1 throughout), nₖ is the training count of category k, K is the number of distinct categories seen in training, N is the total training count, and the posterior predictive probability of category k is [4]: P(k | data) = (α + nₖ) / (K·α + N) What the model knows about C457 (illustrative: 5,000 training events, K = 3 auth types, K = 3 users, so the denominator is 3×1 + 5,000 = 5,003): Auth Type n_k P(k|C457) Score = -log P Kerberos 4,100 0.820 0.20 ? (Unknown) 750 0.150 1.90 NTLM 150 0.030 3.50 Source User n_k P(u|C457) Score = -log P U31@DOM1 3,000 0.600 0.51 U45@DOM1 1,250 0.250 1.39 U58@DOM1 750 0.150 1.90 Scenario 1 — Normal Event This record structure appears in the LANL authentication log [5]: timestamp=3, source_user=U31@DOM1, source_computer=C663, dest_computer=C457, auth_type=Kerberos U31@DOM1 is C457’s dominant user; Kerberos is its dominant protocol. The figure traces each value from the training table (left) into its slot in the formula (right), with colors matched in the legend. Annotated walkthrough showing how the normal event’s training counts flow into the posterior predictive formula, producing a combined score of 0.35. Source: Image by the author. Combined score 0.35 — well within normal range. Scenario 2 — Suspicious Event (Confirmed Red-Team Machine C17693) source_user=U842@DOM1 (never seen on C457), source_computer=C17693, dest_computer=C457, auth_type=NTLM NTLM is known but rare on C457 (nₖ = 150). The user is the interesting part: U842@DOM1 never appeared on C457 during training, which triggers the K → K+1 rule. The denominator grows by one α unit to give the new category its share of prior mass, so the probability is small but never zero. Annotated walkthrough of the suspicious event showing the unseen-user adjustment and a combined score of 6.01 Source: Image by the author. Combined score 6.01–17× higher than the normal event. The same arithmetic runs across all 10,413 computer models simultaneously. Results What the Algorithm Learned The global authentication distribution over 29.4M training events (6 normalized auth types): Bar chart of the global authentication type distribution across 29.4 million training events . Source: Image by the author. Auth Type Events % Total Score (global) ? (Unknown system auth) 17,004,222 57.8% 0.55 Kerberos 10,367,997 35.2% 1.04 NTLM 1,431,374 4.9% 3.02 Negotiate 604,153 2.1% 3.89 MSAUTHPKG ~16,239 0.1% 7.82 Wave 6 0.0% 15.25 The “?” category represents local system authentications where the protocol type was not logged — a common artifact in enterprise Windows environments. The model learns this is the norm and scores it accordingly. Each machine also develops its own authentication fingerprint: Chart showing per-computer authentication type profiles for five representative machines . Source: Image by the author. C586 (3.6M events): 49.9% Unknown system auth -> high-traffic domain resource C625 (1.97M events): 56.2% Unknown system auth -> active infrastructure node C988 (269K events): 48.0% Unknown system auth -> mid-tier server C1020 (156 events): 74.4% Unknown system auth -> isolated/edge system C1069 (149 events): 74.5% Unknown system auth -> isolated/edge system Deviations from these per-computer norms are what drive anomaly scores up. Performance ROC curve for the Dirichlet-Categorical anomaly detector showing AUC of 0.826 . Source: Image by the author The detector reached an AUC-ROC of 0.826 on the temporal test split, training on 29.4 million events and building 10,413 computer models in a single pass, with 1,247 suspicious-window events identified for evaluation. Overlapping histograms of anomaly scores for attack versus normal events, showing clear separation with means of 4.24 and 2.12 . Source: Image by the author. The score separation is clear: attack events average 4.24 versus 2.12 for normal events. The Effect of α, Confirmed on Real Data Two-panel chart showing anomaly scores converging across alpha values as observations accumulate, and unseen-category scores as training data grows . Source: Image by the author The left panel shows anomaly scores falling as a category is observed more often — the model learning the normal pattern. All α values converge as observations accumulate. The right panel tracks the score of a completely unseen auth type as training data grows: at LANL scale (N = 29.4M) every α choice produces nearly identical results. The prior only matters when data is sparse — which is exactly when you need it, in the small per-computer models for edge systems. When to Use This Approach Reach for Dirichlet–Categorical conjugate priors when your problem has categorical inputs (authentication types, user identities, protocol classes), streaming updates with no retraining budget, many per-entity models to maintain at once, sparse data with unseen categories, and a hard interpretability requirement — every score here has a direct meaning, such as “this event type appeared 3 times in 5,000 observations.” Look elsewhere when you have high-dimensional continuous features (Gaussian processes, kernel methods, neural networks), complex non-linear temporal dependencies (LSTMs, Transformers), or abundant labelled data where supervised models can learn richer representations. Implementation Details The companion notebook contains the full DirichletCategorical class, the EnterpriseAuthDetector orchestrator, data loading, and every plot shown here. It runs on standard Colab hardware in about 15 minutes. You can find the code in the GitHub repository and the dataset on the LANL cybersecurity data page . Conclusion Conjugate priors turn a hard computational problem into bookkeeping. Because the Dirichlet posterior has the same form as the prior, 29.4 million training events reduce to counting, 10,413 per-computer behavioral models come essentially for free, and every anomaly score can be traced by hand — as the C457 walkthrough showed. The resulting detector reached an AUC-ROC of 0.826 on highly imbalanced data with a single hyperparameter left at its default. This is not a replacement for gradient-based models, neural networks, or ensembles — those remain the right tools for many problems. The point is narrower and, I think, more useful: when the problem structure matches the model assumptions — categorical data, streaming updates, a need for interpretability — the conjugate prior approach is analytically exact, transparent, and fast enough to be boring. Seeing why each quantity in the formula is what it is, on a concrete operational problem, is the kind of understanding that transfers well beyond this particular use case. References [1] A. Gelman, J. Carlin, H. Stern, D. Dunson, A. Vehtari and D. Rubin, Bayesian Data Analysis, 3rd Edition (2013), Chapman & Hall/CRC [2] K. Murphy, Machine Learning: A Probabilistic Perspective (2012), MIT Press [3] C. Bishop, Pattern Recognition and Machine Learning (2006), Springer [4] S. Tu, The Dirichlet-Multinomial and Dirichlet-Categorical Models for Bayesian Inference (2019), technical writeup [5] N. Heard and P. Rubin-Delanchy, Network-wide anomaly detection via the Dirichlet process (2016), IEEE Conference on Intelligence and Security Informatics (ISI) [6] A. D. Kent, Comprehensive, Multi-Source Cyber-Security Events (2015), Los Alamos National Laboratory — released for public use under a CC0 license (LA-UR-15–23810) All results produced on the unmodified LANL dataset; illustrative values in the worked example are labeled as such. All images by the author. The Anomaly Detector That Learns by Counting was originally published in Towards AI on Medium, where people are continuing the conversation by highlighting and responding to this story.
- This $42 AI Tool Helps Busy Entrepreneurs Finally Write That Book
This $42 AI Tool Helps Busy Entrepreneurs Finally Write That Book entrepreneur.com
Score: 09🌐 MovesAug 22, 2026https://www.entrepreneur.com/leadership/this-42-ai-tool-helps-busy-entrepreneurs-finally-write/505233 - Before you go back to school, set up these 5 ChatGPT tools — your future self will thank you
These five practical ChatGPT tricks can help students organize a semester, understand difficult subjects and study more effectively.
Score: 09🌐 MovesAug 22, 2026https://www.techradar.com/ai-platforms-assistants/chatgpt/5-ways-chatgpt-can-help-when-you-go-back-to-school - 🧠 Community Wisdom: Favorite Lenny’s Product Pass tools, how AI is reshaping hiring, what to prioritize when you join a new company, and more
Community Wisdom 198
- Slack - Qualcomm AI Hub
Slack - Qualcomm AI Hub Qualcomm AI Hub
- D2C Insider concludes AI summit Frontier to explore AI’s role in consumer businesses
D2C Insider concluded Frontier, a D2C AI Summit, in Gurugram, bringing together more than 150 D2C founders and CXOs, over 25 AI leaders and representatives from more than 100 brands to discuss how artificial intelligence is reshaping consumer businesses. The event focused on the impact of AI across discovery, customer conversations, conversion, retention, operations and unit economics, rather than treating AI as a standalone technology. The agenda examined how AI could influence consumer brands’ business models and P&Ls as companies move from experimenting with individual AI tools to integrating the technology across their operations. The summit featured four AI bootcamps, four operator-led panel discussions, a fireside chat, networking sessions and an AI Experience Zone. The event opened with a workshop by Pradeep Sekhar, India CEO of Base.com, on deploying AI agents to monitor real-time omnichannel profitability. This was followed by a panel discussion titled “The AI-Native Consumer: How AI Is Rewriting Discovery, Conversation & Conversion”. The panel featured Ojasvi Bhatia, Lead AI Partnerships, India at Meta; Apurva Mudgal from Product at WhatsApp; Ayushi Gudwani; Vaibhav Makhija; Aditya Singhal; and Sahil Jindal, Managing Director of the Jindal Group. The pre-lunch session focused on the technology infrastructure supporting AI adoption. The afternoon opened with a fireside chat hosted by Abhishek Shah, featuring Gaurav Mangla, CEO of fastrr by Shiprocket, and Nitin Agarwal. This was followed by a workshop on autonomous AI. Commenting on the objective behind the summit, Abhishek Shah, Chief Evangelist at D2C Insider, said that while many founders have experimented with AI tools, relatively few have integrated AI into their core business operations. The summit also featured an AI Experience Zone, speed networking sessions and curated founder introductions based on participants’ business stage, category and growth ambitions. Drawing from D2C Insider’s community of more than 30,000 D2C founders and operators, Frontier provided a platform for entrepreneurs and ecosystem players to discuss AI adoption and explore potential collaborations.
- Give Your Prompts More Perspective with ChatGPT, Gemini and More in a Single $60 Workspace
Give Your Prompts More Perspective with ChatGPT, Gemini and More in a Single $60 Workspace entrepreneur.com
- I asked ChatGPT if I should get Botox — its answer made me understand why ChatGPT for teens needs to exist
I tested ChatGPT with questions about dieting, relationships and AI companions, and quickly saw why age changes everything.
- AI
AI Barron's
- Magicfit
AI Creative Studio for Ecommerce
- Habit Tracker
Build better habits track your progress, and stay consistent
- MyClippings
Image Collection, Save Screenshots & Ideas
- X-Pilot AI
Turn Documents into Accurate Video Course Series
- Kaevo
The AI chief of staff for your household