Description:FIELD OF INVENTION
The present invention relates to debugging systems for software. More Particularly, it relates to a plugin system and method for inline real-time debugging for LLM and agentic applications in integrated development environment.

BACKGROUND
The process of identifying and resolving errors or bugs in a software system, commonly referred to as debugging is a critical aspect of software development, ensuring quality, performance, and user satisfaction. Debugging is crucial for LLMs and agentic application to ensure they function correctly, reliably and as intended. It involves identifying, analyzing and removing errors or bugs, which are especially important in complex, models like LLMs. Debugging techniques help refine prompts, optimize agent workflow and improve overall system performance.
Debugging Large Language Model (LLM) and agentic applications presents unique challenges compared to traditional software. These stem from inherent stochasticity of LLMs, complex control flows and the need to debug interaction with external tool and memory stores. Existing debugging methods often fall short in providing the necessary visibility and control for these evolving systems. Conventional debuggers were designed for deterministic, imperative codebases. They lack the observability, flexibility and interactivity required for modern application driven by LLMs or multi-agent workflows, where state is often represented in embeddings, asynchronous chains or model-inferred variables.
PRIOR ART
202241058134 discloses a system and method that relates in general, to a means to debug a processor. In particular, the present disclosure relates to a means to debug a processor efficiently and quickly in real-time through a low bandwidth interface by removing configurable skip list functions and loops. In an aspect, the invention provides a system for real-time debugging of a processor. The first set of instructions includes any one or a combination of a set of function calls and a set of jump instructions.
US10530802B2 discloses system and method of detecting malicious software (malware) that includes receiving a file and storing a memory baseline for a system. The method also includes copying the file to the system, executing the file on the system, terminating operation of the system, and storing a post-execution memory map. The method further includes analyzing the memory baseline and the post-execution memory map and determining that the file includes malware.
Although the prior art describes that a system and a method for real-time debugging of a processor. The system includes a debugging unit configured to receive a first set of instructions from the processor. The first set of instructions includes a set of function calls and/or a set of jump instructions. The debugging unit further includes a skip list unit including a skip set of instructions. The skip list unit is configured to remove, from the first set of instructions, the skip set of instructions to generate a second set of instructions. A method of detecting malicious software (malware) includes receiving a file and storing a memory baseline for a system. The method also includes copying the file to the system, executing the file on the system, terminating operation of the system, and storing a post-execution memory map.
Debugging such applications typically requires multiple cycles of returns with different inputs, leading to high inefficiency, especially when tuning prompts, memory contexts or agent behaviors. The present invention overcomes the aforementioned drawbacks by providing a real-time, inline debugging system capable of adapting to such complexity and allowing mid-execution parameter mutation without restarting the application. The invention provides an advanced inline debugging plugin integrated with development environment, enabling real-time inspection and modification.

