Run a whole fleet of AI agents as managed services, each with its own model, memory, schedules, and sandboxed workspace, from one admin console. Create an agent, point it at OpenAI, Anthropic, OpenRouter, or any OpenAI-compatible endpoint, store its API keys encrypted, and it is ready to chat in the browser. People sign in with a device key and get a session list, streaming replies, and file attachments. The Agents table shows status, last activity, sessions, errors, and token spend for the past 24 hours, and the Stats page tracks users, sessions, events, and total tokens. Cron or one-shot schedules let an agent send a daily brief, and each run is logged. Owner, user, and guest roles control who may talk to an agent or change it, and policy and approval tabs gate risky tool calls. Skills and MCP servers are registered once and enabled for one agent or the whole fleet, and instructions can be pushed to every agent at once. Sessions, memories, and secrets sit in PostgreSQL, so state persists across gateway restarts. Use it for an internal agent platform, a support desk, or one agent per customer. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. MIT licensed.

A control room for AI agents, where every run is recorded, capped, and ready to resume after a crash. Mission Control opens first with agent and run counts, tokens, success rate, and cost per day. A Templates page applies ready-made agents for code review, KYB due diligence, lead scoring, market monitoring, and release notes in a single screen. Every run gets a Report tab with the finished answer and a Timeline tab with each message, tool call, and charge. Tools are set to allow, ask, or deny. Spend caps pause a run instead of failing it. An agent can stop and ask a person a question. The Playground starts a run from a form and shows the same request as curl, so each agent doubles as an API. Triggers start capped runs on a schedule, from a signed webhook, or on a GitHub pull request. Learning mode keeps notes, skills, and workflows from each job so repeat work needs fewer tokens. Automated code review, customer research, and competitor digests are typical recurring jobs to hand it. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. Apache-2.0 licensed.

SandBase Harness gives your AI agents a proper home with sessions, tools, sandboxes, and an audit trail instead of a pile of scripts. The console lists agents with their model, status, and version, and an agent page shows its system prompt, attached tools, and skills. Every session keeps a resumable event log, and a transcript view opens any user or agent message as a rendered or raw event. Built-in tools run in a local process, per-session Docker containers, Kubernetes, or a self-hosted worker queue, and permission policies can always allow a tool or always ask a human first. MCP toolsets, credential vaults, and skill packages extend what an agent can reach, with Anthropic's xlsx, pptx, pdf, and docx skills listed next to your own. Memory stores, webhooks, scheduled deployments, and outcome definitions cover longer-running work. Settings include a model provider form, API keys for bearer authentication, and an interactive API reference for sessions, agents, environments, and vaults. A TypeScript SDK and a bundled MCP bridge connect other tools to the same runtime. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. Apache 2.0 licensed.

With over 2,100 GitHub stars in its first month and benchmarked at 30-75% lower cost than Claude Managed Agents on enterprise task suites, TrueForge is the open-source agent harness that provides the complete runtime layer for turning any LLM into a working production agent on your own infrastructure. The TypeScript server runs the full execution loop — streaming every step, routing tool calls through MCP servers with centralized header-auth and in-chat OAuth, delegating parallelizable work to isolated subagents, and pausing for human approval on sensitive actions. Context engineering keeps token costs low: deferred tool-schema loading delays MCP schemas until invoked, large-result offloading moves oversized outputs to files, Code Mode processes structured data through sandboxed execution, and automatic compaction summarizes older history at a configurable 50,000-token threshold while preserving the full transcript. The sandbox-as-a-tool architecture provisions isolated Daytona environments only when code execution is required, allowing one server to run many concurrent agents without idle overhead. Agents are configured from shipped YAML catalogs of models, MCP servers, git-backed SKILL.md instruction packs, and sandbox providers, then saved to an Agents Library accessible via the chat UI, TypeScript SDK, or embeddable React UI SDK. Run locally with SQLite via a single npx command, or deploy for teams with Docker Compose or Helm using Postgres and Redis with OIDC authentication. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. MIT licensed.

