Pith.

Programming Languages · arXiv:2611.21298 v1 · submitted 16 Nov 2026 · 52 references

Agent-Native by Design: A Programming Language for Agentic Applications

Jayanaka Dantanarayana, Savini Kashmira, Xiaoyu Ma, Malitha, Malitha Prabhashana, Lingjia Tang, Jason Mars

The paper says

“Building agentic applications requires combining large language model (LLM) operations, workflow structure and application state, and model-guided routing. With SDKs and agent frameworks, developers connect these components through supporting code that prepares model inputs, propagates state, and dispatches model-selected steps.”

more of the abstract

Workflow changes can require coordinated updates to this code, increasing development and testing effort. Splitting execution logic between application code and framework internals also limits compiler visibility into control flow and state dependencies, hindering automatic optimization. We introduce Agent-Native Programming, which unifies these three components with shared execution semantics. We realize this approach in Jac, a Python-superset language, through "by llm()" for typed model operations and tool use, Object-Spatial Programming for workflow structure and state, and "visit ... by llm()" for model-guided routing. The routing construct derives the model's choices from executable workflow steps and schedules the selected steps. This explicit connection between model decisions and program execution gives the compiler and runtime a common basis for dependency analysis and automatic optimization. Across five benchmarks and five baselines, Jac achieves a 1.8-8.7x reduction in AI-integration code relative to the OpenAI SDK, with competitive observed task quality and lower coding-agent development effort. Two case studies demonstrate speculative execution and service partitioning through configuration alone, using program analysis and runtime checks to preserve workflow behavior under stated conditions.

from the abstract

Pith says

Machine review · deepseek-v4-flash · 17 Nov 2026 · read the full text (108,864 characters) · not checked by a person

It can be wrong. Challenge this review or reply to it.

Holds up, with conditions. Jac unifies model operations, workflow structure, and model-guided routing in a single language, reducing AI-integration code and builder tokens, but the evaluation lacks released artifacts and independent validation of the LLM judge. This line is wrong

7 minor · 1 open question

How often objections from reviews like this one are right: not yet measured

Are you an author? What you can do.

The paper, first character to last

The reviewer was given the whole text, 108,864 characters. Not checked: figures, code, what the 52 references say.

7 minor objections

The paper says, at §3.2

Pith says: minor objection 1 of 7

The traversal semantics in Equation (3) uses 'visit [-->]' but the notation '[-->]' is not formally defined. It appears to collect successor edges, but the paper should define this operator explicitly.

The paper says, at §5.1.1

Pith says: minor objection 2 of 7

Figure 3(a) shows LOC ratios but the y-axis label is cut off in the description. The caption says 'SDK LOC divided by implementation LOC' but this is ambiguous: it could mean SDK_LOC / Jac_LOC or the inverse. The text clarifies the ratio direction, but the figure should be self-explanatory.

This objection may describe the copy Pith gave the reviewer, not the paper.

show 5 more

The paper says, at §5.1.2

Pith says: minor objection 3 of 7

The paper reports builder tokens but does not report the variance across the three independent builds. Error bars or standard deviations would help assess the reliability of the reported means.

The paper says, at §5.3.1

Pith says: minor objection 4 of 7

The speculative execution evaluation uses Jev as an auxiliary predictor but does not describe Jev's architecture, training data, or accuracy. The paper cites a blog post (almeida2026jev) but provides no details on how Jev's predictions affect the latency savings. If Jev has low accuracy, the savings may be lower in practice.

The paper says, at §5.3.2

Pith says: minor objection 5 of 7

The service partitioning case study reports builder tokens but does not describe the complexity of the prescribed services. If the services are trivial (e.g., splitting a monolith into two services), the token counts may not generalize to realistic partitioning scenarios.

The paper says, at §3.1

Pith says: minor objection 6 of 7

The 'sem' declaration syntax is shown but not formally defined. The paper says 'A sem declaration adds task intent not explicitly expressed by the function or method signature' but does not specify what forms sem can take or how it is used by the compiler.

The paper says, at §2.3

Pith says: minor objection 7 of 7

The CodeAgent example in Figure 2 (wrapfigure) is referenced but the figure is described as a wrapfigure with 0.45 textwidth. The code listing appears to be truncated in the description; the paper should ensure all code is readable.

This objection may describe the copy Pith gave the reviewer, not the paper.

Open questions (1)

Pith raised these and could not confirm them against the text of the paper it read. They are questions for the authors, not findings.

  1. §5.1.2 (Building from Requirements) and Figure 5 Pith raised a concern here that it could not check against the text of the paper it was given, so it is not published as an objection.