DEFINITIONS:
The expression “system” used hereinafter in this specification refers to an ecosystem comprising, but is not limited to a system with a user, input and output devices, plugin devices, processing unit, plurality of mobile devices, a display unit and output; and is extended to computing systems like mobile, laptops, computers, PCs, etc.
The expression “input unit” used hereinafter in this specification refers to, but is not limited to, mobile, laptops, computers, PCs, keyboards, mouse, pen drives or drives.
The expression “output unit” used hereinafter in this specification refers to, but is not limited to, an onboard output device, a user interface (UI), a display unit, a local display, a screen, a dashboard, or a visualization platform enabling the user to visualize output provided by the system.
The expression “plugin device” refers to an extension that gets linked to any developer environment or application that provide the necessary support for a work. In this context, it refers to a device or module that enables the debugging feature used herein.
The expression “processing unit” refers to, but is not limited to a processor of at least one computing device that optimizes the system, and acts as the functional unit of the system.
The expression “user” used hereinafter in this specification refers to, but is not limited to any person such as a code developer, analyst, manager or any such person who understand what the code is doing, inspects variables, function calls, or data being processed, or identifies bugs or unexpected behavior.
The expression “large language model (LLM)” used hereinafter in this specification refers to a type of machine learning model designed for natural language processing tasks such as language generation. LLMs are language models with many parameters, and are trained with self-supervised learning on a vast amount of text. In this system, they help extract features and suggest metrics.
The term “Integrated Development Environment” (IDE) used hereinafter in this specification refers to a mobile device-based application that provides a comprehensive environment for software development, combining various tools into a single, user-friendly interface.
The term “debugging” used hereinafter in this specification refers, is the process of finding, isolating, and correcting errors (or "bugs") in software code.
The term “mutation” is an application testing technique used to evaluate the effectiveness of a test suite by intentionally introducing small changes (mutations) to the code.
The term “precomputation” used hereinafter in this specification refers to, is a software testing technique used to evaluate the effectiveness of a test suite by intentionally introducing small changes (mutations) to the code.
The term “breakpoints” used hereinafter in this specification refers to a marker set on a specific line of code where the user wants the program to pause execution during debugging, such that when the debugger hits that line while running the program, it stops and allows the user to inspect the state of the application at that moment.
The term “watch expressions” used hereinafter in this specification refers to a variable or expression that instructs the debugger to monitor continuously a program is running or paused; to check how its value changes in real-time during program execution.
The term “embeddings” used hereinafter in this specification refers to a fixed-length array of numbers (a vector) that encodes the meaning of text, allowing LLMs and related systems to compare similarities between texts, retrieve relevant documents, perform reasoning or classification, power search, recommendations, and clustering.
The term “prompts” used hereinafter in this specification refers to a problem statement or question that serves as a starting point for developers to create solutions thereby acting as a bridge for communication between users and computers, prompts provide an interactive space for command execution and data exchange.
The term “tokenized prompt” used hereinafter in this specification refers to a version of a text prompt that has been converted into tokens which are the basic units of meaning used by a Large Language Model (LLM) to process input.
The term “embedding diff” used hereinafter in this specification refers to a comparison between two embeddings (i.e. vector representations of text) to measure how much the meaning or semantics have changed between them.

OBJECTS OF THE INVENTION:
The primary object of the present invention is to provide a plugin system and method for inline real-time debugging for LLM and agentic applications in integrated development environment.
Another object of the present invention is to provide a plugin system and method an integrated system that hooks into integrated development environment (IDE) debuggers.
Yet another object of the present invention is to is to provide a plugin system and method which traces execution of LLM/agentic pipelines.
Yet another object of the present invention is to provide a plugin system and method that displays token-level and semantic runtime data.
Yet another object of the present invention is to provide a plugin system and method that enables real-time modification of inputs, prompts, parameters and agents.
Yet another object of the present invention is to provide a plugin system and method that visualizes the effect of change immediately via re-evaluation of only affected subgraphs.
Yet another object of the present invention is to provide a plugin system and method that uses a delta trace engine for efficient state management and selective precomputation.
Yet another object of the present invention is to provide plugin system and method that supports scalability across multi-agent, multi-threaded workflow with caching and dependency graphs.

SUMMARY
Before the present invention is described, it is to be understood that the present invention is not limited to specific methodologies and materials described, as these may vary as per the person skilled in the art. It is also to be understood that the terminology used in the description is for the purpose of describing the particular embodiments only and is not intended to limit the scope of the present invention.
The invention discloses to a plugin system and method for inline real-time debugging for LLM and agentic applications in integrated development environment (IDE); comprising an input device, a plugin device, and an output device; wherein the plugin device includes an execution hook layer, a state inspector panel, an interactive parameter editor, a delta trace engine, and a checkpoint system; interacting in a sequential and integrated manner to facilitate real-time, in-context debugging of LLM workflows.
In an aspect, the method for inline debugging begins with the user initializing the plugin in the IDE, which then hooks into the execution lifecycle of the LLM or agentic framework. As the user steps through the code, the execution hook layer captures live runtime data, which is passed to the state inspector panel for real-time, editable display. Users can interactively modify prompts and parameters using the parameter editor, which triggers selective re-execution using the delta trace engine. This engine identifies affected nodes based on a dependency graph and recomputes only those, greatly improving efficiency. The system supports dynamic propagation of changes mid-execution and provides real-time output display with comparison capabilities. The checkpoint system captures serialized execution states, allowing users to rewind, fork, or replay executions.
In yet another aspect, the system and method provide a range of advanced features to streamline LLM debugging including live parameter mutation for real-time changes to model settings, side-by-side result comparison, a prompt token visualizer for examining tokenized inputs, and agent path debugging to trace agent decisions. It also offers real-time embedding diffs to monitor changes in vector representations and a snap-back state function to restore any previous checkpoint with a click. By enabling selective re-execution and maintaining stateful checkpoints, the system reduces iteration time, enhances developer control, and significantly improves the debugging experience in complex LLM-driven environments.

