A-JIT: Agentic Just-In-Time Software Construction
cs.SE · cs.AI
Quick verdict
A-JIT proposes runtime agentic software synthesis on Bosque holes; a vision paper grounded in real tooling but with zero evaluation and hand-waved safety.
Summary
This vision paper proposes Agentic Just-In-Time Software Construction (A-JIT): applications ship not as static binaries but as an assembly of code, a runtime harness, and an embedded AI agent that continuously observes usage and live execution traces and synthesizes missing implementations or new capabilities at run time, by analogy to a JIT compiler specializing machine code. The authors ground the idea in four pillars built on their own Bosque ecosystem: (1) the first-class 'hole' construct, which carries metadata such as ensures clauses, doc comments, and test input/output pairs; (2) extending lazy program completion so the Tecton framework has an LLM fabricate concrete output values under type and assertion constraints; (3) 'tactile values' in the BAPI format — human-readable, round-trippable, type-checkable program values with embedded expressions; and (4) trace-driven workflow monitoring that injects hypothetical hole functions at divergence points to cluster workflows into new RPA tools, validated in shadow mode. A weather unit-conversion example (Figs. 1–4) illustrates developer-centric and autonomous flows. The paper is purely a position piece: it contains no implementation evaluation, no user study, and no quantitative results; workflow clustering, end-user UI/UX, and the safety of runtime synthesis remain open, and the claim that generated functions are 'always safe' is unsupported. The underlying Bosque code is public on GitHub.
Review complete
Assessment at a glance
4
risk flags identified
● high 1
● medium 3
● low 0
5 strengths · 5 weaknesses · 5 author questions
AI text signal = Binoculars zero-shot detector score over 20 sampled passages (Fast-DetectGPT co-reported) — absence does not prove human authorship, and a flag does not imply misconduct.
Levels reflect verification complexity — not a quality score. Evolve never rates your paper.
Key claims under review
- Software construction can be moved into the runtime, so that applications synthesize missing implementations and new capabilities on the fly from observed usage and execution traces (§1, §7).
- Bosque's first-class hole construct, decorated with pre/postconditions, docs, and IO pairs, formalizes deferred implementation enough to make it amenable to agentic synthesis and tooling (§2).
- LLM-backed value generation via Tecton removes the manual-completion barrier that limited prior lazy program completion / prorogued programming (§3).
- BAPI 'tactile values' let humans and agents co-author program values that are round-trippable, editable, and checkable against type and structural constraints (§4).
- Trace monitoring with injected hypothetical hole functions can cluster divergent user workflows into new RPA tools whose implementations are validated in shadow mode (§5).
Strengths
Apt, well-developed central analogy
§1 and §7 map JIT compilation's runtime specialization of machine code onto runtime construction of application logic, giving the paradigm a memorable frame and a clear contrast with static AOT-style delivery.
Grounded in an existing, public substrate rather than pure speculation
The mechanisms are concrete: Bosque's ?_ hole with an ensures postcondition (Fig. 2: 'forecast.precipitation == 0.0f ==> $return.precip == none'), Tecton constrained decoding with assertion validation (§3), and BAPI tactile values with $src expressions (Fig. 4). Data Availability links the public BosqueCore repo.
Clear positioning against prior work with an identified barrier removed
Unusually candid about open problems for a vision paper
Internally consistent worked example
Weaknesses
Zero empirical evaluation
Self-citation concentration for all load-bearing components
Safety overclaim in §5
No threat model despite the design being an attack surface
Key mechanisms named but not designed
Full Review Report
$1.99 · one-timeUnlock the complete preliminary analysis Evolve produced for this paper.
Report preview
Scope & Claims
This is a vision/position paper (Onward!-style, per its ACM attribution line and the Bosque keyword) arguing that software delivery should move from pre-built artifacts to applications that construct code at run time. The authors — Mark Marron (Bosque's designer) and Earl T. Barr — define A-JIT as an application that is 'an integrated assembly comprising code, a runtime harness, and an embedded AI agent that continuously observes system usage and live execution traces.' Five claims carry the text: (1) first-class holes (§2) formalize deferred implementation with metadata — `ensures` clauses, doc comments, linked IO pairs; (2) pairing holes with LLM-backed value generation via Tecton [2] (§3) removes the manual value-authoring barrier of prorogued programming [1]; (3) BAPI 'tactile values' (§4) are human-editable, round-trippable, and type-checkable; (4) trace monitoring plus injected hypothetical hole functions (§5) can cluster divergent user workflows into new RPA tools validated in shadow mode; (5) together this is a paradigm shift analogous to JIT compilation (§1, §7). One weather-conversion example (Figs. 1–4) carries every illustration.
The remaining sections cover Methodology Assessment, Statistical Evidence, Results & Reproducibility, Limitations & Risks, and Verdict & Recommendations.
- All 5 strengths & 5 weaknesses, analyzed in detail
- 4 risk flags with severity, section & reviewer questions
- Methods & statistical evidence assessment
- 5 questions a peer reviewer would ask
- Full six-dimension evaluation report & recommendations
One-time purchase · this paper only
One-time purchase, this paper only. AI-generated preliminary analysis — not peer review.
Frequently asked questions
What is A-JIT (Agentic Just-In-Time Software Construction)?
A proposed software paradigm in which an application ships as code plus a runtime harness plus an embedded AI agent. The agent watches how the app is used and the live execution traces, then synthesizes missing implementations or new capabilities at run time — analogous to how a JIT compiler generates machine code on demand rather than ahead of time.
Is A-JIT actually implemented and evaluated?
No system is evaluated in the paper. It is a vision/position paper built on the authors' Bosque programming language (public on GitHub as BosqueCore), its 'hole' construct for marking incomplete code, the Tecton value-generation framework, and the BAPI data format. The only demonstration is a small weather unit-conversion example; there are no benchmarks, measurements, or user studies.
How is A-JIT different from AI coding assistants like Copilot?
Coding assistants generate code offline in an editor for a human to review and compile. A-JIT proposes generation inside the running application: when execution hits a deliberately placed 'hole', the runtime captures the input, reuses or generates an output value (or a full implementation) under the hole's type and contract constraints, and continues execution — adapting the app to observed user behavior.
What are the main risks of runtime code synthesis proposed in this paper?
The paper itself acknowledges workflow-clustering difficulty and end-user UI/UX challenges, but its claim that Bosque's purity features make generated functions 'always safe' is disputed in reviews: purity prevents side effects, not wrong logic or data leakage, and a system that rewrites code from user traces creates data-poisoning and prompt-injection risks that the paper does not analyze.
About this review
This is an AI-generated preliminary review by Evolve.Pub, produced from the openly available text of the paper. It is not peer review and does not represent the authors' views. The canonical record of the paper is at the publisher link above.
- PDF extraction flattened the two-column layout and figure structure, but all four code listings (Figs. 1–4) and the complete reference list [1]–[15] are present, with no truncation at the end of the text.
Go deeper on this paper
Wrote a paper? Stress-test it before reviewers do.
Upload your manuscript for the same structured scrutiny — reasoning, statistics, evidence, figures, and reproducibility.