Description:FIELD OF INVENTION
The present invention relates to the field of intelligent agent systems and prompt engineering. More Particularly, it relates to a system and method for dynamic semantic hashtag expansion in agentic instruction frameworks, thereby providing a construction of tool utilizing semantic hashtags to dynamically enhance and expand user input instructions for agentic systems powered by large language models (LLMs).

BACKGROUND
LLMs are powerful tools for various tasks as it is trained on a massive amount of text data. While LLMs are highly capable across a range of tasks, their probabilistic behaviour can make it difficult to reliably determine the correct sequence of actions needed to complete a task. Deterministic planning helps overcome this limitation by producing a fixed, repeatable sequence of steps that consistently achieves the intended result. There is a need for a method and tool that can abstract instruction sets into semantically meaningful hashtags, enhancing the performance of LLMs by providing structured, interpretable inputs leveraging the fact that increased parameterization enables more nuanced and intelligent behaviour in these models.
In the existing LLM-based systems, user instructions are typically processed as natural language prompts. While this allows for flexibility, it also introduces ambiguity, inconsistency, and limited control over how tasks are interpreted and executed. Existing approaches rely heavily on prompt engineering, but these techniques are not modular, scalable, or easily reusable across different domains or organizational contexts. These limitations highlight the need for a structured, semantically guided input mechanism that can make agentic LLM systems more interpretable, controllable, and context-aware.
Prior Arts:
US20250166102A1 discloses an AI-driven system for automated dispute resolution employing natural language processing to analyze claims and arguments, extracting semantic relationships to construct a structured data model. A reasoning module evaluates this model against a database of precedents and legal principles, generating decision scores for potential outcomes. The user interface presents visual representations of the analysis, allowing decision-makers to interactively explore and modify inputs. A decision recommendation module proposes resolutions based on criteria such as novelty, legal sufficiency, and compliance with jurisdictional laws.
202127022441 discloses a computing system that can be configured to model input that includes context data into a machine-learned model and receive model output that describes one or more semantic entities referenced by the context data. The computing system can be configured to provide data descriptive of the semantic entity or entities to the computer application(s) and receive application output(s) respectively from the computing application(s) in response to providing the data descriptive of semantic entity or entities to the computer application(s). The application output(s) received from each computer application can describe available action(s) of the corresponding computer application with respect to the semantic entity or entities. The computing system can be configured to provide at least one indicator to a user that describes the available action(s) of the corresponding computer applications with respect to the semantic entity or entities.
Whereas the first aforementioned prior art focuses on automated dispute resolution through semantic analysis of legal claims and rule-based reasoning over structured models. The second prior art detects semantic entities from input context and maps them to available application-specific actions, it remains focused on entity recognition and reactive task suggestions. None of the prior arts address the need to abstract complex instruction sets into modular, semantically meaningful tokens—such as hashtags that can guide the LLM-powered agents in a scalable, customizable, and organization-aware manner.
To overcome these drawbacks, there is a need for a novel, deterministic, tool orchestration system that can abstract complex instructions into semantically meaningful hashtags to guide, audit, and adapt LLM-powered agentic workflows in a modular, bias-aware, and context-sensitive manner.