BRIEF DESCRIPTION OF DRAWINGS
A complete understanding of the present invention may be made by reference to the following detailed description which is to be taken in conjugation with the accompanying drawing. The accompanying drawing, which is incorporated into and constitutes a part of the specification, illustrates one or more embodiments of the present invention and, together with the detailed description, it serves to explain the principles and implementations of the invention.
FIG.1. illustrates the structural and functional components of the system.
FIG.2. illustrates the schematic of the arrangement and workflow of different components of the plugin system.
FIG. 3. illustrates the stepwise method for inline real-time debugging.

DETAILED DESCRIPTION OF INVENTION:
Before the present invention is described, it is to be understood that this invention is not limited to methodologies described, as these may vary as per the person skilled in the art. It is also to be understood that the terminology used in the description is for the purpose of describing the particular embodiments only and is not intended to limit the scope of the present invention. Throughout this specification, the word “comprise”, or variations such as “comprises” or “comprising”, will be understood to imply the inclusion of a stated element, integer or step, or group of elements, integers or steps, but not the exclusion of any other element, integer or step, or group of elements, integers or steps. The use of the expression “at least” or “at least one” suggests the use of one or more elements or ingredients or quantities, as the use may be in the embodiment of the invention to achieve one or more of the desired objects or results. Various embodiments of the present invention are described below. It is, however, noted that the present invention is not limited to these embodiments, but rather the intention is that modifications that are apparent are also included.
The present invention discloses a plugin system and method for inline real-time debugging for LLM and agentic applications in integrated development environment, that revolutionizes the way developers debug, test, and iterate on AI-driven code. The system (1) comprises of at least one input device (2), a plugin device (3) further comprising of various modules including an execution hook layer (4), a state inspector panel (5), an interactive parameter editor (6), a delta trace engine (7) and a checkpoint system (8), and at least one output device (9); wherein the various modules work in a sequential manner thereby enabling a method/workflow for inline real-time debugging.
In an embodiment of the invention, the plugin device is structured into five core components; wherein the execution hook layer (4) integrates with the language runtime and integrated development environment (IDE) debugger protocol, such that it captures breakpoints, watch expressions, stack, and context including LLM prompt strings and embeddings. Further, the state inspector panel (5) refers to a custom panel within the integrated development environment (IDE) graphical user interface (GUI) that displays the real-time values of inputs, prompts, model parameters, agent context, intermediate LLM output such as tokens, attention weights, etc.
In a next embodiment, the interactive parameter editor (6) allows the user to interactively change values (like prompts or settings) while the program is running; wherein the inline editable fields are input fields that support the dropdowns (for common types including the list of preset options) or sliders for adjusting numeric values like temperature, token limits; both the options directly visible and editable in the IDE. Further, the interactive parameter editor (6) automatically identifies the part of the code that needs to be edited depending on the selected parameter, and then re-executes only that selective part of the code.
In a preferred embodiment, the delta trace engine (DTE) (7) is the most crucial component that maintains dependency graph of all steps, including LLM prompts, input encodings, and agent outputs. Further, the DTE (7) tracks changes in context and maps them to specific function calls or prompts; and recomputes only the affected downstream nodes, saving compute time and cost. Further, the checkpoint system (8) takes snapshot of the entire system state at a particular moment during execution; wherein it takes the snapshot of the serialized runtime states including model seeds, agent states, memory buffers which enables jumping between known states or “replaying with mutation or modifications”. This enables rollback and replay, mutation testing where the system is allowed to different paths, and stateful debugging similar to that in complex simulations.
In yet another embodiment, the serialized runtime states include the model seed which refers a random seed used to control stochastic processes in the LLM or agent system, to ensure reproducibility of results in generation, sampling, or randomness-based decisions. It allows replaying from a checkpoint with the same seed ensuring identical outputs; whereas changing the seed is similar to running the same logic with different randomness also referred to as “mutated replay.” Further, the agent state captures everything about the agent’s internal logic and context at a moment in time; including the current step or subgoal it is working on, memory or context window history, reasoning stack if multi-step reasoning is involved, an internal control flow flags or decisions made. In an agentic system, agent state is critical to replaying reasoning chains or resuming after a pause. Furthermore, the memory buffer refers to temporary or working memory the system or agent uses during execution, including, but not limited to token-level context buffer, intermediate outputs or scratchpad notes, input or output history, cached vector embeddings, search results or tool outputs.
In a next preferred embodiment of the invention, the method for inline real-time debugging for LLM and agentic applications in integrated development environment; wherein the method comprises the steps as follows:
 The user initializes the plugin system, such that the plugin is loaded directly into integrated development environment (IDE) such as, but not limited to VSCode, Eclipse, IntelliJ, PyCharm, Xcode, preferably VScode.
 The plugin system then hooks into the execution lifecycle of LLM pipelines and agentic frameworks.
 Then, as the user steps through the code, the execution hook layer captures live runtime data including, but not limited to prompts, hyperparameters, model outputs, agent decisions, and memory buffers.
 The said live runtime data is then passed to the state inspector panel.
 The state inspector panel then displays the values in an intuitive and editable format.
 The interactive parameter editor then allows the users to edit parameters and prompts on the fly.
 The interactive parameter editor then instantly triggers a selective re-execution of only the impacted components using the delta trace engine.
 The delta trace engine precisely identifies a dependency-aware graph of execution and selectively recomputes only the affected nodes in the computational flow; thereby avoiding full reruns and dramatically reducing iteration time.
 The plugin then enables a dynamic change propagation, where mid-execution user adjustments or changes are automatically validated and applied.
 The outputs are displayed using at least one output device in real-time with an additional side-by-side comparisons of before-and-after outputs.
 The checkpoint system works in tandem thereby preserving and managing serialized snapshots of execution states including, but not limited to agent behavior trees, model embeddings, and prompt chains.
 The checkpoint system allowing developers to rewind, fork, or replay executions for experimentation and version control, thereby making the system highly interactive is especially innovative in the context of LLM and agentic debugging.
