The American Journal of Engineering and Technology
11
https://www.theamericanjournals.com/index.php/tajet
TYPE
Original Research
PAGE NO.
11-18
10.37547/tajet/Volume07Issue01-03
OPEN ACCESS
SUBMITED
20 October 2024
ACCEPTED
30 December 2024
PUBLISHED
20 January 2025
VOLUME
Vol.07 Issue01 2025
CITATION
Yury Khokhlov. (2025). Advancing operational efficiency in software
companies through generative AI. The American Journal of Engineering
and Technology, 7(01), 11
–
18.
https://doi.org/10.37547/tajet/Volume07Issue01-03
COPYRIGHT
© 2025 Original content from this work may be used under the terms
of the creative commons attributes 4.0 License.
Advancing operational
efficiency in software
companies through
generative AI
Yury Khokhlov
Engagement manager, San Francisco, California
Abstract:
Generative AI is rapidly reshaping the
landscape of software (SW) companies’ operations,
offering unprecedented capabilities for creating new
code, documentation, designs, and more. By harnessing
advanced machine learning architectures such as large
language models (LLMs), agent-based frameworks,
retrieval-augmented generation (RAG), and multimodal
systems, organizations can reduce development cycles,
improve service quality, and unlock innovative business
opportunities. Recent articles highlight how these AI-
driven approaches not only address routine tasks
—
such
as boilerplate code generation or automated testing
—
but also facilitate more complex undertakings, including
self-healing infrastructure and intelligent orchestration
of multi-step workflows. However, integrating
generative AI into software operations requires
strategic
planning
around
data
governance,
infrastructure scalability, workforce reskilling, and
ethical guardrails. This research article examines the
current applications of generative AI in software
organizations, details emerging approaches for
operational efficiency, and discusses implementation
challenges. In doing so, it presents a holistic framework
for understanding and adopting generative AI
techniques
—
ranging from code completion to
multimodal content creation
—
while emphasizing the
synergy between agent-based architectures and
retrieval-augmented
generation.
The
discussion
concludes with recommendations on how software
firms can realize long-term benefits by blending AI-
driven automation with robust oversight mechanisms,
ensuring that generative AI becomes a catalyst for
sustainable and ethical operational improvements.
Keywords:
AI and gen AI operational improvement,
software operations, code generation, agent-based AI,
RAG, multimodality.
The American Journal of Engineering and Technology
12
https://www.theamericanjournals.com/index.php/tajet
The American Journal of Engineering and Technology
Introduction:
Over the past decade, software (SW)
companies have embraced a variety of AI-driven
solutions to streamline their operations, including
predictive analytics for bug detection and machine
learning (ML) models for resource optimization [1].
Nonetheless, these earlier systems were largely
discriminative: they classified, recommended, or
predicted outcomes based on patterns in historical
data. By contrast, generative AI represents a
fundamental leap forward, enabling machines to
create novel outputs such as code snippets, text
content, images, and even entire prototypes [2]. This
shift from discriminative to generative systems has
ushered in a new wave of efficiencies and innovations
that directly impact the software development
lifecycle and operational workflows [3].
Generative
AI’s
power
comes
from
recent
improvements in advanced machine learning systems,
particularly large language models (LLMs) and
transformer networks, which have demonstrated
remarkable abilities in language understanding,
context retention, and content creation [4].
Complementing these models are agent-based
approaches that go beyond simple prompt-response
interactions to autonomously execute multi-step tasks,
and retrieval-augmented generation (RAG) methods
that ground AI outputs in relevant external or internal
knowledge bases to improve accuracy [5]. Together,
these techniques are evolving at breakneck speed,
driven by both academic research and industrial
investments in cutting-edge technologies [6-7].
In software companies, the promise of generative AI is
especially compelling:
•
Code generation can reduce redundant tasks,
such as writing boilerplate functions or setting
up project templates, thereby accelerating
development.
•
Intelligent process automation (IPA) can
orchestrate
incident
management,
infrastructure-as-code updates, and CI/CD
workflows,
reducing
downtime
and
operational overhead.
•
Multimodality allows AI systems to handle
text, images, audio, and other data types,
enabling a more seamless integration of
design, development, and documentation.
Despite these opportunities, implementing generative
AI in SW operations is not without challenges. Data
governance, version control, and IP management
become significantly more complex when AI begins
writing mission-critical code. Furthermore, ethical
considerations, including bias, model “hallucination,”
and the displacement of certain job roles, demand
thoughtful policy-making and oversight [8]. This article
aims to provide a comprehensive examination of how
generative AI can enhance operational efficiency in
software
firms,
while
also
articulating
the
considerations necessary for responsible deployment.
The sections that follow delve into current applications
of generative AI in software operations, highlight
specific approaches that promote operational gains, and
describe the synergy between agent-based systems and
RAG frameworks. We then discuss multimodality as a
rapidly emerging capability that extends AI’s reach into
design and documentation. Finally, we address key
implementation
challenges
—
ranging
from
data
governance to ethical questions
—
and conclude with
guidelines for leveraging generative AI as a sustainable
engine of operational transformation.
CURRENT APPLICATIONS OF GENERATIVE AI IN
SOFTWARE OPERATIONS
Software organizations vary widely in size, product
scope, and market focus. Nonetheless, several common
operational areas have emerged where generative AI
provides
demonstrable
value,
accelerating
development cycles and reducing repetitive work.
1.
Automated Documentation and Knowledge
Management: Large language models (LLMs)
can generate real-time documentation for APIs,
libraries, and internal best practices by
analyzing code repositories and developer
notes. This reduces the tedious task of writing
and updating docstrings, README files, and
technical manuals [3,4].
2.
Prototyping
and
Architectural
Ideation:
Generative AI can suggest novel architectures
or design patterns by learning from extensive
open-source projects. It can produce initial
prototypes
for
front-end
interfaces,
microservice interactions, or database schemas,
enabling faster feedback loops [5].
3.
Testing and Quality Assurance: From generating
test data to identifying edge cases, AI systems
use historical bug reports and telemetry data to
create robust test scenarios. They can even
propose hotfixes for minor issues, reducing
mean time to resolution (MTTR) [6].
4.
Context-Aware DevOps: Through continuous
integration/continuous
delivery
(CI/CD)
pipelines, generative AI can predict which
components are most prone to build failures,
automatically revert problematic commits, or
recommend advanced security patches [2,7].
While these examples illustrate diverse applications, a
unifying theme is operational improvement: generative
The American Journal of Engineering and Technology
13
https://www.theamericanjournals.com/index.php/tajet
The American Journal of Engineering and Technology
AI reduces friction in critical processes, freeing human
engineers to focus on more strategic or creative
aspects of software production. In the next sections,
we delve deeper into specific techniques
—
code
generation and developer support, intelligent process
automation (IPA), and more
—
that collectively reshape
SW company operations.
CODE GENERATION AND DEVELOPER SUPPORT
A revolution in code writing
Perhaps the most high-profile application of
generative AI is code generation. LLM-based coding
assistants translate natural language prompts into
functioning code in languages like Python, Java, or C#,
and can even adapt to specific frameworks. Early
adopters report that code-generation features reduce
repetitive tasks such as writing boilerplate sections,
setting
up
environment
configurations,
and
implementing common design patterns (like the
Singleton or the Factory pattern) [1]. This functionality
spares engineers from “reinventing the wheel” for
each project, which can accelerate release cycles by
weeks or even months, depending on project scope.
However, code generation isn’t solely about speed. AI
-
driven suggestions often incorporate best practices
learned from large-scale training data, potentially
guiding junior developers toward more secure or
efficient solutions [3]. That said, challenges arise
around version control, code provenance, and the AI’s
occasional production of syntactically correct but
logically flawed code. Organizations must implement
rigorous testing and review procedures to ensure that
AI-generated code meets reliability and security
standards [8].
Beyond Boilerplate: Developer Experience and
Onboarding
Generative AI also enhances the developer experience
(DX). Rather than scouring documentation or online
forums, engineers can query AI-driven assistants
directly within integrated development environments
(IDEs). These assistants offer code snippets, explain
potential errors, and even recommend library
integrations. New hires, in particular, can benefit from
real-time guidance, accelerating the onboarding
process by learning project-specific conventions
through AI-generated examples.
Moreover, developer support applications extend to
automated code reviews. Some AI tools can evaluate
code diffs for security flaws, style inconsistencies, and
potential
performance
bottlenecks,
providing
suggestions in natural language [7]. This feedback loop
shortens the time developers spend in iterative review
cycles, ultimately reducing friction and improving code
quality.
INTELLIGENT PROCESS AUTOMATION (IPA)
Rethinking traditional RPA
Generative AI significantly expands the horizons of
process automation in software operations. Traditional
robotic process automation (RPA) tools excel at rule-
based tasks
—
transferring data between systems,
generating nightly reports, or provisioning standardized
environments. However, they often stumble when
encountering ambiguous or unstructured data [2].
In contrast, generative AI can interpret partial, messy, or
dynamically changing information. By learning from
historical process logs, configuration files, and user
queries, AI models can adapt workflows in near real-
time [4]. For instance, in a scenario where a software
deployment fails due to a missing dependency, an AI
system can detect the error, generate the necessary fix
(e.g., adding the missing package), test it in a sandbox
environment, and then redeploy without human
intervention.
Incident management and Self-Healing systems
A major pain point in software operations is the
escalation process during incidents. Historically, human
operators triage tickets, attempt root-cause analysis,
and escalate to specialized teams if necessary.
Generative AI can automate large segments of incident
response:
1.
Incident Triage: By categorizing incoming alerts
and identifying patterns in log files, AI can gauge
severity and likely causes.
2.
Proactive Solutions: Some advanced models
propose patch scripts or configuration changes
that address the underlying issue, effectively
“self
-
healing” the environment.
3.
Post-Incident Documentation: The AI can
compile a post-incident report summarizing
root causes, affected services, remedial actions
taken, and any recommended follow-ups.
Such self-healing systems dramatically reduce the mean
time to resolution (MTTR), especially in global
environments that cannot afford long downtimes during
off-peak hours [6]. Nevertheless, trust is paramount.
Companies must ensure that AI systems only implement
automatic fixes if they pass validated test pipelines or if
a designated human-in-the-loop authorizes the change
[8].
APPROACHES FOR OPERATIONAL EFFICIENCY
Generative AI is not monolithic; it comprises several key
approaches that software companies can tailor to their
specific operational challenges. Below is an overview of
how these techniques align with core efficiency goals:
The American Journal of Engineering and Technology
14
https://www.theamericanjournals.com/index.php/tajet
The American Journal of Engineering and Technology
1.
Code Generation: Shortens development
timelines by automating repetitive coding
tasks, improving developer throughput.
2.
Agent-Based Frameworks: Delegates multi-
step tasks to AI “agents” that can plan,
execute, and iterate with minimal human
intervention [5].
3.
Retrieval-Augmented
Generation
(RAG):
Integrates real-time knowledge from external
or internal sources, grounding AI outputs in
the latest documentation, code repositories,
or best practices [5-6].
4.
Multimodality: Enables AI to handle text,
images, audio, or other data types
—
particularly useful in design, user experience,
and interactive documentation [9].
5.
Intelligent Automation: Augments traditional
RPA with AI-driven adaptability, assisting in
deployment pipelines, monitoring, and incident
management [2,4].
Each
approach
contributes
to
operational
improvements in unique ways, often reinforcing each
other when combined. For instance, an agent-based
generative model could call upon RAG methods to query
an internal repository of microservice configurations
before auto-deploying changes.
Table 1 provides a concise overview of these
approaches, their primary operational impacts, and
illustrative use cases within SW companies.
Table 1. Key generative AI approaches for SW companies
Approach
Description
Operational Impact
Code generation
Uses LLMs to create boilerplate or
initial versions of code
Reduces dev time; lowers human error;
accelerates release cycles
Intelligent process
automation (IPA)
AI-driven orchestration of tasks (e.g.,
incident response, IaC updates)
Decreases downtime; standardizes
processes; promotes quick recovery
Agent-based
frameworks
Autonomous agents that plan &
execute multi-step workflows
Manages complex tasks with minimal
human intervention; self-healing
RAG (retrieval-
augmented)
Combines local or external knowledge
bases with generative AI
Ensures accuracy; harnesses up-to-date
information; minimizes errors
Multimodal generation
Integrates text, images, video, audio,
or other data types
Enables holistic product design,
debugging, and documentation
AGENT-BASED ARCHITECTURES
Toward autonomous software agents
In traditional AI systems, models respond to user
prompts in a single step, generating an immediate
output. However, agent-based architectures extend
this paradigm by endowing AI entities with an internal
state and the capacity to plan and autonomously
execute tasks across multiple steps [6]. These agents
track goals, sub-goals, progress, and intermediate
results, enabling them to refine their approach
dynamically. For example, an agent might:
•
Monitor logs for performance anomalies in a
microservice.
•
Generate a script to adjust resource limits or
container configurations.
•
Test the updated configuration in a staging
environment.
•
Deploy changes to production if performance
thresholds are met.
•
Document the process in a knowledge base for
future reference.
This loop can proceed without constant human
oversight, provided there are guardrails and fail-safes.
Agent-based generative AI architectures thus hold
promise for hands-off operation of complex software
ecosystems
—
an attractive proposition for organizations
with large-scale, distributed applications that must
adapt rapidly.
Coordinating multiple agents
In more advanced settings, multiple AI agents can
coordinate or communicate with each other to
accomplish complex tasks. One agent might specialize in
analyzing logs, another in proposing code changes, and
yet another in validating or deploying updates. Through
a shared memory or message bus, these agents
collaborate, share context, and collectively handle
intricate software lifecycles [6,8]. While powerful, such
multi-agent systems raise new considerations around
concurrency, conflict resolution, and system-level
debugging. Clear orchestration protocols and fallback
mechanisms become essential to prevent emergent,
unintended behaviors.
The American Journal of Engineering and Technology
15
https://www.theamericanjournals.com/index.php/tajet
The American Journal of Engineering and Technology
RETRIEVAL-AUGMENTED GENERATION (RAG)
The RAG workflow
Retrieval-Augmented Generation (RAG) represents an
innovative strategy to mitigate the “hallucination” risk
of large language models, which sometimes invent
facts or produce code incongruent with actual project
contexts [5]. Instead of relying solely on the model’s
internal parameters, RAG retrieves the most relevant
documents or data from a specified knowledge base
—
such as a code repository, set of design docs, or an API
reference library
—
and feeds them to the model as an
expanded context for generation [5-6].
This approach keeps outputs current and domain-
specific. For instance, if a developer requests, “Show
me how to integrate our payment microservice with
the new authentication flow,” a RAG
-enabled model
can fetch the relevant microservice interface
definitions, authentication specs, and any recent
commits that might impact integration. The AI then
synthesizes this data to produce an accurate snippet of
integration code, along with suggestions for error
handling and performance tuning [2,8].
Practical benefits in SW operations
1.
Contextual code generation: RAG ensures the
AI’s outputs align with the company’s existing
codebase, library versions, and naming
conventions.
2.
Informed incident response: During outages,
the AI can query relevant system diagrams and
logs, generating fix suggestions anchored in the
actual production environment.
3.
Documentation consistency: If a feature
changes, the RAG system updates user manuals
or wiki pages by retrieving sections that
mention the feature and rewriting them in light
of the new functionality [4].
By bridging retrieval and generation, RAG endows AI
with a more “truthful” representation of a dynamic
software landscape, reducing guesswork and ensuring
alignment with up-to-date references [5].
Figure 1 (to appear at the end of this document)
sketches a conceptual pipeline for a RAG system,
illustrating how user queries, retrieval components, and
the generative model interact to produce context-
aware responses.
Figure 1. Conceptual pipeline of retrieval-augmented generation (RAG)
A schematic illustrating how user queries pass through a retrieval component before being processed by a
generative model, ensuring the model grounds its output in relevant, up-to-date knowledge.
MULTIMODALITY IN GENERATIVE AI
Moving beyond text
While the early wave of generative AI breakthroughs
focused on text and code, multimodality has
broadened the scope of what models can handle
—
integrating images, audio, video, and other data types
[9]. For software operations, this development enables:
1.
Automated UI/UX prototyping: An AI model
might generate not only the underlying code for
a front-end feature but also propose the UI
layout, colors, and icons consistent with a
design system [3].
The American Journal of Engineering and Technology
16
https://www.theamericanjournals.com/index.php/tajet
The American Journal of Engineering and Technology
2.
Image-Based debugging: Models can interpret
screenshots
of
application
errors
or
performance
dashboards,
providing
contextual suggestions for fixes alongside
textual logs [2].
3.
Video tutorials: AI can create short how-to
videos or animated step-by-step instructions
for developers or end-users, mixing text
overlays with visual demonstrations [9].
Such
multimodal
capabilities
foster
closer
collaboration
between
software
developers,
designers, and product managers, reducing back-and-
forth communication overhead and facilitating more
cohesive product experiences.
Real-World use cases
Some
software
companies
already
leverage
multimodal generative AI for tasks like:
•
Automated graphical asset generation: Tools
that produce marketing images or app icons
based on textual input describing brand
guidelines and user persona [1].
•
Voice-based debugging support: Systems
where a developer explains a problem
verbally, and the AI transcribes, analyzes, and
generates suggestions in real time [4].
•
Cross-Functional documentation: Combining
schematic diagrams, code references, and
textual explanations into a single generative
AI
–
created doc, enabling a more holistic
understanding of system architecture [6].
As the boundaries between design, development, and
deployment blur, multimodality offers a unifying
thread
—
one that generative AI can capitalize on to
deliver deeper operational insights and faster iteration
cycles.
AGENT-BASED FRAMEWORKS AND RAG APPROACH:
SYNERGY FOR SOFTWARE WORKFLOWS
Coordinating complex tasks
Combining agent-based methods with retrieval-
augmented generation (RAG) yields particularly
powerful outcomes. Consider an AI agent tasked with
monitoring a large microservices ecosystem for
performance anomalies [7]. When it detects a spike in
latency:
1.
The agent queries a knowledge base
containing relevant code modules and
infrastructure configs (RAG).
2.
It generates a potential fix
—
say, allocating
additional containers or adjusting load
balancer settings.
3.
It spawns a second agent specialized in testing,
which runs regression tests and performance
checks in a staging environment.
4.
If the fix passes, the original agent deploys it to
production. Otherwise, it reverts changes and
logs the error.
Throughout this process, the agent leverages retrieval
for contextual information and generative capabilities
for proposing code or config updates [5]. This synergy
reduces mean time to resolution (MTTR), lowers the
burden on human engineers, and fosters a “self
-
healing” operational ecosystem.
Human-in-the-Loop vs. Full Autonomy
Not all organizations are ready
—
or willing
—
to cede full
control to AI-driven agents. Many adopt a human-in-
the-loop approach, where generative AI handles the
heavy lifting, but final approvals or critical decisions
require manual review [3,8]. This model balances
efficiency with risk management, ensuring that
significant changes in a software environment aren’t
deployed blindly. As agent-based architectures mature,
we may see more fine-grained control layers, enabling
certain low-stakes tasks (e.g., updating a config file for a
minor service) to proceed autonomously while high-
impact decisions (e.g., refactoring a core library) remain
under human supervision.
IMPLEMENTATION
CHALLENGES
AND
ETHICAL
CONSIDERATIONS
Data governance and security
Generative AI models require significant amounts of
training
data,
including
proprietary
code,
documentation, and even user analytics. Companies
must establish strict governance around how this data is
collected, stored, and used [2]. Cloud infrastructures
—
often essential for scaling AI workloads
—
compound this
challenge by introducing additional points of
vulnerability. Encrypted data pipelines, role-based
access controls, and compliance checks (e.g., GDPR, SOC
2, ISO 27001) help mitigate these risks, but they add
complexity to AI deployments [8].
Code provenance and Intellectual Property (IP)
When an AI suggests or writes code, who owns it? What
if the generated snippet inadvertently contains
copyrighted content from open-source repositories that
the AI has seen during training [4]? Determining code
provenance and ensuring compliance with licensing
obligations can be tricky, especially if the model’s
training data was broad and uncurated. Clear policies
that mandate code reviews, attribution, and usage
disclaimers can reduce legal uncertainties, though there
is ongoing debate in the software community regarding
best practices [1].
The American Journal of Engineering and Technology
17
https://www.theamericanjournals.com/index.php/tajet
The American Journal of Engineering and Technology
Bias and hallucination
Generative AI models, particularly those not grounded
by RAG, can hallucinate
—
producing plausible but
incorrect or fabricated results. In coding contexts,
hallucinations might manifest as syntactically correct
but logically flawed code that fails in production [5].
Bias issues also arise if the training data includes
outdated or unrepresentative code patterns,
potentially
marginalizing
certain
development
frameworks or producing security vulnerabilities.
Regular model retraining, plus real-time retrieval of
verified data (as in RAG), offer partial solutions [6].
Workforce disruption and upskilling
A frequent concern is that automating code generation
and operational tasks will reduce the need for human
engineers [3]. While some roles
—
particularly junior or
entry-level positions focused on repetitive tasks
—
may
indeed evolve or diminish, software companies also
face a growing demand for AI-savvy engineers, data
scientists,
and
DevOps
experts
capable
of
orchestrating complex AI pipelines. Forward-looking
organizations invest in training and upskilling
programs, ensuring their workforce transitions
smoothly into roles that leverage AI rather than
compete with it [4].
Ethical AI governance
The confluence of generative AI, extensive data, and
potential autonomy necessitates robust ethical
governance frameworks [2,6]. Key elements include:
•
Transparency: Documenting how and why AI
systems make specific recommendations or
changes.
•
Accountability: Defining clear escalation paths
and responsible parties if AI-driven actions
lead to outages or data leaks.
•
Fairness:
Ensuring
that
open-source
dependencies or third-party libraries are used
appropriately and credited accurately.
•
Safety: Establishing fallback mechanisms that
prevent catastrophic failure if AI systems
behave unexpectedly [8].
By embedding these principles into the organizational
DNA, companies can confidently push the boundaries
of generative AI without jeopardizing user trust or
product integrity.
CONCLUSION
Generative AI has moved from a futuristic concept to a
practical cornerstone of operational strategy within
software companies. Its capacity to autonomously
produce code, orchestrate workflows, generate user-
facing content, and even fix issues in real-time can
radically enhance efficiency, allowing organizations to
release products faster and maintain them more
reliably. Techniques such as code generation, agent-
based architectures, retrieval-augmented generation
(RAG), and multimodality deliver complementary
benefits, transforming once-manual processes into
adaptive, intelligent pipelines.
Yet, achieving these gains requires careful forethought.
Data governance must keep pace with large-scale data
usage, version control and IP policies must address AI-
generated code, and ethical oversight must mitigate
hallucination and unintended bias. Companies must
balance autonomy with human oversight, customizing
AI adoption to align with internal risk tolerance and skill
levels.
Investing
in
workforce
development
—
particularly in roles bridging AI knowledge and software
expertise
—
ensures that human talent evolves alongside
increasingly capable machines.
Looking ahead, the synergistic convergence of agent-
based AI, real-time retrieval, and multimodal
capabilities points toward highly dynamic, self-
managing software ecosystems. As these technologies
mature, more organizations will likely gravitate toward
semi-autonomous or fully autonomous operational
models, bolstered by rigorous testing, fallback systems,
and ethical fram
eworks. Ultimately, generative AI’s true
promise lies not in supplanting human ingenuity but in
amplifying it
—
freeing developers, architects, and
product teams to focus on the next generation of
innovations that will define the software industry.
REFERENCES
1.
McKinsey & Company. (2023). How generative
AI could accelerate software product time to
market.
https://www.mckinsey.com/industries/technol
ogy-media-and-telecommunications/our-
insights/how-generative-ai-could-accelerate-
software-product-time-to-market
2.
McKinsey & Company. (2023). From promising
to productive: Real results from gen AI in
services.
https://www.mckinsey.com/capabilities/opera
tions/our-insights/from-promising-to-
productive-real-results-from-gen-ai-in-services
3.
McKinsey & Company. (2023). The economic
potential of generative AI: The next productivity
frontier.
https://www.mckinsey.com/capabilities/mckin
sey-digital/our-insights/the-economic-
potential-of-generative-ai-the-next-
productivity-frontier
4.
McKinsey & Company. (2023). Unleashing
The American Journal of Engineering and Technology
18
https://www.theamericanjournals.com/index.php/tajet
The American Journal of Engineering and Technology
developer productivity with generative AI.
https://www.mckinsey.com/capabilities/mcki
nsey-digital/our-insights/unleashing-
developer-productivity-with-generative-ai
5.
Lewis, P., Denoyer, L., & Riedel, S. (2023).
Retrieval-Augmented
Generation
for
Knowledge-Intensive NLP. Transactions of the
Association for Computational Linguistics, 6,
1
–
20.
6.
Chang, S., & Li, T. (2023). Agent-based
generative AI for software engineering.
International
Journal
of
Emerging
Technologies, 6(2), 19
–
28.
7.
Cai, Y., Wang, J., & Chen, L. (2023). AI agents
for automating multi-step tasks. Journal of AI
Research, 58(2), 110
–
119.
8.
OpenAI. (2023). GPT-4 technical report.
https://openai.com/research/gpt-4
9.
LangChain. (2023). Developer documentation.
https://github.com/hwchase17/langchain
