guilds.run

Product Introduction

1. Definition: Guilds.run is an open-source, self-hostable platform for building, running, and inspecting multi-agent AI workflows. Technically, it is a containerized orchestration system for autonomous AI agents, providing each agent with a persistent, sandboxed environment (a "computer") and full observability into every step of execution.
2. Core Value Proposition: It exists to solve the "black box" problem in multi-agent AI systems. Guilds.run enables developers and teams to deploy trustworthy, production-ready AI agent teams by providing unprecedented transparency into prompts, tool calls, memory changes, and inter-agent communication, all while being model-agnostic and running on your own infrastructure.

Main Features

1. Full Run Inspection & Observability: Every agent execution (a "run") is logged with forensic detail. This includes the exact prompt sent to the LLM, every API or tool call made (e.g., to X/Twitter, a database), the raw result returned, and every change to the agent's memory or shared data. This granular audit trail is stored permanently, allowing developers to pinpoint the exact step, agent, and prompt where an error or unexpected behavior occurred.
2. The Studio - AI-Powered Team Tuning: This is a coaching system that analyzes live team data (runs, notes, memory, schedules) to diagnose recurring workflow issues. For example, it can detect that an agent's replies are consistently too long, trace the cause to conflicting instructions, and draft a precise edit to the agent's standing task. The human reviews and approves the change, enabling iterative, data-driven optimization of the entire multi-agent system.
3. Model & Provider Agnostic Architecture: Each individual agent within a team can be configured to use a different Large Language Model (LLM). The platform supports major proprietary APIs (OpenAI GPT, Anthropic Claude, Google Gemini, xAI Grok), open-weight models (Llama, Mistral, Qwen), and can connect via providers like OpenRouter, DeepInfra, or local endpoints like Ollama. This allows cost and performance optimization per agent role.
4. Persistent Agent Computers & Sandboxing: Each agent operates in its own isolated, persistent environment featuring a terminal, a dedicated workspace for scripts/files, and configurable tools (e.g., a logged-in browser, coding tools). This sandbox persists between runs, allowing agents to maintain state, execute custom scripts, and interact with complex web applications securely.
5. Structured Memory & Shared Data: Agents utilize versioned notes, key-value memory, and shared databases (SQLite-style tables). All data—scripts written by agents, records in shared tables, memory key-values—is human-readable and editable. Every change is versioned, attributing it to either a user or a specific agent run, creating a collaborative and auditable knowledge base.
6. Recipes & Connectors: "Recipes" are exportable/importable configuration files that define an entire working agent team—their roles, tasks, tools, schedules, and data schemas. This enables sharing of proven workflows. Connectors are granular, permission-controlled API integrations (e.g., X, GitHub, Notion, Gmail, crypto wallets) that can be assigned at the organization, guild (team), or individual agent level.

Problems Solved

1. Pain Point: The lack of debuggability and trust in multi-agent AI systems. When a complex, automated workflow fails or produces a suboptimal output, it is notoriously difficult to diagnose which agent, tool call, or prompt instruction was responsible.
2. Target Audience: AI Engineers and Developers building production agentic workflows; Product and Growth teams automating complex, multi-step processes (social media, sales outreach, support triage); DevOps and Platform teams requiring security, audit trails, and self-hosting for AI automation.
3. Use Cases:
   • Social Media Growth: A team of agents (scout, quill, editor, keeper) autonomously scans a watchlist, scores posts, drafts on-brand replies, manages a posting queue, and generates reports.
   • Sales & Prospecting: Agents research LinkedIn profiles, draft personalized outreach sequences, and track conversation threads in a shared database.
   • Developer Operations: Agents triage GitHub issues, review simple pull requests, manage backlogs, and post update notifications.
   • Support Triage: Agents read a shared inbox, categorize tickets using memory, draft first-response replies for human review, and escalate urgent issues.

Unique Advantages

1. Strengths & Limitations (Pros & Cons):

   • Pros:
     • Unmatched Transparency: The core differentiator. The ability to inspect every atomic action eliminates guessing and builds operational trust.
     • True Self-Hosting: Offers full data sovereignty and control, avoiding vendor lock-in and API costs for model providers you host yourself.
     • Granular Control: Fine-grained permissions for connectors, model selection per agent, and direct editing of all agent context (memory, tasks, scripts).
     • Practical Tuning Tools: The Studio feature moves beyond simple logging to active problem diagnosis and fix suggestion.
   • Cons:
     • Operational Complexity: Self-hosting requires managing Docker, infrastructure, and potentially your own LLM endpoints (Ollama, vLLM), which has a steeper setup than purely SaaS alternatives.
     • Early-Stage Ecosystem: While powerful, the platform and its library of community "Recipes" are nascent compared to more established automation tools.
     • UI-Centric Workflow: Advanced configuration and deep inspection are done in the web UI. Teams preferring purely code-defined and version-controlled agent specs (e.g., via YAML in Git) might find this less familiar.

2. Key Alternatives & Differentiation:

   • CrewAI & AutoGen: These are popular open-source frameworks for multi-agent development. Guilds.run is a full platform that includes the runtime, orchestration, UI, observability, and data persistence. While CrewAI/AutoGen provide libraries to build agents in code, Guilds.run provides the environment to run, monitor, and manage them long-term.
   • LangGraph / LangChain: These are lower-level libraries for building stateful, multi-step LLM applications. Guilds.run operates at a higher level of abstraction, managing the lifecycle of persistent, tool-using agents and focusing on the operational layer of deployment and observation.
   • SaaS AI Automation Tools (Zapier/Make with AI, n8n): These are general-purpose automation platforms adding AI nodes. Guilds.run is specialized for complex, stateful, multi-agent AI workflows with deep LLM integration. It offers far greater control over the AI reasoning process (prompts, memory) and transparency, whereas SaaS tools often treat AI as an opaque "magic box" within a broader workflow.

Frequently Asked Questions (FAQ)

1. Is guilds.run really free and open source? Yes, the core software is fully open-source (likely under a permissive license like MIT or Apache 2.0) and can be self-hosted for free. You only pay for the LLM API keys you use (OpenAI, Anthropic, etc.) or the infrastructure costs of running it. A managed hosted version is also planned.
2. How does guilds.run compare to Grok AI or other chatbot teams? Guilds.run is an open-source, inspectable platform for building your own custom AI agent teams for specific workflows (like social media or sales). Grok is a proprietary chatbot with a fixed personality. Guilds.run gives you the tools to build, see inside, and control specialized agents that perform concrete tasks using your data and tools.
3. What technical skills are needed to run guilds.run? For self-hosting, basic proficiency with Docker and command-line operations is required to run the provided docker-compose setup. To build complex agents, understanding of LLM prompts, APIs, and basic scripting (Python) is beneficial. Using pre-made "Recipes" lowers the barrier significantly.
4. Can I use local LLMs like Llama 3 with guilds.run? Absolutely. Guilds.run is model-agnostic. You can configure agents to use local models via endpoints like Ollama or LM Studio, or use cloud-hosted open-weight models through providers like Together AI or DeepInfra, alongside proprietary APIs.
5. How does the "agent computer" and sandboxing work for security? Each agent runs in an isolated Docker container with resource limits. Tools like browsers or terminal access are provided in a controlled manner within this sandbox. This prevents agents from interfering with the host system or each other, a critical feature for executing untrusted code or browsing actions.