OpenMA lets you build and run AI agents with the model, harness, and sandbox you choose, on infrastructure you control, while it handles the sessions, execution, and recovery around them. Create an agent in the console, give it work, and come back later to the same session, because conversation history, streamed progress, and execution attempts are preserved rather than tied to one process that might die. Agents start with shell, file, web, and browser tools, then grow through MCP services and reusable Skills, while resources such as GitHub repositories, uploaded files, and shared memory attach to the work that needs them. Deployments run agents manually or on schedules you define, environments carry their own networking and package configuration, and model cards keep provider settings in one place instead of scattered environment files. If a sandbox fails, the session survives it; a replacement harness can rebuild context from durable events and workspace checkpoints. Operate everything through the console, the API, or the CLI, and plug in the database, queue, and object storage your deployment already trusts. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. Apache 2.0 licensed.

Aegra runs your LangGraph agents on your own infrastructure with the same SDK and APIs you would use on the managed platform, so moving in does not mean rewriting your agents. You deploy an agent once and clients connect through Agent Chat UI, LangGraph Studio, or CopilotKit, while threads, runs, and checkpoints persist between sessions instead of vanishing when a process restarts. Streaming answers arrive token by token over server-sent events, and if a connection drops, the stream reconnects and replays missed events rather than losing the run. Human-in-the-loop gates pause an agent at the step you choose, wait for a person to approve or edit, and then resume from exactly that state. Scheduled cron jobs trigger runs on standard or seconds-level expressions with timezone support, which turns agents into recurring workers for reports, checks, and follow-ups. When traffic grows, Redis-backed workers process runs with lease-based crash recovery, so a dead worker's job is picked up instead of disappearing. Authentication handlers plug in JWT, OAuth, or Firebase, custom endpoints sit beside the agent API, and traces fan out to the observability backend you already run. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. Apache-2.0 licensed.

Running AI agents in production takes more than a model call: Omnara supplies the durable runtime, tools, approvals, and complete event history around any model, on your own machines. You define an agent once in a small YAML file: instructions, a model from OpenAI, Anthropic, OpenRouter, Bedrock, LiteLLM, Ollama, or your own endpoint, and the machines it may use. Launch agents from the REST API, the TypeScript SDK, the command line, or the dashboard, then stream every event live or receive it as a webhook while the agent works. Agents run shell commands and edit files on sandboxes from twelve providers, or on your own laptops, VMs, and containers through a daemon that connects outward, so no inbound ports or SSH keys are exposed. Every step is written to Postgres as an event log, which means an agent survives crashes, restarts, and disconnected machines and resumes exactly where it stopped. Tool permissions can run immediately, ask a person first, or block outright, and agents can start subagents, follow cron schedules, and keep shared memory files between conversations. Teams meet the agents where they already talk: mention the bot in Slack or Discord, or let a GitHub pull request trigger a review, with questions and approvals handled in the thread. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. Apache-2.0 licensed.

Describe the task in plain words, pick the sources and model it may use, and an agent plans the workflow before running it. That is the core loop: agents build editable visual workflows from a task description, execute them on demand or on a schedule, and keep everything traceable. Prefer building by hand and the canvas offers 17 preconfigured steps, branching, undo and redo, JSON import and export, plus eight starter templates. Feed it real work by importing PDF, DOCX, XLSX, CSV, JSON, and text files, or by connecting folders, HTTP endpoints, and approved local programs. Upload a screen recording and it identifies the actions with timestamps, turning a demonstrated process into an editable workflow you can refine. Model calls go to the endpoint you choose: Ollama, LM Studio, vLLM, or any OpenAI-compatible service, local or cloud with your own credentials. Every run can be inspected step by step, cancelled mid-flight, and exported as JSON, CSV, or Markdown reports. Observations from completed runs land in a knowledge and learnings store, where you review them and promote the useful ones into reusable skills for the next task. The Docker release bundles the application with FFmpeg and local Whisper support, and your documents stay on your own machine. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. Apache License 2.0 licensed.

Deploy autonomous conversational AI agents and coordinate complex multi-agent workflows through EDDI, an open-source orchestration middleware that turns declarative configuration files into secure, production-grade enterprise assistants. Engineering teams connect AI models from twelve different commercial and local providers, using bilateral Model Context Protocol tools to let external desktop clients and coding assistants interact directly with running conversational services. Autonomous agents collaborate through structured group interaction patterns including round table discussions, peer reviews, Delphi consensus rounds, and devil's advocate debates to refine generated solutions before delivery. Declarative workflow extensions automate external REST API calls with dynamic request templating, extracting structured properties into persistent conversation memory and chaining multi-step service interactions without custom script glue. Built-in secret vaults safely manage sensitive API credentials, while the centralized web dashboard provides live conversation inspection, token quota enforcement, and comprehensive audit logging for regulatory compliance. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. Apache 2.0 licensed.