In a next embodiment of the invention, the system and method disclose significant features such as live parameter mutation that allows a change model temp, prompts, agent rules mid-execution, the side-by-side result view which allows comparison of outputs before and after changes, the prompt token visualizer which enables to view tokenized prompt with highlighting, the agent path debugging enables the user to visualize the decision tree of agent actions, the real-time embedding diff that compares the vector state before and after mutations, the snap-back state allows restoring any previous checkpoint with a single click.
Advantages:
The present system and method transform the runtime inspection into a live experimentation environment, thereby enhancing productivity as well as making the debugging closer to the creative, fluid process of AI application design, ushering in a new paradigm for intelligent development environments. Further, the system and method use hashed caching of node outputs for fast retrieval, parallelizes independent subgraph evaluation, and batches LLM calls thereby sending multiple requests together to LLM where structurally identical prompts exist; thereby making the system and method scalable.

While considerable emphasis has been placed herein on the specific elements of the preferred embodiment, it will be appreciated that many alterations can be made and that many modifications can be made in preferred embodiment without departing from the principles of the invention. These and other changes in the preferred embodiments of the invention will be apparent to those skilled in the art from the disclosure herein, whereby it is to be distinctly understood that the foregoing descriptive matter is to be interpreted merely as illustrative of the invention and not as a limitation.
, Claims:CLAIMS:
We claim,
1. A plugin system and method for inline real-time debugging for LLM and agentic applications in integrated development environment; comprising of an input device (2), a plugin device (3) further comprising of an execution hook layer (4), a state inspector panel (5), an interactive parameter editor (6), a delta trace engine (7) and a checkpoint system (8), and an output device (9); wherein the various modules work in a sequential manner thereby enabling a method for inline real-time debugging;

