This is an automated email from the ASF dual-hosted git repository.

github-actions[bot] pushed a commit to branch asf-site
in repository https://gitbox.apache.org/repos/asf/tvm-site.git


The following commit(s) were added to refs/heads/asf-site by this push:
     new 93c0249756f Build at Wed Nov  4 18:30:56 UTC 2026
93c0249756f is described below

commit 93c0249756f02637c25a1753e9c26220c270a1bd
Author: tvm-bot <[email protected]>
AuthorDate: Wed Nov 4 18:30:57 2026 +0000

    Build at Wed Nov  4 18:30:56 UTC 2026
---
 ...ml-compiler-foundation-for-the-agentic-era.html | 465 +--------------------
 ...ethinking-abstractions-in-the-agentic-era.html} |   4 +-
 _static/downloads/acm%3Adesktopcta                 |   6 +-
 atom.xml                                           |   8 +-
 feed.xml                                           |   2 +-
 posts.html                                         |   2 +-
 rss.xml                                            |  10 +-
 sitemap.txt                                        |   3 +-
 8 files changed, 25 insertions(+), 475 deletions(-)

diff --git a/2026/11/03/rethink-ml-compiler-foundation-for-the-agentic-era.html 
b/2026/11/03/rethink-ml-compiler-foundation-for-the-agentic-era.html
index 59957f4b61c..d6b6d71709a 100644
--- a/2026/11/03/rethink-ml-compiler-foundation-for-the-agentic-era.html
+++ b/2026/11/03/rethink-ml-compiler-foundation-for-the-agentic-era.html
@@ -1,464 +1,13 @@
+<!DOCTYPE html>
 <html lang="en">
 <head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Rethinking the ML Compiler Foundation for the Agentic Era</title>
-    <link rel="shortcut icon" href="/assets/images/favicon.ico">
-    <link rel="stylesheet" href="../../../_static/downloads/bootstrap.min.css" 
integrity="sha384-MCw98/SFnGE8fJT3GXwEOngsV7Zt27NXFoaoApmYm81iuXoPkFOJwJ8ERdknLPMO"
 crossorigin="anonymous">
-    <link rel="stylesheet" href="/css/slick.css">
-    <link rel="stylesheet" href="/css/slick-theme.css">
-    <link rel="stylesheet" href="/css/custom.css">
-    
-    
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <meta http-equiv="refresh" content="0; 
url=/2026/11/03/rethinking-abstractions-in-the-agentic-era.html">
+  <link rel="canonical" 
href="https://tvm.apache.org/2026/11/03/rethinking-abstractions-in-the-agentic-era";>
+  <title>Article moved</title>
 </head>
 <body>
-
-    
-<div class="bannerPage">
-      <header class="header">
-      <div class="container">
-        <div class="headerInner d-flex justify-content-between 
align-items-center">
-          <div class="headerLogo">
-            <a href="/"><img src="/assets/images/logo.svg" alt="Logo"></a>
-          </div>
-          <div id="headMenu" class="headerNav">
-            <button type="button" id="closeHeadMenu" class="navCloseBtn"><img 
src="/assets/images/close-icon.svg"
-                alt="Close"></button>
-                <ul class="nav">
-    
-    <li class="nav-item">
-        <a class="nav-link" href="/community">Community</a>
-    </li>
-    
-    <li class="nav-item">
-        <a class="nav-link" href="/download">Download</a>
-    </li>
-    
-    <li class="nav-item">
-        <a class="nav-link" href="https://tvm.apache.org/docs/";>Docs</a>
-    </li>
-    
-    <li class="nav-item">
-        <a class="nav-link" href="/posts">Posts</a>
-    </li>
-    
-    <li class="nav-item">
-        <a class="nav-link" href="https://github.com/apache/tvm-ffi/";>TVM 
FFI</a>
-    </li>
-    
-    <li class="nav-item">
-        <a class="nav-link" href="https://github.com/apache/tvm/";>Github</a>
-    </li>
-    
-</ul>
-            <div class="responsiveasfdropdown">
-              <button type="button" class="btn-link">
-                ASF
-              </button>
-              <ul>
-    
-    <li>
-        <a href="https://www.apache.org/";>Apache Homepage</a>
-    </li>
-    
-    <li>
-        <a href="https://www.apache.org/licenses/";>License</a>
-    </li>
-    
-    <li>
-        <a 
href="https://www.apache.org/foundation/sponsorship.html";>Sponsorship</a>
-    </li>
-    
-    <li>
-        <a 
href="https://tvm.apache.org/docs/reference/security.html";>Security</a>
-    </li>
-    
-    <li>
-        <a href="https://www.apache.org/foundation/thanks.html";>Thanks</a>
-    </li>
-    
-    <li>
-        <a href="https://www.apache.org/events/current-event";>Events</a>
-    </li>
-    
-</ul>
-            </div>
-          </div>
-          <div class="responsiveMenuIcon">
-            <button type="button" id="menuBtn" class="btn-menu"><img 
src="/assets/images/menu-icon.svg"
-                alt="Menu Icon" /></button>
-          </div>
-          <div class="asfDropdown">
-            <div class="dropdown">
-              <button type="button" class="btn-link dropdown-toggle" 
data-toggle="dropdown" aria-haspopup="true"
-                aria-expanded="false">
-                ASF
-              </button>
-              <div class="dropdown-menu dropdown-menu-right">
-                <ul>
-    
-    <li>
-        <a href="https://www.apache.org/";>Apache Homepage</a>
-    </li>
-    
-    <li>
-        <a href="https://www.apache.org/licenses/";>License</a>
-    </li>
-    
-    <li>
-        <a 
href="https://www.apache.org/foundation/sponsorship.html";>Sponsorship</a>
-    </li>
-    
-    <li>
-        <a 
href="https://tvm.apache.org/docs/reference/security.html";>Security</a>
-    </li>
-    
-    <li>
-        <a href="https://www.apache.org/foundation/thanks.html";>Thanks</a>
-    </li>
-    
-    <li>
-        <a href="https://www.apache.org/events/current-event";>Events</a>
-    </li>
-    
-</ul>
-              </div>
-            </div>
-          </div>
-        </div>
-      </div>
-    </header>
-
-</div>
-
-
-<div class="container post-page">
-<div class="content">
-  <div class="row">
-    <div class="span14 w-100">
-      <header class="post-header">
-      <h1>Rethinking the ML Compiler Foundation for the Agentic Era </h1>
-      <p class="post-meta">
-        <time datetime="2026-11-03T00:00:00+00:00" itemprop="datePublished">
-          Nov 3, 2026
-        </time>
-        
-        • <span itemprop="author" itemscope 
itemtype="http://schema.org/Person";>
-          <span itemprop="name">Apache TVM Community</span>
-        </span>
-        
-      </p>
-      
-      </header>
-    <div class="post-content">
-      <section class="post-summary" aria-labelledby="tldr">
-
-  <h2 id="tldr">TL;DR</h2>
-
-  <p>In our <a 
href="https://blog.mlc.ai/2026/09/29/tirx-harness-an-open-compiler-harness-for-agentic-gpu-programming";>previous
 community effort</a>, we showed that with little more than Opus 5.5 and a few 