Archestra delivers the enterprise AI infrastructure layer that organizations need when managing multiple LLM providers, MCP servers, and AI agents across teams becomes unmanageable. The LLM gateway routes requests across Anthropic, OpenAI, Azure, Bedrock, and DeepSeek with virtual API keys, per-team cost limits, and dynamic model routing — giving every developer one token for Claude Code, Cursor, or Codex while finance tracks spend per department. The MCP gateway authenticates tool calls with OAuth 2.1 and On-Behalf-Of tokens so each tool executes as the calling user, not a shared service account, eliminating credential sprawl. The private MCP registry lets teams publish custom tool servers with approval flows promoting servers from dev through staging to production, each environment maintaining its own credentials and network egress policies. The Kubernetes operator manages MCP server lifecycle — deploying containers, scaling, health-checking, and routing gateway traffic to local servers automatically. The agent runtime supports scheduled triggers, email and webhook invocations, sub-agent delegation, reusable skills, and sandboxed code execution with a K8s-native filesystem. Deterministic guardrails including Dual-LLM verification and Lethal Trifecta protections prevent dangerous tool calls before execution. Built-in OpenTelemetry traces and Prometheus metrics provide full observability without additional tooling. Docker deployment exposes the Admin UI on port 3000 and API on port 9000 with a single command. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. AGPL-3.0 licensed.

With over 24,000 GitHub stars and origins in the MemGPT research paper on virtual context management, Letta has evolved into the leading open-source platform for building AI agents that maintain persistent memory, identity, and continuity across sessions rather than operating as stateless prompt-response loops. The core architecture uses memory blocks — structured, labeled text chunks that reside permanently in the agent's context window — allowing agents to programmatically rewrite their own memory, learn new skills, and improve through a sleeptime dreaming process that runs reflection and memory organization during idle periods. The self-hosted App Server deploys via Docker and exposes a WebSocket API on port 4500, letting the TypeScript Agent SDK connect from any application using local, remote, or cloud backends. Agents support git-versioned memory through MemFS where every memory change is tracked and auditable, multi-agent communication via subagents, scheduled tasks, and integration with messaging platforms including Slack, Discord, Telegram, WhatsApp, and Signal. The platform is fully model-agnostic, routing to OpenAI, Anthropic, xAI, or self-hosted open-weight models through Ollama depending on cost, performance, and data residency requirements. The Agent File format serializes complete agent state — memory, skills, prompts, and conversation history — into portable snapshots. Desktop applications for macOS, Windows, and Linux provide native interfaces alongside the terminal CLI and web chat at chat.letta.com. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. Apache-2.0 licensed.

MateClaw delivers a multi-agent AI platform where digital employees run as persistent team members with roles, goals, and accumulated skills rather than stateless chat completions. The Spring Boot backend on Spring AI Alibaba provides ReAct iterative reasoning and Plan-and-Execute decomposition on a StateGraph runtime, with parallel delegation between employees and dynamic context pruning for multi-step tasks. Five career templates ship ready (Product Researcher, Customer Support, Knowledge Curator, Data Analyst, Executive Assistant) while custom employees inherit configurable backstories, pixel-art avatars, and dedicated tool bindings. The MCP integration supports stdio, SSE, and Streamable HTTP transports with per-employee tool isolation preventing capability bleed between agents. ACP bridges bring Claude Code, Codex, and other coding agents in as first-class employees. Workflow orchestration composes multiple employees and system actions into publishable linear DSL processes with seven step modes: sequential, fan_out, collect, conditional, await_approval, dispatch_channel, and write_memory. The trigger system wires cron schedules, webhooks, channel messages, employee lifecycle events, content matches, and workflow completions to automated flows. The Admin Runtime Console provides real-time visibility into running employees with token usage tracking and one-click force-recycle. Spring Boot Actuator monitoring, full audit trail, and per-channel error isolation deliver production-grade reliability. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. Apache-2.0 licensed.

