{"id":"b89a488a0d3d6c2f4f5795ae8dab246d7c691360c4450b8d1a7e5f89de12aeaa","title":"AI21 introduces Teel, a Python runtime for overlapping independent calls","argument":"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.","topicIds":["intelligence-and-discovery","institutions-and-trust"],"domain":"science","claimType":"attributed reading","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.","speaker":{"name":"Shahar Lev","roleAtSource":"Article author"},"source":{"title":"Introducing Teel - Turbo-Efficient Execution Library for Agents (but not only) | AI21","publisher":"AI21","format":"Article","url":"https://www.ai21.com/blog/teel-turbo-efficient-execution-library/","publishedAt":"2026-11-05T06:57:11+00:00","dateBasis":"Date stated by the publisher."},"evidence":[{"text":"AI21 describes Teel as an open source Python runtime that reads ahead through bytecode to dispatch independent calls with ready arguments on background threads.","excerpt":"a magic shadow interpreter reads ahead through your bytecode, finds calls whose arguments are already known, and dispatches them on background threads","url":"https://www.ai21.com/blog/teel-turbo-efficient-execution-library/","relationship":"Source-stated"},{"text":"AI21 reports an average 83% runtime reduction on Princeton’s unmodified Tree of Thoughts workload.","excerpt":"Average runtime reduction was 83%, from 148s down to 24s at the low end and 307s down to 38s at the high end.","url":"https://www.ai21.com/blog/teel-turbo-efficient-execution-library/","relationship":"Source-stated"},{"text":"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.","excerpt":"across ten mixed web-search-and-LLM prompts, 58s average against 71s for the async JS and 150s for the same Python run sequentially.","url":"https://www.ai21.com/blog/teel-turbo-efficient-execution-library/","relationship":"Source-stated"},{"text":"AI21 says @cacheable functions must be safe to run early, sometimes unnecessarily, and to have results reused; developers are responsible for that contract.","excerpt":"Each is only legal if the function does not care when it runs or how often.","url":"https://www.ai21.com/blog/teel-turbo-efficient-execution-library/","relationship":"Source-stated"},{"text":"AI21 identifies exact Python-version and CPU-bound workload limits for this proof of concept.","excerpt":"It’s pinned to Python 3.12.13 exactly, because frameinspect compiles against CPython’s internal headers. And the GIL still applies","url":"https://www.ai21.com/blog/teel-turbo-efficient-execution-library/","relationship":"Source-stated"}],"sourceMedia":{"status":"found","sourceUrl":"https://www.ai21.com/blog/teel-turbo-efficient-execution-library/","checkedAt":"2026-11-09T06:02:26.717Z","items":[{"type":"image","url":"https://www.ai21.com/wp-content/uploads/2026/11/Introducing-Teel-1-1_2x-1536x713.webp","sourceUrl":"https://www.ai21.com/blog/teel-turbo-efficient-execution-library/","attribution":"AI21","basis":"publisher-embed","availability":"verified","label":"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…","verifiedAt":"2026-11-09T06:02:27.323Z"}],"note":"Media declared by the original publisher; availability checked separately from the editorial reading."},"assumptions":[],"openQuestion":{"attribution":"Open question","text":"How does Teel’s performance vary on workloads beyond the Tree of Thoughts and Deep Agents comparisons described?"},"whatWouldChangeView":{"attribution":"Change condition not recorded","text":""},"editorialComparisons":[],"live":{"title":"AI21 introduces Teel, a Python runtime for overlapping independent calls","summary":"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.","question":"How does Teel’s performance vary on workloads beyond the Tree of Thoughts and Deep Agents comparisons described?","claims":[{"text":"AI21 describes Teel as an open source Python runtime that reads ahead through bytecode to dispatch independent calls with ready arguments on background threads.","excerpt":"a magic shadow interpreter reads ahead through your bytecode, finds calls whose arguments are already known, and dispatches them on background threads","support":"source-stated"},{"text":"AI21 reports an average 83% runtime reduction on Princeton’s unmodified Tree of Thoughts workload.","excerpt":"Average runtime reduction was 83%, from 148s down to 24s at the low end and 307s down to 38s at the high end.","support":"source-stated"},{"text":"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.","excerpt":"across ten mixed web-search-and-LLM prompts, 58s average against 71s for the async JS and 150s for the same Python run sequentially.","support":"source-stated"},{"text":"AI21 says @cacheable functions must be safe to run early, sometimes unnecessarily, and to have results reused; developers are responsible for that contract.","excerpt":"Each is only legal if the function does not care when it runs or how often.","support":"source-stated"},{"text":"AI21 identifies exact Python-version and CPU-bound workload limits for this proof of concept.","excerpt":"It’s pinned to Python 3.12.13 exactly, because frameinspect compiles against CPython’s internal headers. And the GIL still applies","support":"source-stated"}],"limitations":["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."],"mediaId":"1892856a98a7c1f2c51d63e72a37ef7f9c5c621fe6ed20d22be3948e490b20d6","correctionReason":null,"id":"b89a488a0d3d6c2f4f5795ae8dab246d7c691360c4450b8d1a7e5f89de12aeaa","publicationId":"34fce2da-c770-4097-8f43-d3ab569f19aa","version":1,"sourceUrl":"https://www.ai21.com/blog/teel-turbo-efficient-execution-library/","sourceTitle":"Introducing Teel - Turbo-Efficient Execution Library for Agents (but not only) | AI21","publisher":"AI21","publishedAt":"2026-11-05T06:57:11+00:00","originalPublished":{"value":"2026-11-05T06:57:11+00:00","precision":"instant","basis":"publisher_page"},"firstObservedAt":"2026-11-05T10:34:19.409Z","createdAt":"2026-11-09T06:03:18.884Z","historical":true,"entityIds":["ai21"],"topicIds":["intelligence-and-discovery","institutions-and-trust"],"media":[{"id":"1892856a98a7c1f2c51d63e72a37ef7f9c5c621fe6ed20d22be3948e490b20d6","kind":"article","url":"https://www.ai21.com/blog/teel-turbo-efficient-execution-library/","sourceUrl":"https://www.ai21.com/blog/teel-turbo-efficient-execution-library/","label":"Read original","provenance":"source_link","verification":{"status":"verified","checkedAt":"2026-11-09T06:02:27.323Z","method":"acquired_source","contentType":"text/html"},"recommendationReason":"Recommended by Jev for understanding this source; checked by Luna."},{"id":"508fd586a692de8c85e6c1c13dbc195f5cce783a4ab8e06bb6773519aba3be41","kind":"image","url":"https://www.ai21.com/wp-content/uploads/2026/11/Introducing-Teel-1-1_2x-1536x713.webp","sourceUrl":"https://www.ai21.com/blog/teel-turbo-efficient-execution-library/","label":"Figure 1: Same code, different schedule. In plain Python, each search waits for the one before it. W","provenance":"publisher_page","verification":{"status":"verified","checkedAt":"2026-11-09T06:02:27.323Z","method":"publisher_association_and_head","contentType":"image/webp","cacheUntil":1794204147323},"recommendationReason":"Observed on the acquired publisher source; availability checked."}],"sourceMedia":{"status":"found","sourceUrl":"https://www.ai21.com/blog/teel-turbo-efficient-execution-library/","checkedAt":"2026-11-09T06:02:26.717Z","items":[{"type":"image","url":"https://www.ai21.com/wp-content/uploads/2026/11/Introducing-Teel-1-1_2x-1536x713.webp","sourceUrl":"https://www.ai21.com/blog/teel-turbo-efficient-execution-library/","attribution":"AI21","basis":"publisher-embed","availability":"verified","label":"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…","verifiedAt":"2026-11-09T06:02:27.323Z"}],"note":"Media declared by the original publisher; availability checked separately from the editorial reading."},"editorialDecision":{"outcome":"accept","reasonCodes":["material_development"],"rubricVersion":"stream-admission-v5","mediaId":"1892856a98a7c1f2c51d63e72a37ef7f9c5c621fe6ed20d22be3948e490b20d6","confidence":0.99,"provider":"typesafe","model":"jev-1.13.0","inputHash":"e14828863691b195fc48b2f2556c11c69fafd49dddce770418b347840c6857d3","decidedAt":"2026-11-09T06:02:30.630Z"},"provenance":{"textHash":"729dcb94f8ee02c0b03fbdf7941f8d87b45e164f85824d026a7372ee898c2897","observationId":"a04a3f8b42852775b321f78bf20fe1573d651f70bfb83401a959306704b830d8","retrievedAt":"2026-11-09T06:02:26.717Z","kind":"publisher-page","preparer":{"model":"gpt-6-luna","runId":"faad9ecf-e9f1-4f6e-8c49-15690594a059"},"reviewer":{"model":"gpt-6-luna","runId":"e244f583-72dc-46de-8d00-b6800f8d1f78"}},"audit":{"status":"uncertain","reviewedAt":"2026-11-09T06:03:18.884Z","model":"anthropic/claude-opus-5.5"},"sourceAttribution":{"authors":[{"name":"Shahar Lev","url":null,"kind":"unknown"}],"authorRole":"article-author","hosts":[],"status":"stated","authorRoster":{"truncated":false,"omitted":0,"assertionGroupsOmitted":0},"participation":[{"actor":{"name":"Shahar Lev","url":null,"kind":"unknown","actorId":null},"role":"author","scope":{"kind":"work-credit","locator":null},"literalCredit":"Shahar Lev","status":"stated","provenance":{"basis":"article-jsonld","sourceUrl":"https://www.ai21.com/blog/teel-turbo-efficient-execution-library/","locator":"document/html[1]/head[0]/script[59]@2367.@graph[0].author"},"assertionId":"9a837af1ddd0c6ca19f6e0e6b026dca3a7213f5fbe237145de8941dad42855c0:participation:0","identity":{"version":"entity-identity-v1","status":"unresolved","actorId":null,"canonicalActorId":null,"candidateActorIds":[],"assertions":[],"sourceObservedAt":"2026-11-09T06:02:26.717Z","knowledgeAsOf":null},"sourceVersion":{"snapshotId":"9a837af1ddd0c6ca19f6e0e6b026dca3a7213f5fbe237145de8941dad42855c0","sourceUrl":"https://www.ai21.com/blog/teel-turbo-efficient-execution-library/","contentSha256":"9591cd7a75ec5e94c78f1ccbe58df5b1c54c37b12668f16e90e677b7b179b303","textHash":"729dcb94f8ee02c0b03fbdf7941f8d87b45e164f85824d026a7372ee898c2897","observedAt":"2026-11-09T06:02:26.717Z"}}],"participationCoverage":{"total":2,"returned":1,"complete":false,"fullAssertions":"source-metadata-endpoint"},"distribution":null,"publisher":null,"sourceUrl":"https://www.ai21.com/blog/teel-turbo-efficient-execution-library/","snapshotId":"9a837af1ddd0c6ca19f6e0e6b026dca3a7213f5fbe237145de8941dad42855c0","contentSha256":"9591cd7a75ec5e94c78f1ccbe58df5b1c54c37b12668f16e90e677b7b179b303","textHash":"729dcb94f8ee02c0b03fbdf7941f8d87b45e164f85824d026a7372ee898c2897","observedAt":"2026-11-09T06:02:26.717Z","basis":"publisher-page-metadata","sourceLinks":16,"linksTruncated":false,"metadataUrl":"/api/pipeline/stream/b89a488a0d3d6c2f4f5795ae8dab246d7c691360c4450b8d1a7e5f89de12aeaa/source"}},"canonicalUrl":"https://escapemeridian.com/readings/ai21-introduces-teel-a-python-runtime-for-overlapping-b89a488a","formats":{"html":"/readings/ai21-introduces-teel-a-python-runtime-for-overlapping-b89a488a","markdown":"/readings/ai21-introduces-teel-a-python-runtime-for-overlapping-b89a488a.md","json":"/readings/ai21-introduces-teel-a-python-runtime-for-overlapping-b89a488a.json"},"attribution":"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.","maintainedGuideLinks":[],"readerContext":{"version":"reader-context-v1","attribution":"Reference context selected by Escape Meridian; separate from source evidence. Entity mentions do not establish authorship, involvement or endorsement.","terms":[{"id":"term-cpu","name":"CPU","explanation":"The central processing unit: a general-purpose processor that carries out a computer's instructions.","referenceUrl":"https://aws.amazon.com/what-is/cpu/"}],"entities":[{"id":"ai21","name":"AI21","kind":"organization","context":"AI21 publishes technical research and product announcements about its language models and AI systems.","referenceUrls":["https://www.ai21.com/blog/"],"path":"/entities/ai21","json":"/entities/ai21.json","markdown":"/entities/ai21.md"}]},"researchQuestions":[],"withdrawn":false,"references":{"schemaVersion":1,"target":{"type":"reading","id":"b89a488a0d3d6c2f4f5795ae8dab246d7c691360c4450b8d1a7e5f89de12aeaa","revision":"34fce2da-c770-4097-8f43-d3ab569f19aa","revisionKind":"publication-id","title":"AI21 introduces Teel, a Python runtime for overlapping independent calls","url":"https://escapemeridian.com/readings/ai21-introduces-teel-a-python-runtime-for-overlapping-b89a488a"},"source":{"type":"source","id":"https://www.ai21.com/blog/teel-turbo-efficient-execution-library/","revision":"729dcb94f8ee02c0b03fbdf7941f8d87b45e164f85824d026a7372ee898c2897","revisionKind":"sha256-source-text","title":"Introducing Teel - Turbo-Efficient Execution Library for Agents (but not only) | AI21","url":"https://www.ai21.com/blog/teel-turbo-efficient-execution-library/"},"status":"available","items":[],"next":null,"scope":"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."},"revisions":[{"id":"b89a488a0d3d6c2f4f5795ae8dab246d7c691360c4450b8d1a7e5f89de12aeaa","title":"AI21 introduces Teel, a Python runtime for overlapping independent calls","argument":"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.","topicIds":["intelligence-and-discovery","institutions-and-trust"],"domain":"science","claimType":"attributed reading","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.","speaker":{"name":"Shahar Lev","roleAtSource":"Article author"},"source":{"title":"Introducing Teel - Turbo-Efficient Execution Library for Agents (but not only) | AI21","publisher":"AI21","format":"Article","url":"https://www.ai21.com/blog/teel-turbo-efficient-execution-library/","publishedAt":"2026-11-05T06:57:11+00:00","dateBasis":"Date stated by the publisher."},"evidence":[{"text":"AI21 describes Teel as an open source Python runtime that reads ahead through bytecode to dispatch independent calls with ready arguments on background threads.","excerpt":"a magic shadow interpreter reads ahead through your bytecode, finds calls whose arguments are already known, and dispatches them on background threads","url":"https://www.ai21.com/blog/teel-turbo-efficient-execution-library/","relationship":"Source-stated"},{"text":"AI21 reports an average 83% runtime reduction on Princeton’s unmodified Tree of Thoughts workload.","excerpt":"Average runtime reduction was 83%, from 148s down to 24s at the low end and 307s down to 38s at the high end.","url":"https://www.ai21.com/blog/teel-turbo-efficient-execution-library/","relationship":"Source-stated"},{"text":"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.","excerpt":"across ten mixed web-search-and-LLM prompts, 58s average against 71s for the async JS and 150s for the same Python run sequentially.","url":"https://www.ai21.com/blog/teel-turbo-efficient-execution-library/","relationship":"Source-stated"},{"text":"AI21 says @cacheable functions must be safe to run early, sometimes unnecessarily, and to have results reused; developers are responsible for that contract.","excerpt":"Each is only legal if the function does not care when it runs or how often.","url":"https://www.ai21.com/blog/teel-turbo-efficient-execution-library/","relationship":"Source-stated"},{"text":"AI21 identifies exact Python-version and CPU-bound workload limits for this proof of concept.","excerpt":"It’s pinned to Python 3.12.13 exactly, because frameinspect compiles against CPython’s internal headers. And the GIL still applies","url":"https://www.ai21.com/blog/teel-turbo-efficient-execution-library/","relationship":"Source-stated"}],"sourceMedia":{"status":"found","sourceUrl":"https://www.ai21.com/blog/teel-turbo-efficient-execution-library/","checkedAt":"2026-11-09T06:02:26.717Z","items":[{"type":"image","url":"https://www.ai21.com/wp-content/uploads/2026/11/Introducing-Teel-1-1_2x-1536x713.webp","sourceUrl":"https://www.ai21.com/blog/teel-turbo-efficient-execution-library/","attribution":"AI21","basis":"publisher-embed","availability":"verified","label":"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…","verifiedAt":"2026-11-09T06:02:27.323Z"}],"note":"Media declared by the original publisher; availability checked separately from the editorial reading."},"assumptions":[],"openQuestion":{"attribution":"Open question","text":"How does Teel’s performance vary on workloads beyond the Tree of Thoughts and Deep Agents comparisons described?"},"whatWouldChangeView":{"attribution":"Change condition not recorded","text":""},"editorialComparisons":[],"live":{"title":"AI21 introduces Teel, a Python runtime for overlapping independent calls","summary":"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.","question":"How does Teel’s performance vary on workloads beyond the Tree of Thoughts and Deep Agents comparisons described?","claims":[{"text":"AI21 describes Teel as an open source Python runtime that reads ahead through bytecode to dispatch independent calls with ready arguments on background threads.","excerpt":"a magic shadow interpreter reads ahead through your bytecode, finds calls whose arguments are already known, and dispatches them on background threads","support":"source-stated"},{"text":"AI21 reports an average 83% runtime reduction on Princeton’s unmodified Tree of Thoughts workload.","excerpt":"Average runtime reduction was 83%, from 148s down to 24s at the low end and 307s down to 38s at the high end.","support":"source-stated"},{"text":"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.","excerpt":"across ten mixed web-search-and-LLM prompts, 58s average against 71s for the async JS and 150s for the same Python run sequentially.","support":"source-stated"},{"text":"AI21 says @cacheable functions must be safe to run early, sometimes unnecessarily, and to have results reused; developers are responsible for that contract.","excerpt":"Each is only legal if the function does not care when it runs or how often.","support":"source-stated"},{"text":"AI21 identifies exact Python-version and CPU-bound workload limits for this proof of concept.","excerpt":"It’s pinned to Python 3.12.13 exactly, because frameinspect compiles against CPython’s internal headers. And the GIL still applies","support":"source-stated"}],"limitations":["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."],"mediaId":"1892856a98a7c1f2c51d63e72a37ef7f9c5c621fe6ed20d22be3948e490b20d6","correctionReason":null,"id":"b89a488a0d3d6c2f4f5795ae8dab246d7c691360c4450b8d1a7e5f89de12aeaa","publicationId":"34fce2da-c770-4097-8f43-d3ab569f19aa","version":1,"sourceUrl":"https://www.ai21.com/blog/teel-turbo-efficient-execution-library/","sourceTitle":"Introducing Teel - Turbo-Efficient Execution Library for Agents (but not only) | AI21","publisher":"AI21","publishedAt":"2026-11-05T06:57:11+00:00","originalPublished":{"value":"2026-11-05T06:57:11+00:00","precision":"instant","basis":"publisher_page"},"firstObservedAt":"2026-11-05T10:34:19.409Z","createdAt":"2026-11-09T06:03:18.884Z","historical":true,"entityIds":["ai21"],"topicIds":["intelligence-and-discovery","institutions-and-trust"],"media":[{"id":"1892856a98a7c1f2c51d63e72a37ef7f9c5c621fe6ed20d22be3948e490b20d6","kind":"article","url":"https://www.ai21.com/blog/teel-turbo-efficient-execution-library/","sourceUrl":"https://www.ai21.com/blog/teel-turbo-efficient-execution-library/","label":"Read original","provenance":"source_link","verification":{"status":"verified","checkedAt":"2026-11-09T06:02:27.323Z","method":"acquired_source","contentType":"text/html"},"recommendationReason":"Recommended by Jev for understanding this source; checked by Luna."},{"id":"508fd586a692de8c85e6c1c13dbc195f5cce783a4ab8e06bb6773519aba3be41","kind":"image","url":"https://www.ai21.com/wp-content/uploads/2026/11/Introducing-Teel-1-1_2x-1536x713.webp","sourceUrl":"https://www.ai21.com/blog/teel-turbo-efficient-execution-library/","label":"Figure 1: Same code, different schedule. In plain Python, each search waits for the one before it. W","provenance":"publisher_page","verification":{"status":"verified","checkedAt":"2026-11-09T06:02:27.323Z","method":"publisher_association_and_head","contentType":"image/webp","cacheUntil":1794204147323},"recommendationReason":"Observed on the acquired publisher source; availability checked."}],"sourceMedia":{"status":"found","sourceUrl":"https://www.ai21.com/blog/teel-turbo-efficient-execution-library/","checkedAt":"2026-11-09T06:02:26.717Z","items":[{"type":"image","url":"https://www.ai21.com/wp-content/uploads/2026/11/Introducing-Teel-1-1_2x-1536x713.webp","sourceUrl":"https://www.ai21.com/blog/teel-turbo-efficient-execution-library/","attribution":"AI21","basis":"publisher-embed","availability":"verified","label":"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…","verifiedAt":"2026-11-09T06:02:27.323Z"}],"note":"Media declared by the original publisher; availability checked separately from the editorial reading."},"editorialDecision":{"outcome":"accept","reasonCodes":["material_development"],"rubricVersion":"stream-admission-v5","mediaId":"1892856a98a7c1f2c51d63e72a37ef7f9c5c621fe6ed20d22be3948e490b20d6","confidence":0.99,"provider":"typesafe","model":"jev-1.13.0","inputHash":"e14828863691b195fc48b2f2556c11c69fafd49dddce770418b347840c6857d3","decidedAt":"2026-11-09T06:02:30.630Z"},"provenance":{"textHash":"729dcb94f8ee02c0b03fbdf7941f8d87b45e164f85824d026a7372ee898c2897","observationId":"a04a3f8b42852775b321f78bf20fe1573d651f70bfb83401a959306704b830d8","retrievedAt":"2026-11-09T06:02:26.717Z","kind":"publisher-page","preparer":{"model":"gpt-6-luna","runId":"faad9ecf-e9f1-4f6e-8c49-15690594a059"},"reviewer":{"model":"gpt-6-luna","runId":"e244f583-72dc-46de-8d00-b6800f8d1f78"}},"audit":{"status":"uncertain","reviewedAt":"2026-11-09T06:03:18.884Z","model":"anthropic/claude-opus-5.5"},"sourceAttribution":{"authors":[{"name":"Shahar Lev","url":null,"kind":"unknown"}],"authorRole":"article-author","hosts":[],"status":"stated","authorRoster":{"truncated":false,"omitted":0,"assertionGroupsOmitted":0},"participation":[{"actor":{"name":"Shahar Lev","url":null,"kind":"unknown","actorId":null},"role":"author","scope":{"kind":"work-credit","locator":null},"literalCredit":"Shahar Lev","status":"stated","provenance":{"basis":"article-jsonld","sourceUrl":"https://www.ai21.com/blog/teel-turbo-efficient-execution-library/","locator":"document/html[1]/head[0]/script[59]@2367.@graph[0].author"},"assertionId":"9a837af1ddd0c6ca19f6e0e6b026dca3a7213f5fbe237145de8941dad42855c0:participation:0","identity":{"version":"entity-identity-v1","status":"unresolved","actorId":null,"canonicalActorId":null,"candidateActorIds":[],"assertions":[],"sourceObservedAt":"2026-11-09T06:02:26.717Z","knowledgeAsOf":null},"sourceVersion":{"snapshotId":"9a837af1ddd0c6ca19f6e0e6b026dca3a7213f5fbe237145de8941dad42855c0","sourceUrl":"https://www.ai21.com/blog/teel-turbo-efficient-execution-library/","contentSha256":"9591cd7a75ec5e94c78f1ccbe58df5b1c54c37b12668f16e90e677b7b179b303","textHash":"729dcb94f8ee02c0b03fbdf7941f8d87b45e164f85824d026a7372ee898c2897","observedAt":"2026-11-09T06:02:26.717Z"}}],"participationCoverage":{"total":2,"returned":1,"complete":false,"fullAssertions":"source-metadata-endpoint"},"distribution":null,"publisher":null,"sourceUrl":"https://www.ai21.com/blog/teel-turbo-efficient-execution-library/","snapshotId":"9a837af1ddd0c6ca19f6e0e6b026dca3a7213f5fbe237145de8941dad42855c0","contentSha256":"9591cd7a75ec5e94c78f1ccbe58df5b1c54c37b12668f16e90e677b7b179b303","textHash":"729dcb94f8ee02c0b03fbdf7941f8d87b45e164f85824d026a7372ee898c2897","observedAt":"2026-11-09T06:02:26.717Z","basis":"publisher-page-metadata","sourceLinks":16,"linksTruncated":false,"metadataUrl":"/api/pipeline/stream/b89a488a0d3d6c2f4f5795ae8dab246d7c691360c4450b8d1a7e5f89de12aeaa/source"}}}],"audits":[{"publicationId":"34fce2da-c770-4097-8f43-d3ab569f19aa","verdict":"uncertain","findings":[{"dimension":"attribution","status":"pass","explanation":"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.","excerpt":"Teel is an open source Python runtime that overlaps independent IO-bound calls in code you wrote sequentially."},{"dimension":"summary","status":"uncertain","explanation":"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.","excerpt":"Concurrency shouldn’t have to be part of the code a developer, or an agent, writes. It can be the runtime’s job."},{"dimension":"date","status":"pass","explanation":"originalPublished (2026-11-05T06:57:11Z, publisher page) matches the feed entry. Nothing in the text indicates an earlier first publication.","excerpt":null},{"dimension":"support","status":"pass","explanation":"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.","excerpt":"That is the @cacheable contract, and it is on you: no database writes, no reading the clock, no hidden state, and JSON-serializable arguments"},{"dimension":"media","status":"pass","explanation":"The selected media is the verified direct link to AI21's original blog post. It is the most direct way to reach the source.","excerpt":null}],"createdAt":"2026-11-09T06:03:18.884Z","model":"anthropic/claude-opus-5.5"}],"correctionUrl":"https://escapemeridian.com/corrections/"}