Joget AI Agent Builder - Best Practices for prompting and coming up with agents

Overview

The Joget AI Agent Builder makes it possible for non-developers to create “agentic” AI tools, which are agents that understand natural language, make decisions, and execute multi-step tasks without writing code. Refer to Joget AI Agent Builder for more information.

This document explains what a non-technical user should know when building agents: how to write good prompts, structure tasks and workflows, avoid common pitfalls, and ensure agents are reliable, maintainable, and useful.

What is Joget AI Agent Builder

• The Builder is a visual, no-code/low-code interface: you design agents by dragging & dropping components, prompts, tools, and enhancers, instead of coding. (Joget, n.d.)
• An agent built with Joget has two main parts:
  • A Prompt (what the agent is told to do),
  • A Tool (optional external action, e.g., API call, search, email),
  • An Enhancer (optional post-processing, saving outputs, formatting). (Relinns, n.d.)

1. 1. 1. Define Agent: Where you choose the underlying LLM (e.g., GPT) and set default instructions or prompts. (Joget, n.d.)
      2. Task Setup:  Where you define what the agent does via one or more sequential tasks. Each task may include:

• Once tasks are defined, you can test the agent in a built-in Preview mode, simulate inputs, inspect outputs, debug, and refine before deploying. (Joget, n.d.)
• Agents can be embedded into existing workflows or business applications in Joget, e.g., HR onboarding, customer support, supply chain alerts, enabling departments beyond IT to benefit from AI automation. (Joget, n.d.)

Why “Prompting” & “Design” Matter (Not Just LLMs)

Many think building an AI agent is just “give a prompt to the model”. In truth, good agents need more than a prompt. For agents to work reliably:

• Prompts must be clear, unambiguous, and structured so the LLM knows exactly what to do. Vague instructions easily produce unpredictable or inconsistent outputs. (DEV Community)
• Agents often perform multi-step workflows, call external tools/APIs, and handle branching logic. That requires good orchestration around prompts — defining tasks, tool usage, fallbacks, output formatting, error handling, etc. (not just a single “one-shot” prompt) (Joget)
• Because of this complexity, designing agents needs deliberate planning, testing, iterations, and governance (who reviews, what is allowed, when human-in-the-loop is required). Joget supports human oversight via structured workflow integration. (PR Newswire)

In short, prompts are important — but they are only one part of building a robust AI agent. The way tasks are composed, tools used, results handled, and workflows governed matters equally (if not more).

Best Practices for Prompting & Agent Design with Joget (for Non-Technical Users)

Here are recommended best practices (adapted from industry-wide prompt-engineering and agent design guidance) that work especially well when using Joget AI Agent Builder.

1. Be Clear, Specific, and Structured in Prompts

• Write prompts as explicit instructions, not vague or conversational suggestions. For example:
  

  You are a customer support assistant. When given a ticket description, determine whether it is a billing issue, technical issue, or general query. If billing — extract customer ID and invoice number (if provided). If technical — list possible causes. If general — ask a clarifying question.

• Avoid ambiguous phrasing; define objectives, constraints, tone, output format (e.g., “Answer in bullet points”, “Keep tone formal and concise”, “If data not found, say: ‘Information not available.’”). This helps the LLM behave consistently. (Lookfor)
• For complex tasks, encourage the agent to “think step-by-step” (chain-of-thought prompting): ask it to break down reasoning before giving final answers (“First check X, then Y, then decide”). This often yields more logical, accurate results. (VoiceInfra)

2. Use Role-Based or Persona-Based Prompting Where Relevant

Assigning the agent a role or identity (e.g., “legal advisor”, “HR assistant”, “supply-chain controller”) helps guide its responses appropriately. It lends context, shapes tone, and improves relevance. (FreeCodeCamp)

This is especially useful in business settings via Joget: e.g., if building an HR onboarding assistant — define it as “You are the HR Onboarding Assistant. When a new employee joins, generate a welcome email, assign training tasks, schedule orientation…” etc.

3. Design Multi-Step Tasks, Tools & Workflows Carefully (Don’t Rely on One Prompt Only)

Because Joget Agents support multi-task workflows with prompts > tools > enhancers. You should treat agent logic as a mini-workflow or business process:

• Break down the overall goal into smaller tasks (e.g., data retrieval > classification > action > result storage), rather than expecting one prompt to handle everything. This modular design improves clarity and reduces complexity. (Joget)
• If your agent needs to fetch data, use Tools (API calls, database queries, web search). If it needs to format or save results, use Enhancers. This clean separation keeps logic organized and maintainable. (Relinns)
• Always test and preview the full flow before deploying, and use the built-in Preview mode. Simulate different inputs and edge cases to catch unexpected behavior early. (Joget)

4. Prefer Structured Output (Not Free-form Text) Where Downstream Systems or Humans Rely on It

When agents perform tasks whose output needs further use (e.g., populating a form, triggering an action, feeding another system), it’s better to ask for structured output (JSON, tables, fixed format) rather than free-form text. That reduces ambiguity and parsing errors. (VoiceInfra)

For example: if building a support-ticket triage agent — ask it to return something like:

{

  "category": "billing|technical|general",

  "priority": "low|medium|high",

  "required_info": ["customer_id", "issue_description", ...],

  "next_action": "escalate|respond|request_info"

}

This makes downstream automation (e.g., routing, alerts) easier.

5. Ground the Agent with Real Data / Knowledge Where Possible (Use RAG or Internal Knowledge Sources)

If your agent needs to answer questions, look up policies, or provide domain-specific info, rely on a curated knowledge base (documents, company wiki, databases) rather than generic LLM knowledge. This reduces hallucinations (wrong or made-up answers) and increases reliability. (Wikipedia)

In contexts like customer support, HR, and compliance, provide the agent with the relevant documents or database access, and in prompts instruct: “Use ONLY the provided document/database to answer. If the answer is not there, say "I don’t know.”

6. Keep Prompts and Workflows: Iterative Test, Evaluate, Refine

As you build agents, treat prompt-writing and workflow design as an iterative process: write, test, review, refine. This helps catch edge cases and improve consistency. Over time, you discover what works and what breaks. (DEV Community)

Don’t expect the first version to be perfect; agents should evolve as real-world usage reveals new requirements, failure modes, or edge-case inputs.

7. Maintain Human-In-The-Loop, Oversight, and Governance (Especially for Critical Tasks)

Because AI agents can act autonomously (send emails, change data, trigger workflows), it’s wise to have human approval or review for high-stakes actions (e.g., financial decisions, compliance, sensitive data). The Joget platform supports governance agents that can operate within existing workflows where humans make the final decision. (PR Newswire)

This ensures: accountability, audit trails, control over automation, and trust when AI is applied in real business contexts.

Common Pitfalls & What to Avoid (Based on Industry & Community Experiences)

From industry guidelines and real-world agent-builders’ experiences, here are common mistakes and how to avoid them:

• ❌ Relying on prompts alone: Thinking that a single prompt is enough for complex tasks. In reality, you often need orchestration: memory, logic, tools, error handling, workflows. A community builder said:

“I’ve seen great prompts fail. And mid prompts win. Because the magic isn’t in the prompt. It’s in the system around it.” (Reddit)

• ❌ Ignoring testing and edge cases: Without testing across varied inputs, agents may fail unexpectedly. Especially for business-critical tasks, not testing enough is risky. (Reddit)
• ❌ Letting agents hallucinate no grounding / outdated data: If the agent bases its answers only on its LLM’s internal knowledge, answers may be wrong or outdated. Avoid by using RAG or fixed knowledge bases.
• ❌ Over-complex workflows or tool overuse: Trying to over-engineer for rare edge-cases or use many tools can make agents fragile, hard to maintain — overkill often backfires. As one developer wrote, many frameworks try to “do everything,” but you end up using just ~10% of features. Simpler agents often perform best. (Reddit)
• ❌ No human oversight for important actions: Letting agents perform critical tasks unsupervised increases risk (wrong data, unintended side-effects, compliance issues). Always build in review/approval where needed.

What Non-Technical Users (Business Leads / Analysts) Should Think About Before Building an Agent

Before starting to build with Joget AI Agent Builder, consider the following checklist questions. These help define scope, goals, and governance — essential for successful deployment.

Recommendations for “Best Start”: What a First Agent Should Look Like

For those building their first agent with Joget (non-technical):

1. Pick a simple, high-value use case, e.g., internal support ticket triage, FAQ bot, simple document summarizer, or onboarding checklist generator.
2. Use a single-task workflow initially: Prompt > Tool (optional) > Enhancer (optional); avoid complex multi-task or branching flows until you’re comfortable.
3. Ask for structured output, especially if outputs feed into forms or other systems.
4. Ground the agent: provide any company-specific docs or data if the agent responds about your company’s policies, processes, or products.
5. Include human oversight, especially if actions involve sensitive data, approvals, or external communications.
6. Test thoroughly, try varied inputs, edge cases, “weird” or “bad” user inputs, and make sure the agent behaves sensibly or fails gracefully.
7. Iterate & improve: as real usage begins, collect feedback, refine prompts or workflows, treat the agent as a living part of your process, not a one-time build.

Why These Practices Reflect “State-of-the-Art (SOTA)” Guidance

• Leading prompt-engineering guides emphasise clarity, structured prompts, chain-of-thought, role-based prompting, structured output, and grounding (e.g., via retrieval or knowledge bases) for reliability and reduced hallucinations. (FreeCodeCamp)
• Industry-wide consensus: prompting alone is not enough; effective agents require orchestration: tasks, tools, external data, workflows, especially in multi-step or tool-based use cases. (Reddit)
• Real-world agent builders report simpler agents (with clear purpose, minimal complexity, good maintenance) often outperform over-engineered ones. (Reddit)
• Summary

Here are some key takeaways:

• Joget AI Agent Builder democratizes agent-building: non-technical users can build real AI agents visually.
• But building “good agents” requires care: clear prompting + structured workflows + grounding + governance + iteration.
• Avoid thinking of an agent as “just a prompt.” Treat it as a small business process: design tasks, define data & tools, plan for oversight and maintenance.
• Start small, keep things simple, test thoroughly, and iterate based on real-world feedback.