What would settle it

If a Jac program is found where the compiler's effect analysis incorrectly classifies a model request preparation as having no side effects (Wr(S)=∅, Ext(S)=false, Req(S)=false), and speculative execution of that preparation changes application state or triggers an unintended network call, then the central claim about safe automatic optimization would be undermined.

from Pith's summary of the paper

How the review went

5 passes by deepseek-v4-flash · 17 Nov 2026

  1. Reader holds up, with conditions confidence moderate
  2. Skeptic concern withdrawn: Pith's reviewer misread the paper 6 s · 31,091 tokens read, 527 written
  3. Referee 7 minor 14 s · 31,310 tokens read, 1,744 written
  4. Check against the paper kept 0 of 5 objections 26 s · 64,401 tokens read, 4,405 written
  5. Editor wrote the verdict above 7 s · 31,728 tokens read, 514 written

Not run on this paper: the simulated authors' defence.

Pith's passes raised 5 objections. A check against the paper's text kept 0, withdrew 4 (4 Pith's reviewer misread the paper) and left 1 as a question.

The review in full

The review in brief, machine-written

This paper introduces Agent-Native Programming, realized in the Jac language, which brings together model operations (by llm()), workflow structure (Object-Spatial Programming), and model-guided routing (visit ... by llm()) under shared execution semantics. The central idea is that expressing these three components in one language lets the compiler and runtime see the connections between model decisions, state, and control flow, enabling automatic optimizations like speculative execution and service partitioning.

The paper does several things well. The formal semantics for run(), visit, and model-guided routing are clearly specified, and Proposition 3.1 follows from the stated rules. The evaluation is broad: five benchmarks, five baselines, two coding-agent builders, and two case studies. The reported reductions in AI-integration code (1.8-8.7x vs. SDK) and builder tokens (48-51% vs. SDK) are substantial, and the speculative execution latency savings (29-39% on three benchmarks) are plausible given the mechanism described.

The soft spots are real but addressable. First, no code or data is released, so the results cannot be independently reproduced. Second, task quality for four of five benchmarks is assessed by an LLM judge (GPT-4.1-mini) without any reported inter-judge reliability or human validation. The paper acknowledges this implicitly by using SWE-bench's test-based evaluation for CodeAgent, but the other four benchmarks rely entirely on the judge. Third, the speculative execution correctness argument depends on assumptions (sound effect summaries, fair scheduling) that are stated but not empirically validated. The paper is transparent about these assumptions, but they remain unchecked.

This paper is for researchers and practitioners building agentic applications and programming-language designers interested in domain-specific abstractions for AI workflows. It deserves a serious referee: the claims are concrete, the semantics are formalized, and the evaluation, while incomplete in the ways noted, is structured and measurable. The main risk is that the LLM-judge-based quality results may not hold up under independent scrutiny.

Recommendation: send to peer review. The authors should be asked to release artifacts and provide evidence of judge reliability before acceptance.

The stress test's concern

Withdrawn: Pith's reviewer misread the paper.

The paper says

“This argument assumes sound dependency and effect summaries, including trusted declarations, and fair scheduling that prevents auxiliary work from delaying normal execution indefinitely. It also assumes that possible model responses depend only on the complete request and that extra requests change neither the outcomes nor the availability of normal requests. Under these assumptions, ignoring auxiliary requests and buffering, every optimized execution has application state changes, tool interactions, results, failures, and completion permitted by the original program.”

The referee's report

Not published. Pith's referee wrote this assessment before its objections were checked against the paper, and 4 of its 4 major objections did not survive that check.

Pith's reading of the paper (a machine's summary, not the authors')

The paper introduces Agent-Native Programming, a paradigm realized in the Jac programming language, which unifies three components of agentic AI applications—model operations, workflow structure and application state, and model-guided routing—under shared execution semantics. The authors argue that this unification eliminates the supporting code that developers must write when using SDKs or frameworks to connect these components, and it gives the compiler and runtime a holistic view of dependencies and control flow. The paper reports that expert-written Jac implementations achieve a 1.8–8.7× reduction in AI-integration code relative to the OpenAI SDK across five benchmarks, with competitive task quality. It also reports that coding agents (Claude Code and Codex) consume 48–51% fewer tokens when building applications in Jac versus the SDK. Two case studies demonstrate that the compiler can automatically apply speculative execution and service partitioning using program analysis, without changes to application code, under stated conditions.

What carries the argument. The central mechanism is the `visit ... by llm()` construct for workflow-derived model routing, which evaluates a graph expression to obtain candidate workflow nodes, sends their descriptions to a model for selection, and schedules the selected nodes for execution. This is supported by `by llm()` for typed model operations with tool use, and Object-Spatial Programming (OSP) for defining workflow structure and state via nodes, edges, and walkers. The compiler analyzes dependencies through these constructs and applies transformations like speculative execution under checked conditions.

Core claim. The paper claims that expressing model operations, workflow structure and application state, and model-guided routing in a unified language—Jac—makes the connection between model decisions and program execution explicit, eliminating the need for supporting code that translates between these components. The key mechanism is the `visit ... by llm()` construct, which derives the model's available choices from executable workflow steps and schedules the selected steps, giving the compiler and runtime a common basis for dependency analysis and automatic optimization.

The premise it rests on. The correctness of the speculative execution transformation relies on the soundness of the compiler's dependency and effect analysis, including trusted declarations for callee effects—if an effect summary misses a write or a model request, the speculative preparation could change application state or trigger a network call, violating the stated workflow-behavior preserving property.

If the paper is right (Pith's inferences, not the authors')

If Jac's approach is adopted, developers building agentic applications could write significantly less glue code for connecting LLM calls, workflow state, and routing decisions, reducing development and maintenance effort.

The unified representation could enable compilers to automatically apply optimizations like speculative execution and service partitioning across a wider range of agentic applications, without requiring manual implementation of safety checks.

The reduction in coding-agent token consumption (48–51% fewer tokens) suggests that Jac could lower the cost of using AI coding assistants to build agentic systems.

The explicit connection between model decisions and program execution could facilitate formal reasoning about agent behavior, potentially enabling verification of properties like state consistency and termination.

The paper's approach suggests a broader design principle: when a programming language makes the boundaries between AI and deterministic computation explicit, the compiler can reason about both sides together. This principle could extend beyond agentic workflows to any AI-integrated system where control flow depends on model outputs.

The speculative execution case study implies that the same dependency analysis that enables safe speculation could also support other latency-hiding techniques, such as prefetching model responses for multiple possible next steps or batching requests across parallel sub-agents.

The service partitioning case study hints at a future where deployment topology (monolith vs. microservices) is a compiler configuration rather than an architectural decision, as long as the language exposes the data and control dependencies between components.

The paper's reliance on trusted declarations for effect summaries (acknowledged in §4.3) suggests that practical adoption would require either a large library of verified summaries or a runtime verification mechanism to catch unsound assumptions.

Check this review

What was read

The passes were given all 108,864 characters of the paper's LaTeX source.

Fingerprint of that text (SHA-256): c6ca4386452d8aa2add60807e6927b9ce71f33ac9e221a5f01ecaef4e1551676

Pith does not keep that text. Rebuilt from the paper's source or PDF by the same code, it has this fingerprint if it is the same text. From a copy of Pith's code:

PYTHONPATH=. python scripts/review_input_check.py 2611.21298

The passes, in the order they ran

  1. Reader deepseek-v4-flash · medium effort · $0.0096 · instructions of the Reader, fingerprint f9ead7300382…
  2. Skeptic deepseek-v4-flash · medium effort · $0.0029 · instructions of the Skeptic, fingerprint 8f88c0f61488…
  3. Referee deepseek-v4-flash · medium effort · $0.0032 · instructions of the Referee, fingerprint a852d99aea0d…
  4. Check against the paper deepseek-v4-flash · medium effort · $0.0043 · instructions of the Check against the paper, fingerprint 6c7a6883d551…
  5. Editor deepseek-v4-flash · medium effort · $0.0030 · instructions of the Editor, fingerprint e7211f6a3d27…
  6. Summary for the page deepseek-v4-flash · medium effort · temperature 0.2 · $0.0032 · instructions of the Summary for the page, fingerprint e4f56bf568e7…

The passes cost $0.026 in model calls together.

Version stamped on this review: pith-pipeline@v1.4.1-daily-deepseek-or-medium+deepseek/deepseek-v4-flash+p.0ef1a750a3e3

Each link opens a pass's instructions as plain text, the exact bytes its fingerprint was taken over. Every stored set of instructions.

curl -s https://pith.science/methodology/prompts/f9ead730038216984cfb56d7cb34332bdf691828296a1de4245f3d6667d4bf56 | sha256sum

prints the fingerprint of the reader's instructions. The same works for every pass.

The receipt

The review's fingerprint was taken on 17 Nov 2026. The review you are reading still matches it.

Fingerprint of the review (SHA-256): 411f2cdfd65c471f4712d63833523138dc23735e06785a29cebb346c0da84109

curl -s 'https://pith.science/api/v1/verdicts/2611.21298?form=canonical' | sha256sum

prints the fingerprint of the review as it stands now. The rule, in four steps.

A matching fingerprint shows the review has not changed since that date. It does not show that the review is right.

How often reviews like this one are right

Reviews like this one: written by deepseek-v4-flash, from the paper's LaTeX source.

How often objections from reviews like this one are right: not yet measured

Every value above, in the review's public record (JSON)

Reviews by people

This review was written by a machine. No person has reviewed this paper on Pith yet. A scientist listed on Pith can review it for a fee, and their review is published here whatever it concludes.

Request a human review

How Pith checks papers · The full audit of this paper

The paper

Abstract

Building agentic applications requires combining large language model (LLM) operations, workflow structure and application state, and model-guided routing. With SDKs and agent frameworks, developers connect these components through supporting code that prepares model inputs, propagates state, and dispatches model-selected steps. Workflow changes can require coordinated updates to this code, increasing development and testing effort. Splitting execution logic between application code and framework internals also limits compiler visibility into control flow and state dependencies, hindering automatic optimization. We introduce Agent-Native Programming, which unifies these three components with shared execution semantics. We realize this approach in Jac, a Python-superset language, through "by llm()" for typed model operations and tool use, Object-Spatial Programming for workflow structure and state, and "visit ... by llm()" for model-guided routing. The routing construct derives the model's choices from executable workflow steps and schedules the selected steps. This explicit connection between model decisions and program execution gives the compiler and runtime a common basis for dependency analysis and automatic optimization. Across five benchmarks and five baselines, Jac achieves a 1.8-8.7x reduction in AI-integration code relative to the OpenAI SDK, with competitive observed task quality and lower coding-agent development effort. Two case studies demonstrate speculative execution and service partitioning through configuration alone, using program analysis and runtime checks to preserve workflow behavior under stated conditions.

The paper's own sentences, arranged, kept beside the review and separate from it. Each label is drawn from a closed vocabulary; the number beside it is the probability the classifier gave that label. No sentence in this record was written by a model.

abstract compiled · 2026-11-17

The authors' main claim, as the classifier picked it out 0.94

“Across five benchmarks and five baselines, Jac achieves a 1.8-8.7x reduction in AI-integration code relative to the OpenAI SDK, with competitive observed task quality and lower coding-agent development effort.”

How the main claim is stated: asserted 1.00

What the abstract itself states, as probabilities: claims first 0.07 · states limitation 0.32 · human participants 0.08 · controlled comparison 0.93 · randomized assignment 0.02 · states quantitative result 0.99 · compares with prior results 0.98 · mentions code or data availability 0.05

The abstract, sentence by sentence

This table labels the abstract only (arXiv listing abstract v1). The number is the probability the classifier gave the label.

SentenceRoleThe authors' own workStates the main conclusionStrength
Building agentic applications requires combining large language model (LLM) operations, workflow structure and application state, and model-guided routing. background 1.00 0.06 0.04 asserted 1.00
With SDKs and agent frameworks, developers connect these components through supporting code that prepares model inputs, propagates state, and dispatches model-selected steps. background 1.00 0.06 0.03 asserted 1.00
Workflow changes can require coordinated updates to this code, increasing development and testing effort. background 0.91 0.08 0.02 asserted 0.72
Splitting execution logic between application code and framework internals also limits compiler visibility into control flow and state dependencies, hindering automatic optimization. background 0.70 0.11 0.02 asserted 0.95
We introduce Agent-Native Programming, which unifies these three components with shared execution semantics. contribution 1.00 0.91 0.44 asserted 1.00
We realize this approach in Jac, a Python-superset language, through "by llm()" for typed model operations and tool use, Object-Spatial Programming for workflow structure and state, and "visit ... by llm()" for model-guided routing. method 0.68 0.94 0.13 asserted 1.00
The routing construct derives the model's choices from executable workflow steps and schedules the selected steps. method 0.96 0.82 0.06 asserted 1.00
This explicit connection between model decisions and program execution gives the compiler and runtime a common basis for dependency analysis and automatic optimization. interpretation 0.72 0.70 0.17 asserted 0.99
Across five benchmarks and five baselines, Jac achieves a 1.8-8.7x reduction in AI-integration code relative to the OpenAI SDK, with competitive observed task quality and lower coding-agent development effort. result 1.00 0.96 0.46 asserted 1.00
Two case studies demonstrate speculative execution and service partitioning through configuration alone, using program analysis and runtime checks to preserve workflow behavior under stated conditions. result 0.54 0.93 0.09 asserted 1.00

What kind of paper the classifier reports this is: method or tool 1.00 · evidence from observation or experiment 0.99

What was examined, and what was not

Sources read

  • arXiv listing abstract v1

Not examined

  • full text
  • figures and tables
  • references and citing sentences
  • relations to other papers

Levels run

  • P abstract

Not run

  • S sections
  • T body sentences
  • C citations
  • R cross-paper relations

How the labels were made

Compiled by classifier-1.13.0 via TypeSafe API, question bank abstract-p1-20260923, 2026-11-17: 1 request, 7,555 input tokens.

Every quoted sentence on this record is the authors'. Every label is from Pith's closed vocabulary, with the probability shown beside it. This record as JSON

Figures (12)
Figure 1 of the paper
Figure 1. An agentic workflow fragment expressed through three programming approaches. (a) Application
Figure 2 of the paper
Figure 2. CodeAgent’s workflow. The model performs the work within each workflow step with access to
Figure 3 of the paper
Figure 3. CodeAgent implemented with (a) the OpenAI SDK and (b) LangChain with LangGraph. Purple
Figure 4 of the paper
Figure 4. CodeAgent implemented in Jac. Lan￾guage constructs express model operations, workflow structure and application state, and workflow-derived model routing. Colors follow
Figure 5 of the paper
Figure 5. Compiler and runtime architecture. The compiler identifies possible code, state accesses, and
Figure 6 of the paper
Figure 6. AI-integration code in expert implementations. (a) SDK LOC divided by implementation LOC for
Figure 7 of the paper
Figure 7. Building agentic applications from requirements with Claude Code using Claude Opus 5.5 (top) and
Figure 8 of the paper
Figure 8. Mean builder tokens by activity over three independent open-design builds, summed across five
Figure 9 of the paper
Figure 9. Building agentic applications from fixed
Figure 10 of the paper
Figure 10. Task quality relative to the SDK for matched application/model pairs:
Figure 11 of the paper
Figure 11. Speculative execution across five applications. (a) Median paired routing-decision latency reduction,
Figure 12 of the paper
Figure 12. Mean builder tokens to partition an exist

Figures are the authors', reproduced from the paper.

References (52)
  1. [1] Lakshya A. Agrawal, Shangyin Tan, Dilara Soylu, Noah Ziems, Rishi Khare, Krista Opsahl-Ong, Arnav Singhvi, Herumb Shandilya, Michael J. Ryan, Meng Jiang, Christopher Potts, Koushik Sen, Alexandros G. Dimakis, Ion Stoica, Dan Klein, Matei Zaharia, and Omar Khattab. 2026. GEPA: ... on Pith
  2. [2] Diogo Almeida. 2026. Introducing System One Models & Jev. TypeSafe AI Blog. https://typesafe.ai/blog/introducing- system-one-models-and-jev Published September 15, 2026. Accessed November 12, 2026 on Pith
  3. [3] Anthropic. 2026. Claude Code: Overview. Claude Code documentation. https://code.claude.com/docs/en/overview Accessed 2026-11-12 on Pith
  4. [4] Anthropic. 2026. Introducing Claude Opus 5.5. https://www.anthropic.com/claude-opus-5-5 Published 2026-09-22; accessed 2026-11-12 on Pith
  5. [5] Anthropic. 2026. Introducing Claude Sonnet 5. https://www.anthropic.com/news/claude-sonnet-5 Published 2026-06-30; accessed 2026-11-12 on Pith
  6. [6] Luca Beurer-Kellner, Marc Fischer, and Martin Vechev. 2023. Prompting Is Programming: A Query Language for Large Language Models.Proceedings of the ACM on Programming Languages7, PLDI (2023), 1946–1969. doi:10.1145/3591300 on Pithdoi:10.1145/3591300
  7. [7] Mikhail Bogdanov. 2026. How Much Code Do Developers Really Let Agents Write? JetBrains Research. https: //blog.jetbrains.com/research/2026/08/how-much-code-do-developers-really-let-agents-write/ Accessed November 7, 2026 on Pith
  8. [8] Ching-An Cheng, Allen Nie, and Adith Swaminathan. 2024. Trace is the Next AutoDiff: Generative Optimization with Rich Feedback, Execution Traces, and LLMs. InAdvances in Neural Information Processing Systems, Vol. 37. https:// proceedings.neurips.cc/paper_files/paper/2024/hash... on Pith
  9. [9] CrewAI. 2026. CrewAI: Multi-Agent Automation Framework. GitHub repository. https://github.com/crewAIInc/crewAI Accessed: 2026-09-14 on Pith
  10. [10] CrewAI. 2026. CrewAI Skills. GitHub repository. https://github.com/crewAIInc/skills Accessed 2026-11-12 on Pith
  11. [11] CrewAI. 2026. Meeting Assistant Flow. CrewAI Examples, software repository. https://github.com/crewAIInc/crewAI- examples/tree/main/flows/meeting_assistant_flow Accessed: 2026-10-29 on Pith
  12. [12] Jayanaka Dantanarayana, Savini Kashmira, Lingjia Tang, and Jason Mars. 2026. SIGIL: Skill Compilation for Reliable and Efficient Agent Execution. arXiv:2607.27309 [cs.SE] doi:10.48550/arXiv.2607.27309 on PithPith's reviewarXivdoi:10.48550/arxiv.2607.27309
  13. [13] Jayanaka L. Dantanarayana, Yiping Kang, Kugesan Sivasothynathan, Christopher Clarke, Baichuan Li, Savini Kashmira, Krisztián Flautner, Lingjia Tang, and Jason Mars. 2025. MTP: A Meaning-Typed Language Abstraction for AI-Integrated Programming.Proceedings of the ACM on Programm... on Pithdoi:10.1145/3763092
  14. [14] Honghua Dong, Qidong Su, Yubo Gao, Zhaoyu Li, Yangjun Ruan, Gennady Pekhimenko, Chris J. Maddison, and Xujie Si. 2025. APPL: A Prompt Programming Language for Harmonious Integration of Programs and Large Language Model Prompts. InProceedings of the 63rd Annual Meeting of the A... on Pithdoi:10.18653/v1/2025.acl-long.63
  15. [15] Paul Furgale, Severin Klingler, James Nolan, Matt Staats, Gaia Di Lorenzo, Elisa Martinez Abad, Christian Schüller, Razvan Dinu, Alessio Devoto, Pascal Berard, Gal Kaplun, Elad Sarafian, Riccardo Roveri, Leon Derczynski, and Ricardo Silveira Cabral. 2026. NVIDIA-labs OO Agents... on PithPith's reviewarXiv
  16. [16] Dawei Gao, Zitao Li, Xuchen Pan, Weirui Kuang, Zhijian Ma, Bingchen Qian, Fei Wei, Wenhao Zhang, Yuexiang Xie, Daoyuan Chen, Liuyi Yao, Hongyi Peng, Zeyu Zhang, Lin Zhu, Chen Cheng, Hongzhu Shi, Yaliang Li, Bolin Ding, and Jingren Zhou. 2024. AgentScope: A Flexible yet Robust ... on PithPith's reviewarXiv
  17. [17] Sanjay Ghemawat, Robert Grandl, Srdjan Petrovic, Michael Whittaker, Parveen Patel, Ivan Posva, and Amin Vahdat on Pith
  18. [18] Google DeepMind. 2026. Gemma 4 Model Card. Google AI for Developers. https://ai.google.dev/gemma/docs/core/ model_card_4 Accessed 2026-11-12 on Pith
  19. [19] Zijian He, Reyna Abhyankar, Vikranth Srivatsa, and Yiying Zhang. 2025. Cognify: Supercharging Gen-AI Workflows With Hierarchical Autotuning. InProceedings of the 31st ACM SIGKDD Conference on Knowledge Discovery and Data Mining V.2 (KDD ’25). Association for Computing Machiner... on Pithdoi:10.1145/3711896.3736884
  20. [20] Intertwine. 2026. DSPy Agent Skills. GitHub repository. https://github.com/intertwine/dspy-agent-skills Community- maintained skill collection; accessed 2026-11-12 on Pith
show 32 more
  1. [21] Jaseci Labs. 2026. Jac-GPT: A Documentation Assistant for Jac. Agentic-AI software repository. https://github.com/ jaseci-labs/Agentic-AI/tree/main/jac-gpt-fullstack Accessed: 2026-10-29 on Pith
  2. [22] Carlos E. Jimenez, John Yang, Alexander Wettig, Shunyu Yao, Kexin Pei, Ofir Press, and Karthik Narasimhan. 2024. SWE-bench: Can Language Models Resolve Real-World GitHub Issues?. InInternational Conference on Learning Representations. https://arxiv.org/abs/2310.06770 on PithPith's reviewarXiv
  3. [23] Savini Kashmira, Jayanaka Dantanarayana, Thamirawaran Sathiyalogeswaran, Krisztian Flautner, Lingjia Tang, and Jason Mars. 2025. GraphMend: Code Transformations for Fixing Graph Breaks in PyTorch 2. arXiv:2509.16248 [cs.PL] doi:10.48550/arXiv.2509.16248 Accepted for publicatio... on PithPith's reviewarXivdoi:10.48550/arxiv.2509.16248
  4. [24] Omar Khattab, Arnav Singhvi, Paridhi Maheshwari, Zhiyuan Zhang, Keshav Santhanam, Sri Vardhamanan A, Saiful Haq, Ashutosh Sharma, Thomas Joshi, Hanna Moazam, Heather Miller, Matei Zaharia, and Christopher Potts. 2024. DSPy: Compiling Declarative Language Model Calls into State... on Pith
  5. [25] Sehoon Kim, Suhong Moon, Ryan Tabrizi, Nicholas Lee, Michael W. Mahoney, Kurt Keutzer, and Amir Gholami. 2024. An LLM Compiler for Parallel Function Calling. InProceedings of the 41st International Conference on Machine Learning (Proceedings of Machine Learning Research, Vol. ... on Pith
  6. [26] LangChain. 2026. Agents. LangChain Documentation. https://docs.langchain.com/oss/python/langchain/agents Accessed: 2026-11-10 on Pith
  7. [27] LangChain. 2026. Graph API Overview. LangChain Documentation. https://docs.langchain.com/oss/python/langgraph/ graph-api Accessed November 12, 2026 on Pith
  8. [28] LangChain. 2026. LangChain Skills. GitHub repository. https://github.com/langchain-ai/langchain-skills Accessed 2026-11-12 on Pith
  9. [29] LangChain. 2026. LangChain: The Platform for Reliable Agents. GitHub repository. https://github.com/langchain- ai/langchain Accessed: 2026-11-13. Jac for Agentic AI 23 on Pith
  10. [30] LangChain. 2026. LangGraph: Low-Level Orchestration Framework for Building Stateful Agents. GitHub repository. https://github.com/langchain-ai/langgraph Accessed: 2026-09-14 on Pith
  11. [31] Chaofan Lin, Zhenhua Han, Chengruidong Zhang, Yuqing Yang, Fan Yang, Chen Chen, and Lili Qiu. 2024. Parrot: Efficient Serving of LLM-based Applications with Semantic Variable. In18th USENIX Symposium on Operating Systems Design and Implementation (OSDI 24). USENIX Association,... on Pith
  12. [32] Michael Luo, Xiaoxiang Shi, Colin Cai, Tianjun Zhang, Justin Wong, Yichuan Wang, Chi Wang, Yanping Huang, Zhifeng Chen, Joseph E. Gonzalez, and Ion Stoica. 2026. Agentix: An Efficient Serving Engine for LLM Agents as General Programs. In23rd USENIX Symposium on Networked Syste... on Pith
  13. [33] Xiaoyu Ma, Jayanaka L. Dantanarayana, Savini Kashmira, Baichuan Li, Lingjia Tang, and Jason Mars. 2026. MORTIS: Compiler-Guided KV-Cache Management for LLM Agent Programs. arXiv:2611.08638 [cs.OS] https://arxiv.org/abs/ 2611.08638 on PithPith's reviewarXiv
  14. [34] Douwe Maan, David Sanchez, Aditya Vardhan, David Montague, Marcelo Trylesinski, Alex Hall, and Samuel Colvin on Pith
  15. [35] Jason Mars. 2025. Object-Spatial Programming. arXiv:2503.15812 [cs.PL] doi:10.48550/arXiv.2503.15812 on PithPith's reviewarXivdoi:10.48550/arxiv.2503.15812
  16. [36] João Moura. 2026. CrewAI + LangGraph: Email Automation Example. CrewAI Examples, software repository. https://github.com/crewAIInc/crewAI-examples/tree/main/integrations/CrewAI-LangGraph Accessed: 2026-10-29 on Pith
  17. [37] NVIDIA. 2026. Coding-Agent Skills for Authoring NVIDIA-labs Object Oriented Agents. GitHub repository, skills directory. https://github.com/NVIDIA-NeMo/labs-OO-Agents/blob/main/skills/README.md Accessed 2026-11-12 on Pith
  18. [38] OpenAI. 2026. Codex CLI. GitHub repository. https://github.com/openai/codex Accessed 2026-11-12 on Pith
  19. [39] OpenAI. 2026. GPT-4.1 mini Model. OpenAI API documentation. https://developers.openai.com/api/docs/models/gpt- 4.1-mini Accessed 2026-11-12 on Pith
  20. [40] OpenAI. 2026. Models. OpenAI API documentation. https://developers.openai.com/api/docs/models Accessed 2026-11-12 on Pith
  21. [41] OpenAI. 2026. OpenAI Python API Library. GitHub repository. https://github.com/openai/openai-python Accessed: 2026-10-29 on Pith
  22. [42] Zaifeng Pan, Ajjkumar Patel, Zhengding Hu, Yipeng Shen, Yue Guan, Wan-Lu Li, Lianhui Qin, Yida Wang, and Yufei Ding. 2025. KVFlow: Efficient Prefix Caching for Accelerating LLM-Based Multi-Agent Workflows. arXiv:2507.07400 [cs.DC] https://arxiv.org/abs/2507.07400 on PithPith's reviewarXiv
  23. [43] Xin Tan, Yimin Jiang, Yitao Yang, and Hong Xu. 2025. Towards End-to-End Optimization of LLM-based Applications with Ayo. InProceedings of the 30th ACM International Conference on Architectural Support for Programming Languages and Operating Systems, Volume 2 (ASPLOS ’25). Asso... on Pithdoi:10.1145/3676641
  24. [44] wassim249. 2026. YT Navigator: AI-Powered YouTube Content Explorer. Software repository. https://github.com/ wassim249/YT-Navigator Accessed: 2026-10-29 on Pith
  25. [45] Qingyun Wu, Gagan Bansal, Jieyu Zhang, Yiran Wu, Beibin Li, Erkang Zhu, Li Jiang, Xiaoyun Zhang, Shaokun Zhang, Jiale Liu, Ahmed Hassan Awadallah, Ryen W. White, Doug Burger, and Chi Wang. 2024. AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversations. InConfe... on Pith
  26. [46] Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik R. Narasimhan, and Yuan Cao. 2023. ReAct: Synergizing Reasoning and Acting in Language Models. InInternational Conference on Learning Representations. https://arxiv.org/abs/2210.03629 on PithPith's reviewarXiv
  27. [47] Naimeng Ye, Arnav Ahuja, Georgios Liargkovas, Yunan Lu, Kostis Kaffes, and Tianyi Peng. 2026. Speculative Actions: A Lossless Framework for Faster AI Agents. InInternational Conference on Learning Representations. https: //openreview.net/forum?id=P0GOk5wslg on Pith
  28. [48] Z.ai. 2026. GLM-5.3: Frontier Coding with Emergent Cyber Capabilities. https://z.ai/blog/glm-5.3 Accessed 2026-11-12 on Pith
  29. [49] Jiayi Zhang, Jinyu Xiang, Zhaoyang Yu, Fengwei Teng, Xiong-Hui Chen, Jiaqi Chen, Mingchen Zhuge, Xin Cheng, Sirui Hong, Jinlin Wang, Bingnan Zheng, Bang Liu, Yuyu Luo, and Chenglin Wu. 2025. AFlow: Automating Agentic Workflow Generation. InInternational Conference on Learning ... on Pith
  30. [50] Lianmin Zheng, Liangsheng Yin, Zhiqiang Xie, Chuyue Sun, Jeff Huang, Cody Hao Yu, Shiyi Cao, Christos Kozyrakis, Ion Stoica, Joseph E. Gonzalez, Clark Barrett, and Ying Sheng. 2024. SGLang: Efficient Execution of Structured Language Model Programs. InAdvances in Neural Informa... on Pith
  31. [2023] Towards Modern Development of Cloud Applications. InProceedings of the 19th Workshop on Hot Topics in Operating Systems (HotOS ’23). Association for Computing Machinery, 110–117. doi:10.1145/3593856.3595909 on Pithdoi:10.1145/3593856.3595909
  32. [2026] Pydantic AI. Software repository. https://github.com/pydantic/pydantic-ai Accessed: 2026-11-11 on Pith

Challenges and discussion

Disagree with the review, or know something it missed? Leave a comment, or challenge this review formally: a challenge becomes a permanent entry in this paper's record, and its decision is published here.

No comments yet.

Sign in to comment