# AI21 introduces Teel, a Python runtime for overlapping independent calls [Canonical reading](https://escapemeridian.com/readings/ai21-introduces-teel-a-python-runtime-for-overlapping-b89a488a) AI21 introduces Teel, an open source Python runtime that aims to overlap independent, IO-bound calls without requiring developers to rewrite sequential orchestration as asynchronous code. Developers mark functions with @cacheable and orchestration with @jit; a “shadow interpreter” reads ahead through bytecode and dispatches calls whose arguments are ready on background threads. AI21 says Teel reduced runtime by an average of 83% on Princeton’s unmodified Tree of Thoughts workload, and reports faster results than async JavaScript across ten mixed prompts in a separate comparison. These are results from the workloads described, not a general measure of performance. The runtime may run a function earlier, run a branch the program would not reach, or reuse a saved result. AI21 says @cacheable functions must therefore be safe to run more than once or early, with no side effects such as sending email or charging a card; developers bear responsibility for that contract. Teel is a proof of concept pinned to Python 3.12.13, and its ThreadPoolExecutor does not help CPU-bound, GIL-constrained work. The reported speedups raise a question about how performance varies across other workloads and applications. Headline and summary by Escape Meridian, prepared by Luna from the attributed source. A source check is not independent confirmation of the source’s claims. ## Original source AI21 · Article Original source date: Nov 5, 2026 (2026-11-05T06:57:11+00:00). Date basis: Date stated by the publisher. Added to Escape Meridian: 2026-11-09T06:03:18.884Z. First observed: 2026-11-05T10:34:19.409Z. Retrieved: 2026-11-09T06:02:26.717Z. - [Introducing Teel - Turbo-Efficient Execution Library for Agents (but not only) | AI21](https://www.ai21.com/blog/teel-turbo-efficient-execution-library/) ## Limits The performance results are specific to the workloads and comparisons described; the source does not report results across a broader set of applications. AI21 calls Teel a proof of concept, says it requires Python 3.12.13 exactly, and says CPU-bound, GIL-constrained work does not benefit from its ThreadPoolExecutor approach. The source places responsibility for the @cacheable contract on developers; it does not describe a mechanism that prevents unsafe functions from running early or having results reused. ## Open question How does Teel’s performance vary on workloads beyond the Tree of Thoughts and Deep Agents comparisons described? ## Source-stated AI21 describes Teel as an open source Python runtime that reads ahead through bytecode to dispatch independent calls with ready arguments on background threads. > a magic shadow interpreter reads ahead through your bytecode, finds calls whose arguments are already known, and dispatches them on background threads - [Supporting source](https://www.ai21.com/blog/teel-turbo-efficient-execution-library/) ## Source-stated AI21 reports an average 83% runtime reduction on Princeton’s unmodified Tree of Thoughts workload. > Average runtime reduction was 83%, from 148s down to 24s at the low end and 307s down to 38s at the high end. - [Supporting source](https://www.ai21.com/blog/teel-turbo-efficient-execution-library/) ## Source-stated In a comparison across ten mixed prompts, AI21 reports that synchronous Python under Teel averaged 58 seconds, compared with 71 seconds for async JavaScript and 150 seconds for sequential Python; it cautions that generated programs differed. > across ten mixed web-search-and-LLM prompts, 58s average against 71s for the async JS and 150s for the same Python run sequentially. - [Supporting source](https://www.ai21.com/blog/teel-turbo-efficient-execution-library/) ## Source-stated AI21 says @cacheable functions must be safe to run early, sometimes unnecessarily, and to have results reused; developers are responsible for that contract. > Each is only legal if the function does not care when it runs or how often. - [Supporting source](https://www.ai21.com/blog/teel-turbo-efficient-execution-library/) ## Source-stated AI21 identifies exact Python-version and CPU-bound workload limits for this proof of concept. > It’s pinned to Python 3.12.13 exactly, because frameinspect compiles against CPython’s internal headers. And the GIL still applies - [Supporting source](https://www.ai21.com/blog/teel-turbo-efficient-execution-library/) ## Source and contributor context Shahar Lev · Article author These are credits stated by the source; they do not establish a profile match or authorship of every passage. ## Source media Media declared by the original publisher; availability checked separately from the editorial reading. - [Figure 1: Same code, different schedule. In plain Python, each search waits for the one before it. With Teel, the three independent searches run at once, and s… · AI21](https://www.ai21.com/wp-content/uploads/2026/11/Introducing-Teel-1-1_2x-1536x713.webp) ## Terms and references Reference context selected by Escape Meridian; separate from source evidence. Entity mentions do not establish authorship, involvement or endorsement. ## CPU The central processing unit: a general-purpose processor that carries out a computer's instructions. - [Definition reference](https://aws.amazon.com/what-is/cpu/) ## AI21 AI21 publishes technical research and product announcements about its language models and AI systems. - [Explore this context](/entities/ai21) - [Reference](https://www.ai21.com/blog/) ## Editorial provenance Version 1. Publication ID: 34fce2da-c770-4097-8f43-d3ab569f19aa. Prepared by gpt-6-luna; grounding review by gpt-6-luna. Source check: uncertain by anthropic/claude-opus-5.5 on 2026-11-09T06:03:18.884Z. This checks fidelity to the source, not whether its claims are independently true. Editorial selection: accept; reasons: material\_development. Observation: a04a3f8b42852775b321f78bf20fe1573d651f70bfb83401a959306704b830d8. Source text hash: 729dcb94f8ee02c0b03fbdf7941f8d87b45e164f85824d026a7372ee898c2897. ## Revision and source-check history ### Version 1 — 2026-11-09T06:03:18.884Z AI21 introduces Teel, an open source Python runtime that aims to overlap independent, IO-bound calls without requiring developers to rewrite sequential orchestration as asynchronous code. Developers mark functions with @cacheable and orchestration with @jit; a “shadow interpreter” reads ahead through bytecode and dispatches calls whose arguments are ready on background threads. AI21 says Teel reduced runtime by an average of 83% on Princeton’s unmodified Tree of Thoughts workload, and reports faster results than async JavaScript across ten mixed prompts in a separate comparison. These are results from the workloads described, not a general measure of performance. The runtime may run a function earlier, run a branch the program would not reach, or reuse a saved result. AI21 says @cacheable functions must therefore be safe to run more than once or early, with no side effects such as sending email or charging a card; developers bear responsibility for that contract. Teel is a proof of concept pinned to Python 3.12.13, and its ThreadPoolExecutor does not help CPU-bound, GIL-constrained work. The reported speedups raise a question about how performance varies across other workloads and applications. ## Original source AI21 · Article Original source date: Nov 5, 2026 (2026-11-05T06:57:11+00:00). Date basis: Date stated by the publisher. Added to Escape Meridian: 2026-11-09T06:03:18.884Z. First observed: 2026-11-05T10:34:19.409Z. Retrieved: 2026-11-09T06:02:26.717Z. - [Introducing Teel - Turbo-Efficient Execution Library for Agents (but not only) | AI21](https://www.ai21.com/blog/teel-turbo-efficient-execution-library/) ## Limits The performance results are specific to the workloads and comparisons described; the source does not report results across a broader set of applications. AI21 calls Teel a proof of concept, says it requires Python 3.12.13 exactly, and says CPU-bound, GIL-constrained work does not benefit from its ThreadPoolExecutor approach. The source places responsibility for the @cacheable contract on developers; it does not describe a mechanism that prevents unsafe functions from running early or having results reused. ## Open question How does Teel’s performance vary on workloads beyond the Tree of Thoughts and Deep Agents comparisons described? ## Source-stated AI21 describes Teel as an open source Python runtime that reads ahead through bytecode to dispatch independent calls with ready arguments on background threads. > a magic shadow interpreter reads ahead through your bytecode, finds calls whose arguments are already known, and dispatches them on background threads - [Supporting source](https://www.ai21.com/blog/teel-turbo-efficient-execution-library/) ## Source-stated AI21 reports an average 83% runtime reduction on Princeton’s unmodified Tree of Thoughts workload. > Average runtime reduction was 83%, from 148s down to 24s at the low end and 307s down to 38s at the high end. - [Supporting source](https://www.ai21.com/blog/teel-turbo-efficient-execution-library/) ## Source-stated In a comparison across ten mixed prompts, AI21 reports that synchronous Python under Teel averaged 58 seconds, compared with 71 seconds for async JavaScript and 150 seconds for sequential Python; it cautions that generated programs differed. > across ten mixed web-search-and-LLM prompts, 58s average against 71s for the async JS and 150s for the same Python run sequentially. - [Supporting source](https://www.ai21.com/blog/teel-turbo-efficient-execution-library/) ## Source-stated AI21 says @cacheable functions must be safe to run early, sometimes unnecessarily, and to have results reused; developers are responsible for that contract. > Each is only legal if the function does not care when it runs or how often. - [Supporting source](https://www.ai21.com/blog/teel-turbo-efficient-execution-library/) ## Source-stated AI21 identifies exact Python-version and CPU-bound workload limits for this proof of concept. > It’s pinned to Python 3.12.13 exactly, because frameinspect compiles against CPython’s internal headers. And the GIL still applies - [Supporting source](https://www.ai21.com/blog/teel-turbo-efficient-execution-library/) ## Source and contributor context Shahar Lev · Article author These are credits stated by the source; they do not establish a profile match or authorship of every passage. ## Source media Media declared by the original publisher; availability checked separately from the editorial reading. - [Figure 1: Same code, different schedule. In plain Python, each search waits for the one before it. With Teel, the three independent searches run at once, and s… · AI21](https://www.ai21.com/wp-content/uploads/2026/11/Introducing-Teel-1-1_2x-1536x713.webp) ## Terms and references Reference context selected by Escape Meridian; separate from source evidence. Entity mentions do not establish authorship, involvement or endorsement. ## CPU The central processing unit: a general-purpose processor that carries out a computer's instructions. - [Definition reference](https://aws.amazon.com/what-is/cpu/) ## AI21 AI21 publishes technical research and product announcements about its language models and AI systems. - [Explore this context](/entities/ai21) - [Reference](https://www.ai21.com/blog/) ## Editorial provenance Version 1. Publication ID: 34fce2da-c770-4097-8f43-d3ab569f19aa. Prepared by gpt-6-luna; grounding review by gpt-6-luna. Source check: uncertain by anthropic/claude-opus-5.5 on 2026-11-09T06:03:18.884Z. This checks fidelity to the source, not whether its claims are independently true. Editorial selection: accept; reasons: material\_development. Observation: a04a3f8b42852775b321f78bf20fe1573d651f70bfb83401a959306704b830d8. Source text hash: 729dcb94f8ee02c0b03fbdf7941f8d87b45e164f85824d026a7372ee898c2897. ### uncertain — 2026-11-09T06:03:18.884Z — anthropic/claude-opus-5.5 Publication: 34fce2da-c770-4097-8f43-d3ab569f19aa attribution — pass: The draft consistently attributes the runtime, its design and the benchmark claims to AI21. Performance figures are framed as AI21's reports, not as independently established facts. > Teel is an open source Python runtime that overlaps independent IO-bound calls in code you wrote sequentially. summary — uncertain: The draft accurately states what Teel is, but two gaps hurt fidelity and readability. First, it drops AI21's central argument: agent quality increasingly comes from fanning out many independent calls, and concurrency should be the runtime's job rather than something a developer or a code-writing model must hand-manage. Second, the ten-prompt comparison lacks its context. It took place inside LangChain Deep Agents, where the model writes the code. Central terms (IO-bound, bytecode, GIL, orchestration) are also left unexplained. Smallest repair: add one sentence on the agent fan-out and model-written-code motivation, and add tooltips for IO-bound and GIL. > Concurrency shouldn’t have to be part of the code a developer, or an agent, writes. It can be the runtime’s job. date — pass: originalPublished (2026-11-05T06:57:11Z, publisher page) matches the feed entry. Nothing in the text indicates an earlier first publication. support — pass: Every claim matches the source. This covers the 83% average reduction, the 58s vs 71s vs 150s figures, and the caveat about differing generated programs. It also covers the @cacheable contract, which the source makes the developer's responsibility, and the Python 3.12.13 and GIL limits. The limitations and the question do not overstate the evidence. > That is the @cacheable contract, and it is on you: no database writes, no reading the clock, no hidden state, and JSON-serializable arguments media — pass: The selected media is the verified direct link to AI21's original blog post. It is the most direct way to reach the source. ## Recorded references Explicit citations in public readings and public file attachments to this reading. Shared topics are not citations. Other artifact types need an explicit reference adapter. No public references recorded here yet. [Reference data (JSON)](/readings/b89a488a0d3d6c2f4f5795ae8dab246d7c691360c4450b8d1a7e5f89de12aeaa/references.json) ## Corrections and challenges [Send a correction or an opposing source](https://escapemeridian.com/corrections/) [JSON record](https://escapemeridian.com/readings/ai21-introduces-teel-a-python-runtime-for-overlapping-b89a488a.json)