At Jetlink, our strategic goal for 2025 is to create the best enterprise AI agents in the industry, transforming how businesses operate and engage with their stakeholders.
In this guide, we share our insights and practical advice on building effective LLM agents, drawn from our experience as a solutions provider.
What Are Agents?
The term "agent" encompasses a range of definitions. For some, agents represent fully autonomous systems operating independently over extended periods, utilizing tools to accomplish complex objectives. For others, agents follow prescriptive workflows, adhering to predefined processes.
At Jetlink, we consider these variations as agentic systems but distinguish between workflows and agents:
Workflows: Systems where LLMs and tools are orchestrated through predefined code paths.
Agents: Systems where LLMs dynamically direct their processes and tool usage, maintaining control over task execution.
Below, we explore both types in detail, discussing when to use each and the trade-offs involved.
When (and When Not) to Use Agents
When developing applications with LLMs, simplicity should always be the starting point. Increased complexity should be added only when absolutely necessary. Agentic systems often trade latency and cost for improved task performance, so carefully consider whether this trade-off aligns with your goals.
Workflows excel in providing predictability and consistency for well-defined tasks. Conversely, agents are better suited for tasks requiring flexibility and scalable, model-driven decision-making. For many use cases, optimizing single LLM calls with retrieval and in-context examples is often sufficient.
Frameworks: When and How to Use Them
Numerous frameworks simplify the implementation of agentic systems, including graphical tools and APIs designed for rapid development. While these frameworks can streamline initial efforts by automating low-level tasks, they often introduce abstraction layers that can obscure the underlying prompts and responses, making debugging more difficult. They may also encourage unnecessary complexity.
Jetlink’s recommendation is to begin by directly using LLM APIs. Many patterns can be implemented with straightforward code. If frameworks are employed, ensure thorough understanding of the underlying mechanisms to avoid errors stemming from incorrect assumptions.
Building Blocks, Workflows, and Agents
This section outlines common patterns for agentic systems, progressively increasing in complexity from foundational elements to fully autonomous agents.
The Augmented LLM
The core component of any agentic system is an LLM enhanced with retrieval, tools, and memory capabilities. These augmentations allow LLMs to generate their own search queries, select tools, and determine which information to retain.
Key considerations:
Tailor augmentations to your specific use case.
Provide a clear and well-documented interface for your LLM.
Workflow: Prompt Chaining
Prompt chaining involves breaking down a task into sequential steps, where each LLM call builds upon the output of the previous one. Programmatic checks can be added at intermediate steps to maintain accuracy.
Ideal Use Case: Tasks that can be cleanly decomposed into subtasks, prioritizing accuracy over latency.
Examples:
Generating marketing copy and translating it into another language.
Creating a document outline, validating it, and then drafting the document based on the outline.
Workflow: Routing
Routing workflows classify inputs and direct them to specialized follow-up tasks. This approach separates concerns and enables specialized prompts for different input categories.
Ideal Use Case: Tasks with distinct categories requiring specialized handling, such as customer service queries.
Examples:
Sorting customer service queries into categories like general inquiries, refunds, and technical support.
Directing simple queries to cost-effective models while reserving complex ones for more capable models.
Workflow: Parallelization
Parallelization allows multiple LLMs to work on subtasks simultaneously, with results aggregated programmatically. Two key approaches include:
Sectioning: Dividing tasks into independent subtasks.
Voting: Running the same task multiple times for diverse outputs.
Ideal Use Case: Tasks that can benefit from parallel processing or require multiple perspectives for improved accuracy.
Examples:
Screening user queries while processing them simultaneously.
Evaluating model performance across different aspects or scenarios.
Workflow: Orchestrator-Workers
This workflow employs a central LLM to dynamically assign subtasks to worker LLMs and synthesize the results.
Ideal Use Case: Complex tasks with unpredictable subtasks, such as information aggregation from diverse sources.
Examples:
Coordinating changes across multiple inputs in a data management project.
Gathering and analyzing data from multiple sources.
Workflow: Evaluator-Optimizer
Here, one LLM generates outputs while another evaluates and provides feedback, creating an iterative improvement loop.
Ideal Use Case: Scenarios with clear evaluation criteria, where iterative refinement improves outcomes.
Examples:
Refining literary translations with nuanced feedback.
Conducting complex searches that require multiple iterations to achieve comprehensive results.
Agents: The Next Step
Agents represent a more advanced stage of LLM implementation, capable of autonomous operation. These systems rely on tools and environmental feedback loops, pausing for human input as necessary. Their open-ended nature makes them ideal for scaling complex tasks in trusted environments.
Key Considerations:
Design tools and interfaces thoughtfully, ensuring clear documentation.
Establish robust guardrails and test extensively in controlled environments.
Examples:
Agents performing intricate research tasks, synthesizing information from diverse sources.
Customer engagement solutions that dynamically adapt to user needs in real time.
Enterprise Applications of Agents
Jetlink’s AI agents unlock significant potential across various enterprise domains by automating and scaling tasks that were traditionally manual or highly specialized. As we aim to lead the market by 2025, these use cases highlight the transformative capabilities of our solutions:
Customer Support
Jetlink agents can transform customer service by combining conversational capabilities with seamless tool integration. These agents can:
Pull customer data, order history, and knowledge base articles.
Automate actions like issuing refunds or updating tickets.
Adapt to dynamic customer queries, offering personalized solutions.
Finance and Banking
Jetlink agents in financial institutions enable smoother operations by:
Assisting customers with account inquiries, loan applications, or transaction histories.
Providing financial recommendations tailored to user profiles.
Automating compliance checks and reporting.
Healthcare
Healthcare providers can use Jetlink agents to streamline patient interactions, including:
Answering patient inquiries and scheduling appointments.
Assisting with pre-diagnosis through symptom-checking capabilities.
Guiding users through medication management or post-treatment care.
Retail and E-Commerce
Jetlink agents in retail and e-commerce enhance user experience by:
Providing product recommendations based on browsing history and preferences.
Managing inventory queries and order tracking.
Automating responses for common customer service questions.
Human Resources
In HR, Jetlink agents simplify employee management by:
Assisting with policy queries and leave applications.
Conducting onboarding processes and collecting employee feedback.
Providing insights into training programs and development opportunities.
Combining and Customizing Patterns
The patterns described above are not rigid blueprints. Jetlink encourages developers to adapt and combine them to meet specific requirements. Always measure performance and iterate on implementations, adding complexity only when it delivers measurable benefits.
Guiding Principles for Building Effective Agents
To create reliable and maintainable agents, adhere to these principles:
Keep It Simple: Avoid unnecessary complexity in your design.
Promote Transparency: Ensure the agent’s decision-making processes are visible.
Optimize Interfaces: Craft clear and user-friendly agent-computer interfaces (ACI).
Frameworks can help you get started, but reducing abstraction layers and focusing on core components is critical for production-level reliability.
Conclusion
Success in deploying LLM agents lies in aligning their design with your needs. Start with simple prompts and single-step workflows. Gradually introduce multi-step systems only when simpler approaches prove inadequate. By following these principles and with Jetlink’s expertise, you can build agents that are both powerful and trustworthy.