presses of Enter, we could produce production-quality B200 kernels that 
significantly outperform existing baselines.</p>
-
-  <p>This led us, as ML compiler practitioners, to revisit a fundamental 
question from first principles: <strong>Do we still need our beloved 
compilers?</strong></p>
-
-  <p>Our answer is <strong>yes, but perhaps not in the form we know 
today.</strong> Through concrete case studies and first-principles reasoning, 
we explore why agents still need compiler abstractions and how these 
abstractions should be designed for them.</p>
-
-  <p>We’re putting these ideas into practice through a ground-up rebuild of <a 
href="https://github.com/apache/tvm-tirx/tree/main";>TIRx</a>, with the goal of 
making it a shared DSL and compiler foundation for agentic kernel 
development.</p>
-
-</section>
-
-<p>For those of us working on ML compilers and GPU kernels, 2026 has been both 
an exciting and an unsettling year.</p>
-
-<p><img src="/images/rethink-ml-compiler-foundation/image7.png" 
alt="Opportunities and challenges for ML compiler practitioners in 2026" 
style="width: 90%; margin: auto; display: block;" /></p>
-
-<p>On the one hand, much of the tedious maintenance work that once consumed 
our time can now be delegated to agents. Agents are even tackling the 
development of high-performance GPU kernels, one of the ultimate goals of our 
compiler research, with remarkable success. Perhaps we can finally free 
ourselves from the endless cycle of reading Nsight Compute reports, inspecting 
SASS assembly, and hand-tuning the most delicate details of GPU kernels. Recent 
efforts such as <a href="https://pyto [...]
-
-<p>On the other hand, this progress raises an uncomfortable question: 
<strong>Are we automating ourselves out of relevance?</strong> In the essay <a 
href="https://mp.weixin.qq.com/s/zk0KxuLzhmMJ4LPYW_OHMA";><em>I Have No Choice 
but to Bury My Talent in Yesterday</em></a>, DeepSeek engineer Shengyu Liu 
reflects on the possibility of agents surpassing human experts in kernel 
development. Meanwhile, Stanford’s <a 
href="https://hazyresearch.stanford.edu/blog/2026-08-05-retire-the-abstractions 
[...]
-
-<p>This is a particularly uncomfortable thought for those of us who have spent 
years building DSLs, compiler heuristics, optimization passes, and entire 
compilation frameworks. Much of this machinery was designed around the needs 
and limitations of human programmers.</p>
-
-<p>After all, we humans have limited attention and working memory. We cannot 
easily keep every detail of GPU hardware in our heads, nor can we manually 
explore thousands of possible optimization strategies. We need high-level 
abstractions to make low-level programming manageable and compilers to automate 
the tedious, repetitive, and error-prone parts of optimization.</p>
-
-<p><strong>But what happens when the programmer is no longer 
human?</strong></p>
-
-<p>Agents can work directly with low-level CUDA or PTX, inspect profiling 
results in seconds, experiment with unconventional optimization strategies, and 
explore dozens or even hundreds of kernel variants within an hour. They are not 
constrained by human cognitive limitations in the same way. Why should we 
expect them to use the same languages, abstractions, and workflows we designed 
for ourselves?</p>
-
-<p>This brings us to a more fundamental question:</p>
-
-<p><strong>If agents can handle the low-level details themselves, should we 
still put a compiler between them and the hardware?</strong></p>
-
-<p>We believe the answer is <strong>yes, but for a different reason.</strong> 
Instead of requiring agents to reinvent IR and compiler infrastructure at every 
iteration of kernel development, a minimal, stable ML compiler foundation can 
provide shared abstractions and reusable tools for the entire community while 
leaving agents free to explore their own optimization strategies.</p>
-
-<p><img src="/images/rethink-ml-compiler-foundation/image2.png" alt="From an 
opaque compiler to agentic kernel programming, compiler harnesses, and a 
minimal compiler foundation" style="width: 90%; margin: auto; display: block;" 
/></p>
-
-<p>In this post, we explain why such a foundation is still needed and how it 
should be designed for agents. These ideas guided our redesign of TIRx around 
the following core elements:</p>
-
-<ul>
-  <li><strong>A minimal, stable set of core AST nodes</strong> designed for 
common needs and extensions.</li>
-  <li><strong>Stable, predictable utilities</strong> for common needs, 
including TVM-FFI bridge generation, symbolic integer analysis, structural 
traversal and mapping, and basic code generation for CUDA and host LLVM 
targets.</li>
-  <li><strong>Dynamic extension by design:</strong> Types and operations can 
be easily added without rebuilding a static bundle. Customizations can be 
developed in independent repositories and loaded dynamically to interoperate 
with the foundation layer.</li>
-  <li><strong>First-class cross-language support:</strong> Python, C++, and 
Rust (work in progress). Agents can implement compiler analyses and extensions 
in any of these languages, quickly prototyping ideas in a dynamic language like 
Python and then implementing them in Rust or C++. Extensions work out of the 
box across supported languages.</li>
-  <li><strong>Connections to stable compiler toolchains:</strong> The 
foundation provides a minimal layer for ML compilation while using the backend 
capabilities of established toolchains where possible.</li>
-</ul>
-
-<p>This post walks through the design reasoning behind our approach to 
rethinking the ML compiler foundation for the agentic era. We hope these 
principles and ideas will be broadly applicable to the ML compiler and agentic 
development communities.</p>
-
-<h2 id="do-we-still-need-compilers-at-all">Do We Still Need Compilers at 
All?</h2>
-
-<p>The first question we should ask ourselves is whether we really need 
compilers at all.</p>
-
-<p>Many of the abstractions we designed for DSLs help human programmers manage 
low-level details. If agents can work directly with CUDA, PTX, or assembly, 
they may no longer need the same human-oriented programming interfaces.</p>
-
-<p>Agents are also already very good at the heuristic optimizations 
traditionally performed by compilers and can work directly with low-level 
code.</p>
-
-<p><img src="/images/rethink-ml-compiler-foundation/image6.png" alt="Agents 
still need structured IR and AST representations for analysis and verification" 
style="width: 90%; margin: auto; display: block;" /></p>
-
-<p><strong>But does eliminating a DSL interface or compiler-driven code 
generation eliminate the need for compiler infrastructure?</strong></p>
-
-<p>Imagine a future where an agent writes CUDA kernels directly, relies on 
existing toolchains to generate PTX and SASS, and iterates through profiling 
and testing. It might even generate PTX or native machine instructions 
directly, without going through a traditional ML compiler at all.</p>
-
-<p>Now suppose we want to verify that a generated kernel is correct. We cannot 
simply trust the agent’s judgment or rely on tests alone. We still need a 
formal representation of the program and its semantics, such as an IR 
formalized in Lean, against which correctness proofs can be checked.</p>
-
-<p>Moreover, we wouldn’t want agents to spend hundreds of iterations on 
programs with obvious bugs. Ideally, we should catch errors as early as 
possible, using efficient checkers to analyze program patterns, memory 
accesses, synchronization, and other properties without relying on expensive 
model reasoning or full formal verification for every candidate (see the <a 
href="https://github.com/mlc-ai/TIRx-harness/tree/main/tools";>checkers</a> we 
built).</p>
-
-<p>This thought experiment reveals two important needs that remain even when 
agents take over code generation:</p>
-
-<ul>
-  <li><strong>Analysis:</strong> While agents can reason directly over program 
text, not every analysis needs to be performed through model reasoning. Just as 
humans can perform arithmetic by hand but benefit from calculators, agents can 
benefit from structured program representations and efficient analysis 
algorithms to catch problems early in development.</li>
-  <li><strong>Verification:</strong> Program correctness should not depend on 
trusting an agent’s judgment. Independent verification requires precisely 
defined program semantics against which correctness claims can be checked.</li>
-</ul>
-
-<p>These two needs motivate a common foundation: a minimal, extensible IR that 
exposes program structure and semantics to both agents and conventional tools, 
independently of any particular code generation or optimization strategy.</p>
-
-<p>In this future, <strong>we may no longer need a compiler that actually 
compiles anything, but we will still need compiler infrastructure to understand 
and verify programs.</strong> A shared IR can serve as the foundation for 
analysis, verification, and new tools built by agents.</p>
-
-<p>Our insight is that we need a <strong>minimal, stable set of core IR/AST 
nodes</strong> designed for common needs and extensions. Whether agents 
generate CUDA/PTX or eventually native machine instructions, the resulting 
programs should be representable by introducing new operations into the stable 
operator system without fundamentally changing the IR infrastructure.</p>
-
-<p>Additionally, the foundation should be able to <strong>connect to stable 
compiler toolchains</strong> where it makes sense, so we can reuse established 
backend capabilities when those backends are not a bottleneck.</p>
-
-<h2 id="how-should-we-design-ml-compilers-for-agents">How Should We Design ML 
Compilers for Agents?</h2>
-
-<p>One key characteristic of the agentic era is the accelerating pace of 
development. Agents will become the primary developers of compiler extensions 
and will try out new ideas. We should rethink what makes compiler code itself 
easy to develop and maintain.</p>
-
-<h3 id="should-everything-be-written-in-the-same-language">Should Everything 
Be Written in the Same Language?</h3>
-
-<p><img src="/images/rethink-ml-compiler-foundation/image5.png" alt="A shared 
TVM-FFI and TIRx foundation supports Python, C++, and Rust compiler components" 
style="width: 90%; margin: auto; display: block;" /></p>
-
-<p>Most of our current compilers are written primarily in one programming 
language, with supporting wrappers in others. However, an agent implementing 
different kinds of compiler components may have different needs:</p>
-
-<ul>
-  <li>For experimental analyses that benefit from existing Python libraries 
such as NumPy or PyTorch, Python would be preferable.</li>
-  <li>For frequently executed analysis passes, C++ or Rust may be 
preferable.</li>
-</ul>
-
-<p>While agents can always reimplement everything in a single language such as 
C++ or Rust, the tokens spent doing so could be put to better use. Ideally, a 
global choice of programming language should not constrain local implementation 
decisions.</p>
-
-<p>These observations highlight the need for <strong>first-class 
cross-language support</strong>. Built on TVM-FFI, the TIRx foundation provides 
out-of-the-box, first-class support for Python, C++, and Rust. Agents can 
prototype in Python, move performance-critical components to C++ or Rust, and 
reuse extensions across supported languages.</p>
-
-<h3 id="how-can-we-help-agents-iterate-faster">How Can We Help Agents Iterate 
Faster?</h3>
-
-<p><img src="/images/rethink-ml-compiler-foundation/image3.png" alt="Dynamic 
extensions shorten the agent development loop by avoiding monolithic compiler 
rebuilds" style="width: 90%; margin: auto; display: block;" /></p>
-
-<p>An agent can be very smart, but its iteration speed is fundamentally 
limited by its development environment and workflow. Suppose an agent wants to 
add a new operator or experiment with a new backend. Generally, it needs to 
modify the code, rebuild the compiler, run the tests, and repeat that process. 
As agents become faster at writing code, rebuilding and testing account for a 
larger share of the development loop. While mechanisms like build caching can 
partly alleviate the issue, th [...]
-
-<p>These needs call for a shift from statically bundled compilers and 
extensions to <strong>dynamic extension by design.</strong> The TIRx foundation 
allows types and operations to be added dynamically without rebuilding a 
monolithic compiler. Extensions can live in independent repositories and 
interoperate with the foundation, enabling faster development iterations.</p>
-
-<h3 id="what-will-maintenance-look-like-going-forward">What Will Maintenance 
Look Like Going Forward?</h3>
-
-<p>As agents get better at building compiler components, we should also 
consider how project maintenance will change. Agents may still need to maintain 
different, potentially conflicting optimization pipelines tailored to specific 
domains. There will also be a strong need for compiler harnesses that focus on 
analysis rather than code transformation. Finally, agents may make optimization 
decisions themselves rather than relying on heuristic transformations.</p>
-
-<p>There is a <strong>fundamental tension between rapid innovation and the 
need for stability and code quality</strong>. Kernels can be generated in 
minutes and discarded, whereas lower layers benefit from stability and closer 
human oversight.</p>
-
-<p><img src="/images/rethink-ml-compiler-foundation/image1.png" alt="Kernels, 
compiler harnesses, and the minimal compiler foundation evolve at different 
rates with different levels of human oversight" style="width: 90%; margin: 
auto; display: block;" /></p>
-
-<p>These observations favor structuring projects into layers based on their 
levels of stability and rates of change. The new ML compiler foundation should 
provide a minimal, stable, and predictable base for compilation, with extension 
mechanisms that allow agents to customize the compiler abstractions themselves. 
Agents can build compiler harnesses and transformations on top and evolve them 
at a faster rate. The TIRx foundation focuses on:</p>
-
-<ul>
-  <li><strong>A minimal, stable core AST</strong>, extended through an open 
operator system.</li>
-  <li><strong>Reusable, predictable utilities</strong>, including symbolic 
integer analysis, structural traversal and mapping, and TVM-FFI bridge 
generation.</li>
-  <li><strong>Integration with established toolchains</strong>, including 
basic CUDA and host LLVM code generation, rather than reimplementing everything 
within a custom compiler pipeline.</li>
-</ul>
-
-<p>The goal is not to eliminate compiler functionality, but to keep the shared 
foundation small while letting agents implement and evolve the functionality 
they need at upper layers.</p>
-
-<h2 id="discussion-and-looking-to-the-future">Discussion and Looking to the 
Future</h2>
-
-<p><img src="/images/rethink-ml-compiler-foundation/image4.png" alt="Minimal 
composable boundaries support continued improvement as agent tokens and 
engineering effort increase" style="width: 90%; margin: auto; display: block;" 
/></p>
-
-<p>We are at a crossroads this year, and predicting where the future will lead 
is challenging. The approach outlined in this post is likely not the only path 
forward for ML compilers in the agentic era. As ML compilers transition into 
this new phase, we must carefully avoid rigid abstractions that restrict agent 
capabilities, while recognizing that a complete lack of layering leads to 
unnecessary token expenditure and sloppy outcomes.</p>
-
-<p>Our view is that composable layers can succeed as long as we avoid rigid 
abstractions that limit agent capabilities. An ML compiler foundation can play 
a vital role in supporting research and development in ML compilers and agents. 
We hope TIRx can provide such a foundation and work with the broader ML 
compiler and agentic development ecosystems.</p>
-
-<h2 id="technical-details">Technical Details</h2>
-
-<p>The previous section discusses the overall design motivation. This section 
walks through some of the technical design elements with code examples. For 
readability, the technical details are collapsed below.</p>
-
-<details class="technical-details">
-  <summary>Technical details and code examples</summary>
-
-  <p>TIRx offers a complete interface to construct typical tensor programs in 
Python:</p>
-
-  <div class="language-python highlighter-rouge"><div class="highlight"><pre 
class="highlight"><code><span class="kn">from</span> <span 
class="n">tvm_tirx.script</span> <span class="kn">import</span> <span 
class="n">tirx</span> <span class="k">as</span> <span class="n">T</span>
-
-<span class="n">n</span> <span class="o">=</span> <span 
class="n">T</span><span class="p">.</span><span class="nf">dynamic</span><span 
class="p">(</span><span class="sh">"</span><span class="s">n</span><span 
class="sh">"</span><span class="p">)</span>
-
-<span class="nd">@T.function</span>
-<span class="k">def</span> <span class="nf">add_one</span><span 
class="p">(</span><span class="n">A</span><span class="p">:</span> <span 
class="n">T</span><span class="p">.</span><span class="nc">Tensor</span><span 
class="p">((</span><span class="n">n</span><span class="p">,),</span> <span 
class="n">T</span><span class="p">.</span><span class="n">float32</span><span 
class="p">),</span> <span class="n">B</span><span class="p">:</span> <span 
class="n">T</span><span class="p">.</span><span  [...]
-    <span class="k">for</span> <span class="n">i</span> <span 
class="ow">in</span> <span class="nf">range</span><span class="p">(</span><span 
class="n">n</span><span class="p">):</span>
-        <span class="n">B</span><span class="p">[</span><span 
class="n">i</span><span class="p">]</span> <span class="o">=</span> <span 
class="n">A</span><span class="p">[</span><span class="n">i</span><span 
class="p">]</span> <span class="o">+</span> <span class="mi">1</span>
-</code></pre></div>  </div>
-
-  <p>The example above constructs a function object representing an add-one 
operation on the CPU. TIRx provides a built-in API to compile the function into 
code that interoperates with libraries in the Python array API ecosystem, such 
as NumPy and PyTorch.</p>
-
-  <div class="language-python highlighter-rouge"><div class="highlight"><pre 
class="highlight"><code><span class="kn">import</span> <span 
class="n">torch</span>
-<span class="kn">import</span> <span class="n">tvm_tirx</span> <span 
class="k">as</span> <span class="n">tirx</span>
-
-<span class="n">add_one_compiled</span> <span class="o">=</span> <span 
class="n">tirx</span><span class="p">.</span><span 
class="nf">compile</span><span class="p">(</span><span 
class="n">add_one</span><span class="p">,</span> <span 
class="n">target</span><span class="o">=</span><span class="sh">"</span><span 
class="s">llvm</span><span class="sh">"</span><span class="p">)</span>
-<span class="n">a</span> <span class="o">=</span> <span 
class="n">torch</span><span class="p">.</span><span 
class="nf">arange</span><span class="p">(</span><span class="mi">10</span><span 
class="p">,</span> <span class="n">dtype</span><span class="o">=</span><span 
class="n">torch</span><span class="p">.</span><span 
class="n">float32</span><span class="p">)</span>
-<span class="n">b</span> <span class="o">=</span> <span 
class="n">torch</span><span class="p">.</span><span 
class="nf">empty</span><span class="p">(</span><span class="n">a</span><span 
class="p">.</span><span class="n">shape</span><span class="p">,</span> <span 
class="n">dtype</span><span class="o">=</span><span class="n">a</span><span 
class="p">.</span><span class="n">dtype</span><span class="p">)</span>
-<span class="nf">add_one_compiled</span><span class="p">(</span><span 
class="n">a</span><span class="p">,</span> <span class="n">b</span><span 
class="p">)</span>
-</code></pre></div>  </div>
-
-  <p>Our design aims to be <strong>minimal, faithful, and 
predictable</strong>. A call to <code class="language-plaintext 
highlighter-rouge">tirx.compile</code> applies no additional heuristic 
optimizations; the program is passed directly to the LLVM compiler toolchain to 
generate CPU code.</p>
-
-  <p>The examples so far show how TIRx can be used as a typical opaque 
domain-specific compiler. As mentioned earlier, our goal is to expose not only 
the programming interface but also the compiler API and every intermediate AST 
object to developers and agents. We store every AST node in a 
<strong>cross-language object</strong> backed by TVM FFI, making it directly 
accessible from languages including Python, C++, and Rust. The following code 
shows how we can inspect program structures su [...]
-
-  <div class="language-python highlighter-rouge"><div class="highlight"><pre 
class="highlight"><code><span class="c1"># query the type of parameter A
-</span><span class="n">ty_A</span> <span class="o">=</span> <span 
class="n">add_one</span><span class="p">.</span><span 
class="n">params</span><span class="p">[</span><span class="mi">0</span><span 
class="p">].</span><span class="n">ty</span>
-<span class="c1"># query the length of parameter B
-</span><span class="n">n</span> <span class="o">=</span> <span 
class="n">add_one</span><span class="p">.</span><span 
class="n">params</span><span class="p">[</span><span class="mi">1</span><span 
class="p">].</span><span class="n">ty</span><span class="p">.</span><span 
class="n">shape</span><span class="p">[</span><span class="mi">0</span><span 
class="p">]</span>
-</code></pre></div>  </div>
-
-  <h3 id="common-utilities-for-traversal-mapping-and-analysis">Common 
Utilities for Traversal, Mapping, and Analysis</h3>
-
-  <p>Direct access to internal compiler objects allows us to inspect and 
transform programs further. We use a set of lightweight, general-purpose 
utilities built into TIRx and TVM FFI to traverse, compare, and transform 
program structures. For example, the following code snippet specializes the 
dynamic dimension <code class="language-plaintext highlighter-rouge">n</code> 
to 128:</p>
-
-  <div class="language-python highlighter-rouge"><div class="highlight"><pre 
class="highlight"><code><span class="kn">import</span> <span 
class="n">tvm_ffi</span>
-<span class="kn">import</span> <span class="n">tvm_tirx</span>
-
-<span class="n">add_one_specialized</span> <span class="o">=</span> <span 
class="n">tvm_ffi</span><span class="p">.</span><span 
class="nf">structural_map</span><span class="p">(</span>
-    <span class="n">add_one</span><span class="p">,</span>
-    <span class="p">(</span><span class="n">tvm_tirx</span><span 
class="p">.</span><span class="n">ir</span><span class="p">.</span><span 
class="n">Var</span><span class="p">,</span> <span class="k">lambda</span> 
<span class="n">v</span><span class="p">:</span> <span class="mi">128</span> 
<span class="k">if</span> <span class="n">v</span><span class="p">.</span><span 
class="nf">same_as</span><span class="p">(</span><span class="n">n</span><span 
class="p">)</span> <span class="k">else</sp [...]
-<span class="p">)</span>
-
-<span class="n">add_one_specialized</span><span class="p">.</span><span 
class="nf">show</span><span class="p">()</span>
-</code></pre></div>  </div>
-
-  <div class="language-python highlighter-rouge"><div class="highlight"><pre 
class="highlight"><code><span class="nd">@T.function</span>
-<span class="k">def</span> <span class="nf">add_one</span><span 
class="p">(</span><span class="n">A</span><span class="p">:</span> <span 
class="n">T</span><span class="p">.</span><span class="nc">Tensor</span><span 
class="p">((</span><span class="mi">128</span><span class="p">,),</span> <span 
class="n">T</span><span class="p">.</span><span class="n">float32</span><span 
class="p">),</span> <span class="n">B</span><span class="p">:</span> <span 
class="n">T</span><span class="p">.</span><sp [...]
-    <span class="k">for</span> <span class="n">i</span> <span 
class="ow">in</span> <span class="nf">range</span><span class="p">(</span><span 
class="mi">128</span><span class="p">):</span>
-        <span class="n">B</span><span class="p">[</span><span 
class="n">i</span><span class="p">]</span> <span class="o">=</span> <span 
class="n">A</span><span class="p">[</span><span class="n">i</span><span 
class="p">]</span> <span class="o">+</span> <span class="mi">1</span>
-</code></pre></div>  </div>
-
-  <p>Symbolic shapes and indices are common in both kernels and higher-level 
programs. TIRx’s representation allows types like <code 
class="language-plaintext highlighter-rouge">TensorType</code> to depend on 
expression values, and we provide common utilities to check symbolic relations 
during program analysis. Thanks to feedback from the TileLang community, we 
have also added structural traversal variants with symbolic constraint contexts 
and stronger Z3 proofs. These tools are designed [...]
-
-  <p>At every stage of compilation, the program can be printed in Python 
script syntax, as shown above. This allows agents and developers to inspect 
intermediate programs, experiment with transformations, and build new ones.</p>
-
-  <h3 id="dynamic-extension-through-types-and-operations">Dynamic Extension 
through Types and Operations</h3>
-
-  <p>While the compiler foundation provides a minimal backbone, TIRx is 
designed to accommodate new customizations both in-tree and downstream. The 
primary way to extend the TIRx foundation is to introduce new types and 
operations. Downstream projects can define new types as TVM-FFI objects that 
subclass the original type node and carry additional type and expression 
information. For example, we introduced <code class="language-plaintext 
highlighter-rouge">tirx.TensorMapType</code> to su [...]
-
-  <p>Because new types can carry information that depends on other types and 
expressions, they can preserve that information across intermediate stages of 
compilation. A typical approach is to lower these intermediate types to 
existing types or add dedicated backend code generation support for the new 
types. To maintain simplicity and consistency, we allow Python type 
constructors to be used directly in the script syntax. For instance, <code 
class="language-plaintext highlighter-rouge">T [...]
-
-  <p>Most extensions introduce new operations (ops). An op can be used in 
either a <code class="language-plaintext highlighter-rouge">Call</code> AST 
node, resembling an intrinsic call, or a <code class="language-plaintext 
highlighter-rouge">RegionStmt</code>, defining a region with additional 
semantics such as a thread launch or kernel region. We built minimal CUDA and 
PTX support by introducing the <code class="language-plaintext 
highlighter-rouge">device_entry</code> region op and rep [...]
-
-  <div class="language-python highlighter-rouge"><div class="highlight"><pre 
class="highlight"><code><span class="kn">from</span> <span 
class="n">tvm_tirx.script</span> <span class="kn">import</span> <span 
class="n">tirx</span> <span class="k">as</span> <span class="n">T</span>
-
-<span class="n">n</span> <span class="o">=</span> <span 
class="n">T</span><span class="p">.</span><span class="nf">dynamic</span><span 
class="p">(</span><span class="sh">"</span><span class="s">n</span><span 
class="sh">"</span><span class="p">)</span>
-
-<span class="nd">@T.function</span>
-<span class="k">def</span> <span class="nf">add_one</span><span 
class="p">(</span><span class="n">A</span><span class="p">:</span> <span 
class="n">T</span><span class="p">.</span><span class="nc">Tensor</span><span 
class="p">((</span><span class="n">n</span><span class="p">,),</span> <span 
class="n">T</span><span class="p">.</span><span class="n">float32</span><span 
class="p">),</span> <span class="n">B</span><span class="p">:</span> <span 
class="n">T</span><span class="p">.</span><span  [...]
-    <span class="n">T</span><span class="p">.</span><span 
class="nf">device_entry</span><span class="p">(</span>
-        <span class="n">launch</span><span class="o">=</span><span 
class="n">T</span><span class="p">.</span><span class="n">cuda</span><span 
class="p">.</span><span class="nc">LaunchConfig</span><span 
class="p">(</span><span class="n">grid</span><span class="o">=</span><span 
class="p">((</span><span class="n">n</span> <span class="o">+</span> <span 
class="mi">255</span><span class="p">)</span> <span class="o">//</span> <span 
class="mi">256</span><span class="p">,),</span> <span class="n [...]
-    <span class="p">)</span>
-    <span class="n">i</span> <span class="o">=</span> <span 
class="n">T</span><span class="p">.</span><span class="n">cuda</span><span 
class="p">.</span><span class="nf">block_idx</span><span 
class="p">(</span><span class="sh">"</span><span class="s">x</span><span 
class="sh">"</span><span class="p">)</span> <span class="o">*</span> <span 
class="mi">256</span> <span class="o">+</span> <span class="n">T</span><span 
class="p">.</span><span class="n">cuda</span><span class="p">.</span><span  
[...]
-    <span class="k">if</span> <span class="n">i</span> <span 
class="o">&lt;</span> <span class="n">n</span><span class="p">:</span>
-        <span class="n">T</span><span class="p">.</span><span 
class="n">ptx</span><span class="p">.</span><span class="n">add</span><span 
class="p">.</span><span class="n">rn</span><span class="p">.</span><span 
class="nf">f32</span><span class="p">(</span><span class="n">B</span><span 
class="p">[</span><span class="n">i</span><span class="p">],</span> <span 
class="n">A</span><span class="p">[</span><span class="n">i</span><span 
class="p">],</span> <span class="n">T</span><span class="p"> [...]
-</code></pre></div>  </div>
-
-  <p>As an example of these dynamic extension capabilities, we registered most 
ops in the <code class="language-plaintext highlighter-rouge">T.ptx</code> 
namespace directly through Python, allowing us to update compiler support 
quickly without modifying the core library.</p>
-
-  <p>Both type and operator registrations support dynamic extension through 
runtime tables indexed by string keys. This setup allows us to build extensions 
as downstream packages that depend on the compiler foundation without needing 
to recompile or bundle the original project. This separation enables different 
modules to evolve at different rates. The ML compiler foundation contains 
reusable code that is continuously hardened, while agents can independently 
iterate on new compiler harne [...]
-
-  <h3 id="first-class-tvm-ffi-host-abi-support">First-Class TVM FFI Host ABI 
Support</h3>
-
-  <p>Every new ML compiler or harness needs a way to connect to the broader 
ecosystem. TVM FFI provides standard ABI and FFI support for interoperability. 
The TIRx foundation provides shared utilities for generating host code 
compatible with the TVM FFI ABI. This is particularly useful for generating 
efficient compiled tensor checks. For example, the following code declares a 
<code class="language-plaintext highlighter-rouge">2 * n</code> shape 
constraint on an input tensor. The compiled [...]
-
-  <div class="language-python highlighter-rouge"><div class="highlight"><pre 
class="highlight"><code><span class="kn">import</span> <span 
class="n">torch</span>
-<span class="kn">import</span> <span class="n">tvm_tirx</span> <span 
class="k">as</span> <span class="n">tirx</span>
-<span class="kn">from</span> <span class="n">tvm_tirx.script</span> <span 
class="kn">import</span> <span class="n">tirx</span> <span class="k">as</span> 
<span class="n">T</span>
-
-<span class="n">n</span> <span class="o">=</span> <span 
class="n">T</span><span class="p">.</span><span class="nf">dynamic</span><span 
class="p">(</span><span class="sh">"</span><span class="s">n</span><span 
class="sh">"</span><span class="p">)</span>
-
-<span class="nd">@T.function</span>
-<span class="k">def</span> <span class="nf">add_one</span><span 
class="p">(</span><span class="n">A</span><span class="p">:</span> <span 
class="n">T</span><span class="p">.</span><span class="nc">Tensor</span><span 
class="p">((</span><span class="mi">2</span> <span class="o">*</span> <span 
class="n">n</span><span class="p">,),</span> <span class="n">T</span><span 
class="p">.</span><span class="n">float32</span><span class="p">),</span> <span 
class="n">B</span><span class="p">:</span> <sp [...]
-    <span class="k">for</span> <span class="n">i</span> <span 
class="ow">in</span> <span class="nf">range</span><span class="p">(</span><span 
class="mi">2</span> <span class="o">*</span> <span class="n">n</span><span 
class="p">):</span>
-        <span class="n">B</span><span class="p">[</span><span 
class="n">i</span><span class="p">]</span> <span class="o">=</span> <span 
class="n">A</span><span class="p">[</span><span class="n">i</span><span 
class="p">]</span> <span class="o">+</span> <span class="mi">1</span>
-
-<span class="n">add_one_compiled</span> <span class="o">=</span> <span 
class="n">tirx</span><span class="p">.</span><span 
class="nf">compile</span><span class="p">(</span><span 
class="n">add_one</span><span class="p">,</span> <span 
class="n">target</span><span class="o">=</span><span class="sh">"</span><span 
class="s">llvm</span><span class="sh">"</span><span class="p">)</span>
-<span class="n">a</span> <span class="o">=</span> <span 
class="n">torch</span><span class="p">.</span><span 
class="nf">arange</span><span class="p">(</span><span class="mi">11</span><span 
class="p">,</span> <span class="n">dtype</span><span class="o">=</span><span 
class="n">torch</span><span class="p">.</span><span 
class="n">float32</span><span class="p">)</span>
-<span class="n">b</span> <span class="o">=</span> <span 
class="n">torch</span><span class="p">.</span><span 
class="nf">empty</span><span class="p">(</span><span class="n">a</span><span 
class="p">.</span><span class="n">shape</span><span class="p">,</span> <span 
class="n">dtype</span><span class="o">=</span><span class="n">a</span><span 
class="p">.</span><span class="n">dtype</span><span class="p">)</span>
-<span class="nf">add_one_compiled</span><span class="p">(</span><span 
class="n">a</span><span class="p">,</span> <span class="n">b</span><span 
class="p">)</span>
-</code></pre></div>  </div>
-
-  <div class="language-text highlighter-rouge"><div class="highlight"><pre 
class="highlight"><code>ValueError: Invalid A.shape[0] on argument #0 when 
calling:
-   `add_one(A: Tensor([2 * n], float32), B: Tensor([2 * n], float32))`,
-   expected A.shape[0] to be divisible by 2
-</code></pre></div>  </div>
-
-  <p>While agents can easily rebuild support for new variants on the fly, 
these foundation features remain stable and continue to be hardened, allowing 
agents to focus on developing new compiler features and analyses while relying 
on established pipelines.</p>
-
-</details>
-
-<h2 id="acknowledgements">Acknowledgements</h2>
-
-<p>This post summarizes work by many contributors across the TVM and broader 
ML communities. It was written by a human, with GenAI models assisting with 
grammar and style edits.</p>
-
-<h2 id="links">Links</h2>
-
-<ul>
-  <li>GitHub (work in progress): <a 
href="https://github.com/apache/tvm-tirx/";>https://github.com/apache/tvm-tirx/</a></li>
-</ul>
-
-    </div>
-    </div>
-  </div>
-</div>
-</div>
-
-    
-
-
-
-
-  <script src="../../../_static/downloads/jquery-2.2.0.min.js" 
type="text/javascript"></script>
-  <script src="../../../_static/downloads/popper.min.js" 
integrity="sha384-ZMP7rVo3mIykV+2+9J3UJ46jBk0WLaUAdn689aCwoqbBJiSnjAK/l8WvCWPIPm49"
 crossorigin="anonymous"></script>
-  <script src="../../../_static/downloads/bootstrap.min.js" 
integrity="sha384-ChfqqxuZUCnJSK3+MXmPNIyE6ZbWh2IMqE241rYiqJxyMiZ6OW/JmZQ5stwEULTy"
 crossorigin="anonymous"></script>
-  <!-- <script src="./assets/js/slick.js"></script> -->
-  <script src="/assets/js/custome.js"></script>
-  <script>
-    window.dataLayer = window.dataLayer || [];
-    function gtag(){dataLayer.push(arguments);}
-    gtag('js', new Date());
-    gtag('config', 'UA-75982049-2');
-  </script>
+  <p>This article has moved to <a 
href="/2026/11/03/rethinking-abstractions-in-the-agentic-era.html">Rethinking 
Abstractions in the Agentic Era</a>.</p>
 </body>
-<section class="footerSec">
-  <div class="footerHeader">
-    <ul class="container d-flex align-md-items-center justify-content-between 
flex-column flex-md-row">
-      <li class="logo">
-
-        <p><a href="/"><img src="/assets/images/logo.svg" alt="logo" 
title="logo" /></a></p>
-      </li>
-      <li class="copywrite d-flex align-items-center">
-        <h5 id="apache-software-foundation--all-right-reserved">© 2024 Apache 
Software Foundation | All right reserved</h5>
-      </li>
-    </ul>
-
-  </div>
-
-  <ul class="container">
-    <li class="footernote">
-      Copyright © 2024 The Apache Software Foundation. Apache TVM, Apache, the 
Apache feather, and the Apache TVM project logo are either trademarks or 
registered trademarks of the Apache Software Foundation.</li>
-  </ul>
-
-</section>
 </html>
diff --git a/2026/11/03/rethink-ml-compiler-foundation-for-the-agentic-era.html 
b/2026/11/03/rethinking-abstractions-in-the-agentic-era.html
similarity index 99%
copy from 2026/11/03/rethink-ml-compiler-foundation-for-the-agentic-era.html
copy to 2026/11/03/rethinking-abstractions-in-the-agentic-era.html
index 59957f4b61c..17b9215e0b4 100644
--- a/2026/11/03/rethink-ml-compiler-foundation-for-the-agentic-era.html
+++ b/2026/11/03/rethinking-abstractions-in-the-agentic-era.html
@@ -2,7 +2,7 @@
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Rethinking the ML Compiler Foundation for the Agentic Era</title>
+    <title>Rethinking Abstractions in the Agentic Era: Towards a DSL and 
Compiler Foundation for Agentic Kernel Development</title>
     <link rel="shortcut icon" href="/assets/images/favicon.ico">
     <link rel="stylesheet" href="../../../_static/downloads/bootstrap.min.css" 
integrity="sha384-MCw98/SFnGE8fJT3GXwEOngsV7Zt27NXFoaoApmYm81iuXoPkFOJwJ8ERdknLPMO"
 crossorigin="anonymous">
     <link rel="stylesheet" href="/css/slick.css">
@@ -137,7 +137,7 @@
   <div class="row">
     <div class="span14 w-100">
       <header class="post-header">
-      <h1>Rethinking the ML Compiler Foundation for the Agentic Era </h1>
+      <h1>Rethinking Abstractions in the Agentic Era: Towards a DSL and 
Compiler Foundation for Agentic Kernel Development </h1>
       <p class="post-meta">
         <time datetime="2026-11-03T00:00:00+00:00" itemprop="datePublished">
           Nov 3, 2026
diff --git a/_static/downloads/acm%3Adesktopcta 
b/_static/downloads/acm%3Adesktopcta
index 91f01042319..31fe3038d21 100644
--- a/_static/downloads/acm%3Adesktopcta
+++ b/_static/downloads/acm%3Adesktopcta
@@ -64,12 +64,12 @@
 
       <div class="cf-error-footer cf-wrapper w-240 lg:w-full py-10 sm:py-4 
sm:px-8 mx-auto text-center sm:text-left border-solid border-0 border-t 
border-gray-300">
     <p class="text-13">
-      <span class="cf-footer-item sm:block sm:mb-1">Cloudflare Ray ID: <strong 
class="font-semibold">a55500f07bd6f165</strong></span>
+      <span class="cf-footer-item sm:block sm:mb-1">Cloudflare Ray ID: <strong 
class="font-semibold">a555afb49a9dda3a</strong></span>
       <span class="cf-footer-separator sm:hidden">&bull;</span>
       <span id="cf-footer-item-ip" class="cf-footer-item hidden sm:block 
sm:mb-1">
         Your IP:
         <button type="button" id="cf-footer-ip-reveal" 
class="cf-footer-ip-reveal-btn">Click to reveal</button>
-        <span class="hidden" id="cf-footer-ip">52.252.244.216</span>
+        <span class="hidden" id="cf-footer-ip">172.182.226.229</span>
         <span class="cf-footer-separator sm:hidden">&bull;</span>
       </span>
       <span class="cf-footer-item sm:block sm:mb-1"><span>Performance &amp; 
security by</span> <a rel="noopener noreferrer" 
href="https://www.cloudflare.com/5xx-error-landing"; id="brand_link" 
target="_blank">Cloudflare</a></span>
@@ -86,5 +86,5 @@
     
     
   </script>
-<script>(function(){function c(){var 
b=a.contentDocument||(a.contentWindow&&a.contentWindow.document);if(b){var 
d=b.createElement('script');d.innerHTML="window.__CF$cv$params={r:'a55500f07bd6f165',t:'MTc5MzgwOTgzMA=='};var
 l=window.parent.location,o;try{o=new URL(l.origin).origin}catch(e){try{o=new 
URL(new URL(l.href).origin).origin}catch(e){o=''}}var 
u='/cdn-cgi/challenge-platform/scripts/jsd/main.js?ray=a55500f07bd6f165',a=document.createElement('script');a.src=o?new
 URL(u,o).href:u;do [...]
+<script>(function(){function c(){var 
b=a.contentDocument||(a.contentWindow&&a.contentWindow.document);if(b){var 
d=b.createElement('script');d.innerHTML="window.__CF$cv$params={r:'a555afb49a9dda3a',t:'MTc5MzgxNjk4OA=='};var
 l=window.parent.location,o;try{o=new URL(l.origin).origin}catch(e){try{o=new 
URL(new URL(l.href).origin).origin}catch(e){o=''}}var 
u='/cdn-cgi/challenge-platform/scripts/jsd/main.js?ray=a555afb49a9dda3a',a=document.createElement('script');a.src=o?new
 URL(u,o).href:u;do [...]
 </html>
\ No newline at end of file
diff --git a/atom.xml b/atom.xml
index 4f6b70b4541..e12bf4603b0 100644
--- a/atom.xml
+++ b/atom.xml
@@ -4,7 +4,7 @@
  <title>TVM</title>
  <link href="https://tvm.apache.org"; rel="self"/>
  <link href="https://tvm.apache.org"/>
- <updated>2026-11-04T16:30:29+00:00</updated>
+ <updated>2026-11-04T18:29:43+00:00</updated>
  <id>https://tvm.apache.org</id>
  <author>
    <name></name>
@@ -13,10 +13,10 @@
 
  
  <entry>
-   <title>Rethinking the ML Compiler Foundation for the Agentic Era</title>
-   <link 
href="https://tvm.apache.org/2026/11/03/rethink-ml-compiler-foundation-for-the-agentic-era"/>
+   <title>Rethinking Abstractions in the Agentic Era: Towards a DSL and 
Compiler Foundation for Agentic Kernel Development</title>
+   <link 
href="https://tvm.apache.org/2026/11/03/rethinking-abstractions-in-the-agentic-era"/>
    <updated>2026-11-03T00:00:00+00:00</updated>
-   
<id>https://tvm.apache.org/2026/11/03/rethink-ml-compiler-foundation-for-the-agentic-era</id>
+   
<id>https://tvm.apache.org/2026/11/03/rethinking-abstractions-in-the-agentic-era</id>
    <content type="html">&lt;section class=&quot;post-summary&quot; 
aria-labelledby=&quot;tldr&quot;&gt;
 
   &lt;h2 id=&quot;tldr&quot;&gt;TL;DR&lt;/h2&gt;
diff --git a/feed.xml b/feed.xml
index 0fd851d8142..4fcbc5b199d 100644
--- a/feed.xml
+++ b/feed.xml
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?><feed 
xmlns="http://www.w3.org/2005/Atom"; ><generator uri="https://jekyllrb.com/"; 
version="4.4.1">Jekyll</generator><link href="/feed.xml" rel="self" 
type="application/atom+xml" /><link href="/" rel="alternate" type="text/html" 
/><updated>2026-11-04T16:30:29+00:00</updated><id>/feed.xml</id><title 
type="html">TVM</title><author><name>{&quot;name&quot; =&gt; 
nil}</name></author><entry><title type="html">Rethinking the ML Compiler 
Foundation for the Ag [...]
+<?xml version="1.0" encoding="utf-8"?><feed 
xmlns="http://www.w3.org/2005/Atom"; ><generator uri="https://jekyllrb.com/"; 
version="4.4.1">Jekyll</generator><link href="/feed.xml" rel="self" 
type="application/atom+xml" /><link href="/" rel="alternate" type="text/html" 
/><updated>2026-11-04T18:29:43+00:00</updated><id>/feed.xml</id><title 
type="html">TVM</title><author><name>{&quot;name&quot; =&gt; 
nil}</name></author><entry><title type="html">Rethinking Abstractions in the 
Agentic Era: Towa [...]
 
   <h2 id="tldr">TL;DR</h2>
 
diff --git a/posts.html b/posts.html
index 70eaaa25f60..6210470b169 100644
--- a/posts.html
+++ b/posts.html
@@ -146,7 +146,7 @@
 
 <li>
   <span>
-    <a class="post-link" 
href="/2026/11/03/rethink-ml-compiler-foundation-for-the-agentic-era">Rethinking
 the ML Compiler Foundation for the Agentic Era</a>
+    <a class="post-link" 
href="/2026/11/03/rethinking-abstractions-in-the-agentic-era">Rethinking 
Abstractions in the Agentic Era: Towards a DSL and Compiler Foundation for 
Agentic Kernel Development</a>
   </span>
   </br>
   <span>
diff --git a/rss.xml b/rss.xml
index 60ed5b42e23..42a43375833 100644
--- a/rss.xml
+++ b/rss.xml
@@ -5,13 +5,13 @@
         <description>TVM - </description>
         <link>https://tvm.apache.org</link>
         <atom:link href="https://tvm.apache.org"; rel="self" 
type="application/rss+xml" />
-        <lastBuildDate>Wed, 04 Nov 2026 16:30:29 +0000</lastBuildDate>
-        <pubDate>Wed, 04 Nov 2026 16:30:29 +0000</pubDate>
+        <lastBuildDate>Wed, 04 Nov 2026 18:29:43 +0000</lastBuildDate>
+        <pubDate>Wed, 04 Nov 2026 18:29:43 +0000</pubDate>
         <ttl>60</ttl>
 
 
         <item>
-                <title>Rethinking the ML Compiler Foundation for the Agentic 
Era</title>
+                <title>Rethinking Abstractions in the Agentic Era: Towards a 
DSL and Compiler Foundation for Agentic Kernel Development</title>
                 <description>&lt;section class=&quot;post-summary&quot; 
aria-labelledby=&quot;tldr&quot;&gt;
 
   &lt;h2 id=&quot;tldr&quot;&gt;TL;DR&lt;/h2&gt;
@@ -279,8 +279,8 @@
   &lt;li&gt;GitHub (work in progress): &lt;a 
href=&quot;https://github.com/apache/tvm-tirx/&quot;&gt;https://github.com/apache/tvm-tirx/&lt;/a&gt;&lt;/li&gt;
 &lt;/ul&gt;
 </description>
-                
<link>https://tvm.apache.org/2026/11/03/rethink-ml-compiler-foundation-for-the-agentic-era</link>
-                
<guid>https://tvm.apache.org/2026/11/03/rethink-ml-compiler-foundation-for-the-agentic-era</guid>
+                
<link>https://tvm.apache.org/2026/11/03/rethinking-abstractions-in-the-agentic-era</link>
+                
<guid>https://tvm.apache.org/2026/11/03/rethinking-abstractions-in-the-agentic-era</guid>
                 <pubDate>Tue, 03 Nov 2026 00:00:00 +0000</pubDate>
         </item>
 
diff --git a/sitemap.txt b/sitemap.txt
index a9246d3ad80..9ff4a8d8d50 100644
--- a/sitemap.txt
+++ b/sitemap.txt
@@ -9,13 +9,14 @@ https://tvm.apache.org/download
 https://tvm.apache.org/history
 https://tvm.apache.org/
 https://tvm.apache.org/posts
+https://tvm.apache.org/2026/11/03/rethink-ml-compiler-foundation-for-the-agentic-era.html
 https://tvm.apache.org/rss.xml
 https://tvm.apache.org/sitemap.txt
 https://tvm.apache.org/tags
 https://tvm.apache.org/feed.xml
 https://tvm.apache.org/css/custom.css.map
 
-https://tvm.apache.org/2026/11/03/rethink-ml-compiler-foundation-for-the-agentic-era
+https://tvm.apache.org/2026/11/03/rethinking-abstractions-in-the-agentic-era
 https://tvm.apache.org/2026/06/22/tirx
 https://tvm.apache.org/2025/10/21/tvm-ffi
 https://tvm.apache.org/2021/12/15/tvm-unity

Reply via email to