DEFINITIONS
The expression “system” used hereinafter in this specification refers to an ecosystem comprising, but not limited to, system with input and output devices, processing unit, plurality of mobile devices or a mobile device-based application. It is extended to computing systems like mobile phones, laptops, computers, PCs, and other digital computing devices.
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 the graphs provided as output by the system.
The expression “Large Language Models” or “LLMs” used hereinafter in this specification refers to systems that use natural language understanding to interpret and generate text. In this system, they help extract features and suggest metrics.
The expression “semantic” used hereinafter in this specification refers to the meaning of a programming language construct, rather than its grammatical structure (syntax).
The expression “hashtag” used hereinafter in this specification refers to a word or phrase preceded by a hash sign (#), especially used on social media sites and applications to identify digital content on a specific topic.
The expression “semantic hashtag expansion” used hereinafter in this specification refers to the process of automatically identifying and including related hashtags to broaden the reach and relevance of a given hashtag or topic on social media; which goes beyond simple keyword matching by considering the meaning and context of hashtags, using techniques like synonym discovery and co-occurrence analysis to find hashtags with similar semantic meanings.
The expression “dockerization” used hereinafter in this specification refers to the process of packaging and distributing applications using Docker containers.
The expression “JavaScript Object Notation” or “JSON” used hereinafter in this specification refers to a lightweight data-interchange format that is easy for humans to read and write and easy for machines to parse and generate.
The expression “Single Sign-On” or “SSO” used hereinafter in this specification refers to a feature allowing users to access multiple cloud applications with a single set of login credentials, typically a username and password.
The expression “org context” or “organization context” used hereinafter in this specification refers to the organizational identity, preferences, rules, and configurations associated with a particular user or team. This context is used to customize or adapt the behavior of semantic hashtags and agentic workflows in a way that aligns with that organization’s standards. Specifically, “org context” includes user's organizational affiliation – which company, department, or project the user belongs to; based on login, email domain, or SSO.
The expression “overlay block” used hereinafter in this specification refers to a customization layer that adjusts or enhances the behavior of a semantic hashtag based on the user's organization context. It is part of the mechanism that ensures that a single hashtag like #prod-ready can behave differently for different organizations, without requiring the user to change their input.
The expression “agent instruction state” used hereinafter in this specification refers to the final, enriched, and executable directive passed to the agentic execution engine after all parsing, registry lookups, static rules, LLM expansions, and organization-specific overlays have been applied to the user's original prompt.

OBJECTS OF THE INVENTION
The primary object of the invention is to provide a system and method for dynamic hashtag expansion in agentic instruction framework.
Another object of the invention is to provide semantic hashtag abstraction that uses a single, natural-language tag with reference complex and multi-step instruction for users.
Yet another object of the invention is to provide org-aware expansion engine that uniquely adjusts behaviour based on dynamic, contextual, organization-specific overlayers without user needing to change the prompt.
Yet another object of the invention is to provide a layered prompt expansion that combines static patterns, deterministic system rules and stochastic LLM expansion to create highly reliable, dynamic instructions.
Yet another object of the invention is to provide plug-and-play extensible hashtag registry is composable and pluggable new hashtag, orgs or expansion can be added without system downline.

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 system (10) for dynamic semantic hashtag expansion in agentic instruction frameworks includes an input unit (1), a processing unit (2), and an output unit (3). The processing unit houses several critical components: a hashtag-based prompt expansion system (21) with semantic hashtags (21.1) and a hashtag registry (21.2); a dynamic organization-specific expansion module (22); and a prompt expansion workflow engine (23). The workflow engine comprises a hashtag parser (23.1), tag registry (23.2), and an overlay engine (23.3) with an org context resolver (23.3a) and org-specific overlay fetcher (23.3b). It also includes an LLM prompt constructor (23.4) and an agentic execution engine (23.5). These modules work together to translate semantic hashtags into actionable prompts customized by organizational context.
The method begins when a user inputs a query with semantic hashtags via the input unit (1). The hashtag parser (23.1) extracts tags, which are matched against the tag registry (23.2) to retrieve associated logic and templates. The base logic is expanded using static rules, system defaults, and LLM-generated content. If the user is associated with a specific organization, the org context resolver (23.3a) identifies the affiliation and the org-specific overlay fetcher (23.3b) retrieves applicable customizations. These overlays are merged with the base logic to construct a final prompt using the LLM prompt constructor (23.4). This refined prompt is executed through the agentic execution engine (23.5), and the final output is delivered to the user via the output unit (3). The workflow concludes after delivering the desired result.
The system is further enhanced by dynamic overlays that are tailored to an organization's specific needs, preferences, or compliance frameworks. These overlays allow outputs to reflect internal policies, brand voice, or regulatory standards unique to a particular entity. By combining all these layers, the framework empowers intelligent agents to generate high-quality, production-ready, and context-aware responses from concise and user-friendly prompts, making complex prompt engineering accessible and scalable for a wide range of users and industries.

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 a schematic representation of the structural and functional components of the system.
FIG.2. illustrates a system architecture overview.
FIG.3. illustrates sequence diagram.
FIG.4. illustrates flowchart.
FIG.5. illustrates registry schema and overlay composition.
FIG.6. illustrates agentic execution workflow.
FIG.7. illustrates tag conflict resolution logic.
FIG.8. illustrates dynamic tag discovery engine.

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 describes a system and method for dynamic semantic hashtag expansion in agentic instruction frameworks. The system (10) comprises of an input unit (1), a processing unit (2), comprising a hashtag-based prompt expansion system (21), a dynamic organization-specific expansion module (22), a prompt expansion workflow engine (23) further comprising hashtag parser (23.1), tag registry (23.2), or overlay engine (23.3) with an org context resolver (23.3a.), org-specific overlay fetcher (23.3b.), LLM prompt constructor (23.4), agentic execution engine (23.5), and an output unit (3); where all the structural and functional components work in co-ordination to employ a method for dynamic semantic hashtag expansion in agentic instruction frameworks.
In an embodiment of the invention, hashtag-based prompt expansion system (21) comprises two dimensions such as semantic hashtag (21.1) in which each hashtag is a semantic alias for a bundle of configuration directives that can be applied to a user prompt such that when a user inserts a plain text as “#prod-ready”, the system configures this tag to represent production-readiness standards like dockerization, CI/CD compatibility, retry logic, structured logging, and documentation requirements. Further a hashtag registry (21.2) is a structured configuration (JSON, YAML, or database table) mapping each tag to parameters like description for human-readable purpose, static prompts for concrete instruction to append, system guidelines for metadata or rules to enforce, LLM expansion directive for text that instructs the model to expand instructions meaningfully, conflict or dependency resolvers, and org-specific overlays for dynamic customization layer.
According to another embodiment of the invention, the dynamic organization-specific expansion module (22) collects data from hashtag-based prompt expansion system (21). Dynamic organization-specific expansion module (22) is unique due to its ability to dynamically adapt hashtag behaviour based on the user’s organization, derived from metadata like user identity or role, domain, project or repository context, configured org_id or embedding similarity match. Further the dynamic organization-specific expansion module (22) comprises of an org overlay engine (22.1) which acts as a middleware layer that injects organization-specific customizations into the hashtag resolution pipeline by, matching user or org context, fetching the appropriate overlay block, merging it with static and system guidelines blocks and updating prompt instruction dynamically.
In a preferred embodiment of the invention, the prompt expansion workflow engine (23) employs a method comprising the steps as follows:
- input parsing wherein the user inputs prompt with embedded hashtags;
for example:
the user inputs “create a dashboard for ticket triage from ServiceNow. #prod-ready #interservicenow”;
- tag resolution wherein the tags are resolved via registry lookup further static, system and LLM directives are loaded;
- org context detection wherein the system determines user’s org via single sign-on SSO, config, embedding-based similarity;
- overlay injection that allows merging org-specific overrides into base expansion;
- prompt construction that concatenates static prompts and LLM directives into the input prompt, further updating the agent instruction state;
- LLM expansion generates detailed execution plan/code/documentation using the augmented prompt;
- agentic execution where the agents consume expanded prompt and executed in workflow graphs (e.g., LangGraph, AutoGen, ReAct)
In yet another preferred embodiment of the invention, the prompt expansion workflow engine (23) employs a workflow as illustrated in FIG.2. comprising the steps employed by various components, as follows:
- initiating the prompt processing workflow,
- providing an input query by the user along with relevant hashtags or functionality through at least one input unit (1),
- extracting and identifying meaningful tags from the prompt using the hashtag parser (23.1),
- matching parsed hashtags against a predefined tag registry to find associated logic or templates by the tag registry (23.2),
- expanding base wherein the static, system and LLM expands the base logic using static rules, loads predefined rules and system defaults, and provides LLM-generated suggestions and system-level guidance,
- checking if the belongs to a specific organization i.e. org-affiliated by the engine (23),
- fetching org-specific overlays thereby retrieving organization-specific customizations by an org-specific overlay fetcher (23.3b.) if the user is org-affiliated,
- using base expansion only if there is no org affiliation with the user where it applies only the default base logic thereby determining the user's organization-specific settings or context by the org context resolver (23.3a.),
- merging base and org overrides thereby combining standard logic with organization-specific customizations with overlays if applicable,
- constructing a refined final expanded prompt tailored for the LLM using merged data using the LLM prompt constructor (23.4),
- sending prompt to LLM where LLM expands instruction thereby interpreting and generating instructions or output,
- executing the task using agent-based automation with the constructed prompt using agentic execution engine (23.5),
- producing and returning a final deliverable such as code or a structured action plan to the user using at least one output unit (3),
- ending the workflow.
According to yet another embodiment of the invention, the sequence of the steps as illustrated in FIG.3. is described as follows:
- user submits a prompt with hashtags,
- prompt handler fetches base tag definitions,
- prompt handler fetches organization-specific overlays,
- org overlay engine returns overlays,
- prompt handler constructs and sends an expanded prompt to the LLM engine,
- LLM engine then returns a detailed prompt response,
- prompt handler dispatches the response to an agent execution module for execution,
- agent execution module returns the final result and delivers the final result back to the user.
In yet a next embodiment of the invention, the registry schema and overlay composition as illustrated in Fig. 4. refers to a user input as “#prod-ready” which refers to a core production-ready configuration entry point such that the system provides static prompts or predefined prompts for consistent outputs; the system guidelines rules define system behavior and limitations; the LLM expansion directive instructions guide LLM’s response elaboration; the conflict resolution rules enables the system to resolve overlaps or contradictions; tag dependencies define inter-tag relationships and load order; and the org-specific overlays custom overrides tailored to organizations. Further, a sequence in a classified structure of overlay blocks by organization defines how base semantic hashtags are dynamically adapted per organization, allowing agentic systems to behave in an org-aware, consistent, and policy-compliant manner. The sequence is classified into:
- acme_inc custom settings specific to acme inc.
- logging: acmelogger acme’s custom logging configuration.
- ci/cd: acmepipeline acme’s continuous integration/deployment setup.
- globex_corp custom settings specific to globex corp.
- logging: globexlogger globex’s custom logging configuration.
- auth: globexsso globex’s single sign-on authentication setup.
In yet a next embodiment of the invention, agentic execution engine (23.5) employs a workflow as illustrated in Fig. 5. includes the steps as follows:
- providing an expanded prompt which is a detailed and clarified version of the user’s input, to the input validator node,
- checking the expanded prompt input validator node for correctness and completeness,
- breaking down the validated prompt into smaller, manageable tasks by the prompt decomposer node,
- directing each sub-task to the most appropriate specialized agent by the agent router node
- handling code-related tasks with a focus on security by the secure code agent,
- generating or updating relevant documentation for the task by the documentation agent,
- managing deployment-related operations for the request by the deployment agent,
- collecting and merging results from all agents into a unified response by the response aggregator,
- delivering the consolidated and refined answer as final output back to the user.
In yet a next embodiment of the invention, the hashtag registry (21.1) employs a tag conflict resolution logic as illustrated in fig. 6. includes the steps as follows:
- receiving the initial set of hashtags,
- checking for conflicts thereby analyzing hashtags for duplicates or contradictions,
- detecting a conflict thereby determining if any hashtag conflicts exists or not,
- continuing with the original hashtags if no conflict is found,
- applying predefined conflict resolution logic or rules if a conflict exists,
- removing or merging conflicting tags eliminates or consolidate conflicting hashtags,
- loading full tag expansion finally generating and loading a complete set of expanded tags for use.
In yet a next embodiment of the invention, dynamic tag discovery engine as illustrated in fig. 7. discloses the steps as follows:
- gathering source data including, but not limited to internal repos, docs, Jira from internal repositories, documentation, and Jira tickets,
- embedding and vectorization of text data which is converted into numerical vectors for semantic understanding,
- grouping similar content into clusters by the semantic clustering engine based on meaning,
- creating templates for hashtags based on clustered data by the hashtag template generator,
- generating potential hashtags from templates by the system and suggesting tags (e.g., #acme-helm, #vault-auth),
- reviewed and refining LLM or human validation suggested tags by a model or human expert,
- publishing the validated tags to a central repository or tag registry for consistent use.
In yet a next embodiment of the invention, the system and method of the present invention offers several advanced features that significantly enhance usability, adaptability, and scalability. one key advantage is semantic hashtag abstraction, which allows users to invoke complex, multi-step workflows through a single, intuitive natural-language tag, streamlining interaction and reducing cognitive load. complementing this is the org-aware expansion engine, which dynamically tailor responses based on organization-specific context without requiring users to modify their prompts—ensuring both personalization and operational continuity. the layered prompt expansion capability further strengthens reliability by blending static templates, deterministic system rules, and stochastic language model outputs to generate rich, contextually appropriate instructions. finally, the system supports plug-and-play extensibility through a modular hashtag registry architecture, enabling seamless integration of new hashtags, organizations, or expansion patterns without any service interruption. together, these features empower flexible, efficient, and context-sensitive AI-driven interactions.
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:We claim,
1. A system and method for dynamic semantic hashtag expansion in agentic instruction frameworks;
wherein the system (10) comprises of an input unit (1), a processing unit (2) comprising a hashtag-based prompt expansion system (21), a dynamic organization-specific expansion module (22), a prompt expansion workflow engine (23) further comprising hashtag parser (23.1), tag registry (23.2), or overlay engine (23.3) with an org context resolver (23.3a.), org-specific overlay fetcher (23.3b.), LLM prompt constructor (23.4), agentic execution engine (23.5), and an output unit (3); where all the structural and functional components work in co-ordination to employ a method for dynamic semantic hashtag expansion;

characterized in that:
the prompt expansion workflow engine (23) employs a method for dynamic semantic hashtag expansion comprising the steps of;
- initiating the prompt processing workflow,
- providing an input query by the user along with relevant hashtags or functionality through at least one input unit (1),
- extracting and identifying meaningful tags from the prompt using the hashtag parser (23.1),
- matching parsed hashtags against a predefined tag registry to find associated logic or templates by the tag registry (23.2),
- expanding base wherein the static, system and LLM expands the base logic using static rules, loads predefined rules and system defaults, and provides LLM-generated suggestions and system-level guidance,
- checking if the belongs to a specific organization i.e. org-affiliated by the engine (23),
- fetching org-specific overlays thereby retrieving organization-specific customizations by an org-specific overlay fetcher (23.3b.) if the user is org-affiliated,
- using base expansion only if there is no org affiliation with the user where it applies only the default base logic thereby determining the user’s organization-specific settings or context by the org context resolver (23.3a.),
- merging base and org overrides thereby combining standard logic with organization-specific customizations with overlays if applicable,
- constructing a refined final expanded prompt tailored for the LLM using merged data using the LLM prompt constructor (23.4),
- sending prompt to LLM where LLM expands instruction thereby interpreting and generating instructions or output,
- executing the task using agent-based automation with the constructed prompt using agentic execution engine (23.5),
- producing and returning a final deliverable such as code or a structured action plan to the user using at least one output unit (3),
- ending the workflow.

2. The system and method as claimed in claim 1, wherein the hashtag-based prompt expansion system (21) comprises a semantic hashtag (21.1) where each hashtag is a semantic alias for a bundle of configuration directives that can be applied to a user prompt such that when a user inserts a plain text as “#prod-ready”, the system configures this tag to represent production-readiness standards like dockerization, CI/CD compatibility, retry logic, structured logging, and documentation requirements.

3. The system and method as claimed in claim 1, wherein the hashtag registry (21.2) is configured for mapping each tag to parameters like description for human-readable purpose, static prompts for concrete instruction to append, system guidelines for metadata or rules to enforce, LLM expansion directive for text that instructs the model to expand instructions meaningfully, conflict or dependency resolvers, and org-specific overlays for dynamic customization layer.

4. The system and method as claimed in claim 1, wherein the agentic execution engine (23.5) employs a workflow including the steps of:

- providing an expanded prompt which is a detailed and clarified version of the user’s input, to the input validator node,
- checking the expanded prompt input validator node for correctness and completeness,
- breaking down the validated prompt into smaller, manageable tasks by the prompt decomposer node,
- directing each sub-task to the most appropriate specialized agent by the agent router node
- handling code-related tasks with a focus on security by the secure code agent,
- generating or updating relevant documentation for the task by the documentation agent,
- managing deployment-related operations for the request by the deployment agent,
- collecting and merging results from all agents into a unified response by the response aggregator,
- delivering the consolidated and refined answer as final output back to the user.

5. The system and method as claimed in claim 1, wherein the hashtag registry (21.1) employs a tag conflict resolution logic workflow including the steps of;
- receiving the initial set of hashtags,
- checking for conflicts thereby analyzing hashtags for duplicates or contradictions,
- detecting a conflict thereby determining if any hashtag conflicts exists or not,
- continuing with the original hashtags if no conflict is found,
- applying predefined conflict resolution logic or rules if a conflict exists,
- removing or merging conflicting tags eliminates or consolidate conflicting hashtags,
- loading full tag expansion finally generating and loading a complete set of expanded tags for use.

6. The system and method as claimed in claim 1, wherein dynamic tag discovery engine employs the steps of;
- gathering source data including, but not limited to internal repos, docs, Jira from internal repositories, documentation, and Jira tickets,
- embedding and vectorization of text data which is converted into numerical vectors for semantic understanding,
- grouping similar content into clusters by the semantic clustering engine based on meaning,
- creating templates for hashtags based on clustered data by the hashtag template generator,
- generating potential hashtags from templates by the system and suggesting tags,
- reviewed and refining LLM or human validation suggested tags by a model or human expert,
- publishing the validated tags to a central repository or tag registry for consistent use.

7. The system and method as claimed in claim 1, wherein the registry schema and overlay is configured to entering user input as “#prod-ready” referring to a core production-ready entry point such that the system provides static prompts predefined prompts for consistent outputs; the system guidelines rules define system behavior and limitations; the LLM expansion directive instructions guide LLM’s response elaboration; the conflict resolution rules enables the system to resolve overlaps or contradictions; tag dependencies define inter-tag relationships and load order; and the org-specific overlays custom overrides tailored to organizations.