Source-linked AI summary
A-JIT: Agentic Just-In-Time Software Construction
Mark Marron, Earl T. Barr
TL;DR
A-JIT addresses the limits of static, preconstructed software by integrating code construction and adaptation into the runtime. The paper combines language, runtime, tactile-value, and agentic-generation mechanisms to synthesize missing behavior and specialize applications from execution and interaction traces. It presents a design space for adaptive software, while identifying manual value construction and end-user interaction design as important boundaries.
Problem
Traditional software delivery constructs code before execution and deploys it as a fixed artifact, leaving the paper to explore runtime-integrated construction and adaptation.
Method
A-JIT combines explicit code holes, runtime synthesis and testing, tactile values, and embedded agent observation to construct missing implementations and adapt applications.
Results
A-JIT detects partial implementations at runtime, reuses matching examples or generates outputs and implementations through agentic synthesis constrained by types, semantics, and assertions.
Takeaways & Limitations
A-JIT supports applications that adapt through developer or end-user interaction, including proactive workflow specialization from recurring traces.
Takeaways & Limitations
Prior lazy completion required developers to hand-craft result values, while end-user customization still requires usable interfaces for inspecting, authoring, and approving generated behavior.
Abstract
from arXiv · showhide
Traditional software delivery assumes a static paradigm: code is constructed prior to execution and deployed as a fixed artifact. We present Agentic Just-In-Time Software Construction (A-JIT), a paradigm that replaces static binaries with dynamic, software systems that can perpetually evolve to meet changing demands. In A-JIT, an application is an integrated assembly comprising code, a runtime harness, and an embedded AI agent that continuously observes system usage and live execution traces. Much like a traditional JIT compiler specializes machine code to runtime execution paths, A-JIT specializes software logic, workflows, and tool interfaces to meet the specific needs of the end-user. By integrating synthesis directly into the ambient application lifecycle, A-JIT enables applications to dynamically construct missing implementations, generate new capabilities on the fly, and continuously adapt to end-user behavior. We demonstrate how this model supports trace-driven human-AI co-construction and opens a new design space for adaptive, self-evolving software.
1 Introduction
A-JIT moves software construction into the runtime, allowing code and application behavior to be constructed as execution reveals the need. It combines language support, runtime mechanisms, and agentic generation to adapt applications to users and their interactions.
- A-JIT applies the just-in-time compiler shift to software development by constructing code during execution instead of writing all code beforehand.
- The approach combines language support for marking code intended for just-in-time construction with runtime support for constructing, running, and testing code.
- A-JIT supports a spectrum of human involvement, from developer-driven construction to systems that autonomously observe interactions and adapt behavior.
- For ambiguous spreadsheet requests, an A-JIT agent can explicitly inject an operation that triggers clarification or adaptation rather than silently assuming an interpretation.
- By integrating monitoring, response, and synthesis into the application lifecycle, A-JIT can leave broad application structure to developers while dynamically handling finer details and adaptations.
2 Code Holes
Code holes make deferred implementation explicit and machine-actionable rather than dependent on informal TODO conventions. Their metadata and examples guide synthesis while providing runtime entry points for dynamic behavior and agent collaboration.
- BOSQUE hole constructs explicitly mark incomplete code that must be filled later, replacing ad hoc TODO comments, assertions, and issue numbers.
- Hole expressions can carry types, documentation, preconditions, postconditions, and relevant input/output examples as metadata for the missing implementation.
- In the weather conversion example, an ensures clause specifies that zero precipitation in the standard Forecast maps to none in the SI representation.
- Linked input/output pairs specify expected behavior for synthesis and provide runtime hooks where agents can generate custom logic or outputs with end users.
- Treating deferred implementation as a first-class language feature formalizes the workflow, supports tool integration, and enables training data for architecture-focused AI agents.
3 Partial and Complete Implementation
A-JIT treats incomplete implementations as executable runtime hooks that can be completed from traces, generated values, constraints, and input/output pairs. The system can first produce concrete results for partial code, then synthesize a complete implementation as evidence accumulates.
- Lazy program completion lets applications run and experiment even when some function implementations remain incomplete.
- A-JIT addresses the manual effort of hand-crafting result values by using Tecton to generate concrete outputs for partial implementations.This repurposes a framework for automatically generating test and mock values.
- At runtime, A-JIT reuses matching examples or invokes Tecton and existing constraints to generate outputs or synthesize the missing function.
- When multiple plausible results exist, the system can request user guidance or explore alternative execution paths with branchable time-travel debugging.
- Tecton combines BOSQUE type and semantic constraints with constrained decoding and assertion validation to generate outputs consistent with expected structures.
- After sufficient input/output pairs are collected, strong types, semantic constraints, and examples support synthesis of a complete implementation.
4 Tactile Values
Tactile values give A-JIT a human-readable, roundtrippable representation for authoring examples and function results. BAPI combines concise editing with embedded expressions and strong structural validation, helping guide synthesis and catch inconsistent outputs.
- Tactile values support full roundtripping through a simple human-readable format, with BAPI adding standard types and embedded expression evaluation.
- Figure 4 presents a Forecast input, an expression-based ForecastSI result, and an erroneous result that violates TempRange validity conditions.
- BAPI values let developers author, edit, and test input/output examples that guide synthesis of missing implementations.
- Strong type and structural constraints validate values and catch inconsistencies such as swapped low and high temperature fields.
5 The End-User Experience: Living, Self-Specializing Software
A-JIT monitors user workflows and can proactively generate streamlined tools tailored to recurring patterns, while exposing new UI/UX challenges for end-user customization and approval.
- Workflow monitoring: A-JIT monitors workflows across users and can proactively generate RPA tools optimized for recurring workflows.The system may identify common workflows per user or across users, then construct tools for them.
- Workflow monitoring: Help-desk traces can be merged into streamlined workflows, but divergent handling makes clustering and trace-based synthesis difficult.Naive synthesis risks either proliferating overly specific workflows or producing one overly general workflow.
- Workflow synthesis: BOSQUE holes can represent hypothetical functions for workflow divergence and special cases before complete implementations are synthesized and validated.Validation can use existing traces or shadow-mode execution on new traces.
- User experience: End-user customization requires interfaces for inspecting and authoring data-results, then approving or rejecting generated implementations.Reactive UI models or moldable patterns are proposed to make these values accessible to users who may not edit raw BAPI values comfortably.
6 Related Work
Related work situates A-JIT among specification, synthesis, end-user programming, monitoring, and isolation research, while emphasizing unresolved requirements for communicating intended behavior.
- Specification and synthesis: Effective cooperation between human and AI agents remains challenged by specification and requirements gathering.The discussion highlights the need to communicate intended behavior and disambiguate requirements.
- Specification and synthesis: Prior research includes multimodal end-user programming, FlashFill, NLyze, prorogued programming, programming-language holes, typed holes, and moldable development patterns.These areas provide context for A-JIT’s use of holes and interactive specification.
- Agentic monitoring: As AI agents become more autonomous and tool-using, monitoring and isolation become increasingly important.Prior work has emphasized sandboxing and isolation to limit agentic behavior.
7 Onward!
The paper presents A-JIT as a vision for a runtime ecosystem that constructs code during execution, positioning the approach against software-engineering and agentic-system challenges.
- Vision: A-JIT is envisioned as a software ecosystem that constructs code just-in-time as execution requires it.The paper frames this as a vision for an agentic Just-In-Time Runtime.
- Vision: The authors propose that A-JIT could address challenges in the software engineering lifecycle and emerging security and coding challenges from agentic systems.This is presented as the paper’s forward-looking motivation.