Open Agent Builder delivers a visual canvas for orchestrating AI agent workflows without writing Python scripts or managing complex codebases. The React Flow-powered drag-and-drop interface supports seven node types — Agent, Scraper, Transform, If/Else, Loop, User Approval, and MCP Tool — each configurable with provider-specific settings for Anthropic Claude (Haiku 4.5 and Sonnet 4.5), OpenAI GPT-5, Groq, or any OpenAI-compatible endpoint. The LangGraph orchestration engine handles state management, conditional routing, and human-in-the-loop approval gates while Firecrawl integration converts any website into structured, LLM-ready data through scrape, crawl, and map operations. E2B sandboxed code execution powers Transform nodes for secure data manipulation without risking host system integrity. Real-time streaming updates show execution progress node-by-node as workflows run, with Convex providing reactive database synchronization for workflow state and execution history. The TypeScript-first architecture (96.8% TypeScript) built on Next.js 16 App Router with Tailwind CSS delivers a responsive interface across devices. Clerk handles multi-user authentication with JWT integration for secure workspace isolation. Deploy via npm install and environment configuration with Firecrawl, Convex, and Clerk API keys. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. MIT licensed.

Building LangGraph agents in code means imagining the graph; LangGraph GUI turns that graph into something you draw, wire, and run from the browser instead. You place a start node, add step nodes, and drag edges between ports to define the flow, with cycles created by simply connecting nodes back toward each other. Condition nodes split execution into green true paths and red false paths, info nodes append context to stage output, and subgraph nodes run a whole named graph inside another one. Tool steps call real Python functions that you define in tool nodes with the familiar decorator style, so file saving, lookups, and custom logic sit inside the visual flow. Graphs save to JSON on your computer, load back for editing, and upload to the server as workflow files ready to execute. You configure which LLM to use and its API key in the panel, run against local models through Ollama or hosted APIs, then download every file the run produced in the workspace. Files upload to the server workspace as working environment, and a cache clean clears it between runs. Example graphs for role-playing loops, lottery branch switches, and tool-using flows show patterns you can copy and refine with your own prompts. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. MIT licensed.

Langflow turns LLM application development into a visual canvas where every node maps to a real LangChain primitive (chains, agents, retrievers, memory, vector stores, and tools) that teams wire together without writing integration boilerplate. The platform supports 15+ LLM provider components including OpenAI, Anthropic, Google Gemini, Mistral, Groq, Cohere, Azure OpenAI, HuggingFace, and Ollama for fully local inference, with LiteLLM proxying to over 100 additional providers through a single OpenAI-compatible endpoint. Vector database integrations cover Pinecone, Weaviate, Chroma, Qdrant, Astra DB, OpenSearch, FAISS, and Milvus, while built-in Knowledge Bases introduced in version 1.8 allow RAG pipelines without any external vector service. Multi-agent orchestration enables agent-to-agent communication with conversation management, persistent Memory Bases for cross-session context retrieval, and step-by-step reasoning visibility in the interactive Playground. Every flow automatically becomes a callable REST API endpoint via the /run route and an MCP server exposable to Claude Desktop, Cursor, or any MCP-compatible client. Every component is a real Python class that developers can customize, extend, or replace, while Extension Bundles package third-party integrations as independent pip packages for modular installation. Tool integrations include web search, Slack, Gmail, Google Drive, GitHub, and custom REST API calls. Docker deployment with PostgreSQL persistence runs on port 7860. Backed by 153,000+ stars and DataStax. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. MIT licensed.

Drag nodes onto a canvas and ship an LLM app: Flowise is an open-source visual builder for AI agents and LLM applications, written in Node.js on LangChain.js and licensed Apache-2.0. You assemble flows by dragging nodes onto a canvas: models, prompts, memory, vector stores, retrievers, and tools, then wire them together and test in the built-in chat panel. Three builder types cover increasing complexity: Assistant for simple RAG chat over uploaded files, Chatflow for single-agent systems with techniques like rerankers and Graph RAG, and Agentflow for multi-agent orchestration with branching, looping, shared flow state, and human-in-the-loop checkpoints. Over 100 integrations connect data sources, vector databases, and both proprietary and open-source models, plus MCP client and server nodes for standard tool interop. Finished flows are exposed as REST APIs, embedded chat widgets, or via JS and Python SDKs - each flow gets an endpoint the moment it is saved, removing the deployment gap between a working prototype and something your application can call. Execution logs, visual step debugging, and external log streaming trace behavior, while input moderation and rate limiting act as guardrails; RBAC, SSO, and workspaces cover team deployments. Self-hosting keeps prompts, encrypted credentials, and conversation data on your own instance, which matters when flows handle internal documents or customer data - and wiring a model, prompt, memory, and vector store on the canvas replaces the boilerplate a hand-coded LangChain project would need.

