Gianluca Brigandi
Gola: Prompt-Defined AI Agents Are Here

Gola: Prompt-Defined AI Agents Are Here


AI
AI agents LLM MCP agentic-ai llm-applications

The Shift: From Code to Prompts

Traditional agent frameworks require you to write Python or JavaScript code that orchestrates LLMs, manages state, and coordinates tools. The LLM is powerful but passive: it only responds to your programmatic instructions.

Enter Gola

Gola flips this model. You write natural language descriptions of what the agent should do, and the LLM orchestrates its own behavior. The prompt becomes the code.

# Traditional: Code orchestrates the LLM
class TravelAgent:
  def __init__(self):
    self.llm = LLMClient()
    self.tools = [FlightSearch(), HotelSearch(), ...]
    self.memory = ConversationHistory()
  
  def process(self, query):
    context = self.memory.get_context()
    tool_decision = self.decide_tool(query, context)
    if tool_decision:
      result = self.execute_tool(tool_decision)
      response = self.llm.generate(query, result, context)
    self.memory.update(query, response)
    return response

# Prompt-defined: LLM controls itself (simplified version)
agent:
  name: "travel-assistant"
  instructions: |
    You are travel assistant. Help users plan travel by:
    - Finding flights, hotels, activities using search tools
    - Always verify current prices and availability
    - Present 2-3 options with clear trade-offs
    Never confirm reservations without explicit user approval.
  mcp_servers:
    - name: "flights"
    - name: "hotels"

Why Now? The Perfect Storm

Three advances converged to make prompt-defined agents possible:

1. Research Maturity

Years of research from ReAct framework to Chain-of-Thought prompting taught us how LLMs can reason through problems and take actions. We understand the patterns (Reason → Act → Observe loops) that make agents effective.

Anthropic’s Model Context Protocol (MCP) solved the integration nightmare. Like USB-C for AI, MCP provides standardized connections to tools and data sources. Instead of custom integrations for every tool, LLMs can directly plug into 5000+ pre-built MCP servers.

Modern LLMs already have native tool-calling abilities. MCP leverages this, creating a clean interface between what LLMs naturally want to do and external systems.

3. Understanding and Controlling Non-Determinism

Gola doesn’t fight LLM variability and works with it instead. Rather than trying to eliminate non-deterministic behavior (impossible), it provides consistent orchestration patterns while allowing natural reasoning flexibility within guardrails that combine platform safeguards with user-defined constraints.

Sharing Agents Made Simple

Gola transforms GitHub into an app store for AI agents. Every agent configuration is a repository. Want a customer support agent? Search GitHub, find community-maintained options, fork one, modify the prompts, and deploy.

This solves the fundamental challenge of agent distribution: where do you find, share, and discover effective agents? When the prompt is the code, collaboration becomes natural.

What Actually Works

Natural ReAct Flow: The LLM alternates between thinking and acting, with each observation informing the next reasoning step. No bolted-on tool calling; it’s native to how the agent operates.

Containing LLM Drift: Gola’s agent runtime keeps deviations under control without affecting user experience. When agents start to drift from their intended behavior, the runtime provides guardrails that maintain workflow adherence. Combined with detailed tracing, you can see exactly what happened and refine prompts as needed. The result: agents stay on track in production while you iteratively improve their instructions.

LLMs as Development Tools: LLMs themselves become a core piece of the development environment for crafting prompts. Since LLMs excel at writing and refining prompts, they can analyze trace data and suggest improvements to agent instructions. The development loop becomes AI-assisted: deploy, observe behavior, use LLMs to refine prompts, redeploy.

Self-Improving Prompts: When prompts are code, debugging becomes collaborative and transparent. The git-native approach means you can version prompt improvements and share them with the community.

Less Complexity: Integration complexity vanishes through standardized MCP servers. Planning complexity is handled by letting the LLM orchestrate based on intermediate results rather than rigid upfront planning.

Try It Now

See prompt-defined agents in action with a single command. Gola runs on macOS, Linux, Windows, and Docker:

# Download for Mac Silicon
curl -L https://github.com/gola-agent/gola/releases/latest/download/gola-darwin-arm64 -o gola
chmod +x gola
./gola --config github:gola-agent/gola-sherpa-agent

You’re now running a full travel agent. No framework setup, no integration code, just a prompt defining behavior.

The Bottom Line

Building agents used to require deep technical expertise: wrestling with frameworks, managing integrations, handling non-deterministic behavior. Gola makes these proven patterns accessible — as a single, all-in-one binary — to anyone who can write YAML and describe what they want in natural language.

This is just the start. Help shape the growing ecosystem of prompt-defined agents with your feedback and contributions.

Learn more at gola.chat — documentation, examples, and community.

This project is dedicated to the loving memory of my mom, who passed recently after a long fight with dementia.

References

Originally published on Medium