characterised in that:
the method includes the steps of;
 initializing the plugin system by the user thereby loading the plugin directly into integrated development environment (IDE);
 hooking the plugin system into the execution lifecycle of LLM pipelines and agentic frameworks;
 stepping through the code by the user;
 capturing live runtime data by the execution hook layer;
 passing the live runtime data to the state inspector panel;
 displaying the values in an intuitive and editable format by the state inspector panel;
 allowing the users to edit parameters and prompts on the fly using the interactive parameter editor;
 triggering a selective re-execution of only the impacted components instantly by the interactive parameter editor by using the delta trace engine;
 identifying a dependency-aware graph of execution and selective recomputing only the affected nodes in the computational flow by the delta trace engine precisely, thereby avoiding full reruns and dramatically reducing iteration time;
 enabling a dynamic change propagation by the plugin, thereby validating and applying the mid-execution user adjustments or changes automatically;
 displaying the outputs using at least one output device in real-time with an additional side-by-side comparisons of before-and-after outputs;
 preserving and managing serialized snapshots of execution states by the checkpoint system that works in tandem;
 allowing the developers to rewind, fork, or replay executions using the checkpoint system for experimentation and version control, thereby making the system highly interactive in the context of LLM and agentic debugging.

2. The system and method as claimed in claim 1, wherein the execution hook layer (4) integrates with the language runtime and integrated development environment (IDE) debugger protocol, such that it captures breakpoints, watch expressions, stack, and context including LLM prompt strings and embeddings.

3. The system and method as claimed in claim 1, wherein the state inspector panel (5) refers to a custom panel within the integrated development environment (IDE) graphical user interface (GUI) that displays the real-time values of inputs, prompts, model parameters, agent context, intermediate LLM output such as tokens, attention weights, etc.

4. The system and method as claimed in claim 1, wherein the interactive parameter editor (6) allows the user to interactively change values inline; such that the inline editable fields are input fields that support the dropdowns or sliders for adjusting numeric values like temperature, token limits; directly visible and editable in the IDE; thereby automatically identifying the part of the code that needs to be edited depending on the selected parameter, and re-executes only that selective part.

5. The system and method as claimed in claim 1, wherein the delta trace engine (DTE) (7) maintains dependency graph of all steps, including LLM prompts, input encodings, and agent outputs; tracks changes in context and maps them to specific function calls or prompts; and recomputes only the affected downstream nodes, saving compute time and cost.

6. The system as claimed in claim 1, wherein the checkpoint system (8) takes snapshot of the serialized runtime states including prompts, model seeds, model outputs, agent states, agent decisions, and memory buffers which enables jumping between states or replaying with mutation; and of execution states including agent behavior trees, model embeddings, and prompt chains.

7. The system and method as claimed in claim 1, wherein the memory buffer refers to temporary or working memory the system or agent uses during execution, including, but not limited to token-level context buffer, intermediate outputs or scratchpad notes, input or output history, cached vector embeddings, search results or tool outputs.

8. The system and method as claimed in claim 1, wherein the system enlists features such as-
- live parameter mutation that allows a change model temp, prompts, agent rules mid-execution,
- the side-by-side result view which allows comparison of outputs before and after changes,
- the prompt token visualizer which enables to view tokenized prompt with highlighting,
- the agent path debugging enables the user to visualize the decision tree of agent actions,
- the real-time embedding diff that compares the vector state before and after mutations, and
- the snap-back state allows restoring any previous checkpoint with a single click.
Dated this 07th day of July, 2025.