Every AI agent that deals with people eventually needs an email address, and Open Agent Email gives each one a real inbox on your own domain. Agents receive mail in proper threads, reply in place, send new messages, schedule sends up to 90 days ahead, and handle attachments, labels, search, trash and restore from one mailbox. A human approval gate can hold any outgoing message until a person clicks approve or reject, with an expiry and a full history, so a risky reply never reaches a customer unchecked. Incoming mail is screened for prompt-injection tricks and hidden text, checked against SPF, DKIM, and DMARC, and can be scanned for viruses before an agent reads it. Agents connect through a REST API with an OpenAPI file, dependency-free Python and TypeScript SDKs, the oae command line, signed webhooks, a live WebSocket stream, or 96 MCP tools for coding agents. The browser dashboard covers guided setup, inboxes, pending approvals, the outbox queue with retries, delivery metrics with bounce and complaint tracking, contacts, templates, domains with DNS verification, and API keys. Sending runs through your own relay, SES events feed suppression lists automatically, and scoped per-inbox keys limit what each agent may do. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. Apache-2.0 licensed.

AgentConnect brings Claude Code, Codex, Grok Build, DeepSeek, and any other ACP-compatible coding agent into the chat channels and repositories where your team already works, each with a role of its own. Mention an agent in Slack, Microsoft Teams, Google Chat, Lark, Discord, or Telegram and it replies in the thread, calls on a colleague agent when needed, and keeps its session visible to teammates who can step in. Work can also start from a GitHub, GitLab, Gitea, or Azure DevOps pull request, a Linear issue, a webhook, or a schedule. The web console organizes the fleet into Agents, Sessions, Schedules, Tools and Skills, Knowledge, and Daemons views. Every agent gets its own memory, skills, MCP servers, workspace, and sandbox policy, and reviewed Knowledge pages can be published for all agents to search. Decisions route new conversations to specialist agents and pick the runtime and model for each session. Review bots can run several reviewers with separate instructions on one pull request. Set who may see each agent or session, which repositories it can touch, and which agents it may call. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. Apache-2.0 licensed.

One endpoint for every MCP server you run: MCPHub gathers local and remote Model Context Protocol servers behind stable URLs, so AI clients connect once and see what you allow. Claude Code, Cursor, and Cherry Studio can use four routes: everything at /mcp, a named group at /mcp/{group}, one server at /mcp/{server}, or semantic tool search at /mcp/$smart. Smart routing runs vector search on PostgreSQL with pgvector and an OpenAI-compatible key, so the model gets a shorter tool list. Servers attach over stdio, SSE, or streamable HTTP, OpenAPI services can be wrapped as MCP tools, and changes apply without downtime. In the other direction, MCP tools can be exported as an OpenAPI 3.0.3 spec for OpenWebUI and other OpenAPI clients. Bearer keys, OAuth 2.0 (client and server modes), and GitHub or Google sign-in in database mode control access, with per-user visibility for servers and groups. Encrypted per-user credentials let one shared server use each person's own key. Logs show tool-call activity, request status, and latency, health checks track each connection, and the dashboard controls which tools, prompts, and resources each server exposes. Large text tool results can be compressed, interactive MCP Apps are proxied through MCPHub routes, and a built-in market lets you browse a server catalog. Typical uses include a team-wide gateway, per-project groups, and direct single-server routes for debugging. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. Apache-2.0 licensed.

Software developers running Claude Code, Cursor, Codex, and Aider use AgentsView to trace token expenditures, search full session transcripts, and analyze multi-agent concurrency timelines. Engineers can search through historical developer sessions to locate specific code modifications, prompt chains, or debugging rationales across extensive programming workflows. The real-time activity timeline visualizes concurrent agent operations, revealing peak execution windows, task run durations, and automated tool invocations. The usage analytics engine calculates financial costs and token volumes per model by applying live pricing tables while accounting for prompt caching read discounts. Developers inspect granular turn-by-turn session transcripts complete with raw model payloads, file difference diffs, executed shell commands, and syntax errors. The recall browser extracts key technical context from past programming sessions, organizing facts into an indexed reference knowledge corpus for reuse across future project tasks. Administrators can replicate SQLite session tables into DuckDB analytics files or PostgreSQL warehouses to query longitudinal metrics using SQL analytical tools or custom reporting scripts. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. MIT licensed.