Software that evolves itself to fit user needs in real time
A-JIT: Agentic Just-In-Time Software Construction
Software EngineeringArtificial Intelligence
Summary
Most software is fixed before you use it and can’t easily change to fit how you actually use it. The authors present a new idea called A-JIT that builds software that keeps changing and improving while you use it. A-JIT uses an AI agent inside the software to watch how you work and then creates new features or improves existing ones automatically. This way, the software adapts specifically for each user, much like how some programs optimize themselves while running. The authors show how this method can make software that is more flexible and continually customizes itself with the help of AI.
What this means in practice
- •For enterprise software developers: Build business applications that automatically add new features and tailor workflows based on how employees actually use the software in real time.
- •For robotics system builders: Enable robots to adapt their control software continuously by generating new behaviors as they interact with changing environments.
Authors
Mark Marron, Earl T. Barr
Abstract
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.