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.

OpenClaw Dashboard is a secure real-time monitoring dashboard for OpenClaw AI agents that tracks live sessions, API costs, rate limits, and host health from one browser page. The overview refreshes every five seconds with live session activity, token totals, and lifetime spending, so you can see what every agent is doing right now. Cost views break spending down by model, session, and time period, and rate limit panels track Claude and Gemini usage against rolling windows with browser alerts before quotas run out. A live feed streams agent messages across all sessions, and a session browser adds search, status filters, timelines, and a 30 day activity heatmap. You can read agent memory files (MEMORY.md, HEARTBEAT.md, daily notes) and edit workspace files, skills, and configuration with JSON validation and automatic backups. Host panels report CPU, memory, disk, and temperature with 24 hour sparklines, plus Docker containers, cron jobs, real-time logs, and one-click service restarts. A security page shows firewall rules, open ports, fail2ban status, and SSH login history, and sign-in uses PBKDF2 hashed passwords with optional TOTP two-factor codes. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. MIT licensed.

To pull a team's skills, MCP servers, hooks, prompts, and agent files out of scattered Git repositories, Observal keeps them in one reviewed registry and traces real sessions to show which ones help. Build an agent visually, with a live config preview for every harness. Submissions wait in an admin review queue, where reviewers inspect side-by-side version diffs before approving a release. Teamspaces give each team its own namespace, and approved releases can be forked into independent drafts. One pull command then writes the right config for Claude Code, Cursor, Kiro, Codex, Copilot, Pi, OpenCode, Antigravity, or Goose. Every approved resource is discoverable through the open Agentic Resource Discovery standard, and a running agent can hand part of its task to another approved agent or a remote Agent2Agent service. Hooks record each session as a trace of prompts, tool calls, MCP round trips, tokens, and errors, with turn-by-turn replay for debugging and audits. Insight reports, generated through providers such as Anthropic, OpenAI, or Ollama, list what is working, what is hindering, and quick wins. A dashboard follows adoption, cost, and department usage, a leaderboard ranks agents by downloads, and audit logs, SAML single sign-on, and SCIM provisioning are included. 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.

When an AI agent breaks in production, Tracely freezes that exact run into a replayable regression test and blocks the pull request that would ship the bug again. Span soup hides the failure. OTLP/HTTP traces group into conversation threads, and a waterfall marks the failing span in red with its input and output. Nobody knows if an answer was good. Evaluators sit as columns on the trace table, mixing model-free checks with LLM judges at conversation, run, or span level. Thirty-one broken runs, one issue. Clustering turns them into a single counted issue and can suggest the evaluator that would have caught it. A fix nobody can prove. One click promotes a failing trace into a hermetic case with recorded fixtures and a fail-to-pass contract, and scenarios send a red-team model after an adversarial goal. Model bills on every CI run. The suite replays offline with no API keys and no model spend, and tracely gate posts a commit status, comments on the pull request, and blocks regressions. No warning when it breaks again. Alert flows drawn on a canvas react to failed gates, broken conversations, unseen failure modes, or rising failure rates by messaging Slack, sending email, calling a webhook, or prompting an LLM. Coding agents can read traces and write evaluators through an MCP endpoint. 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 looping agent burns money quietly until someone can see where it drifted, and PandaProbe is an observability and evaluation platform for AI agents that makes that drift visible step by step. Capture complete executions as sessions, traces, and spans spanning model calls, tool calls, multi-agent handoffs, and custom logic, then follow a looping or failing run back to the decision where it drifted. Score traces and sessions with agent-specific metrics, run asynchronous and sampled evaluations so judge models do not cost more than inference, and use lightweight trajectory signals to catch stalls, bad tool use, and regressions over time. Bring agents built with LangGraph, CrewAI, the Claude Agent SDK, the OpenAI Agents SDK, and other integrations, with MCP tool calls captured automatically where supported. Organize work by user, organization, and project, send data through an SDK or HTTP API with project keys, and query filtered, paginated traces when you need the raw record. Keep sensitive workflows local when that matters: prompts, traces, and evaluation results stay inside the deployment you run, instead of leaving for a hosted console. 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.

Every call your AI agents make becomes a searchable trace in LangWatch, and the same platform tests and scores those agents before a new prompt or model reaches users. The Trace Explorer filters by origin, user, model, cost, and evaluator, reads each run as a waterfall, flame graph, topology, or sequence diagram, and takes traces from the Python, TypeScript, and Go SDKs or any OpenTelemetry source. Agent Testing sends simulated users, in text or beta voice calls, through your agent while a judge passes or fails every criterion with its reasoning, adds multi-turn red teaming, and compares two agents side by side. The Experiments workbench scores prompts and agents on datasets with LLM judges, exact match, and RAG checks, then compares runs on cost, latency, and pass rate, while online evaluations monitor live traffic and guardrails block unsafe replies. Prompts keep version history and staging or production tags, Workflows wire prompts, Python code, and HTTP calls on a visual canvas, and annotation queues route traces to human reviewers. Alerts fire when a graph crosses a threshold, automations post to Slack, email, or webhooks, and scheduled reports go out by email or Slack. Claude Code, Codex, Copilot, Gemini CLI, and opencode report session cost, pull request cost, and terminal replays, and an MCP server exposes trace search and prompt management to coding assistants. 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.

Backed by Y Combinator and trusted by over 2,300 companies processing billions of observations monthly, Langfuse is the most widely adopted open-source platform for building, monitoring, evaluating, and debugging LLM applications. The hierarchical tracing engine captures every LLM call, tool invocation, retrieval step, and agent action as nested spans based on OpenTelemetry, with automatic cost calculation, latency tracking, and token usage attribution across sessions and users. Prompt Management separates prompts from code with versioned artifacts, label-based deployments, one-click rollbacks, and runtime SDK fetching with server-side caching, while linking every generation back to its exact prompt version for attribution analytics. The evaluation system supports LLM-as-a-judge scoring, heuristic code evaluators, user feedback collection, and manual annotation workflows that run automatically on production traces or against curated datasets. The Playground enables interactive prompt testing on real production inputs with side-by-side model comparison across providers. Datasets and Experiments define test cases for systematic benchmarking with comparative result visualization. Native SDKs for Python and TypeScript provide decorator-based instrumentation, while 100+ integrations cover LangChain, LlamaIndex, OpenAI SDK, LiteLLM, Vercel AI SDK, and any OpenTelemetry-instrumented framework. The analytics dashboard surfaces cost breakdowns, quality scores, latency percentiles, and usage trends across models and prompt versions. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. MIT licensed.

Your AI application is burning through API tokens faster than you can refresh the billing page, and you have no idea which prompt template is responsible. OpenLIT plugs that visibility gap with a self-hosted observability platform built specifically for LLM workloads. Add one line of code to instrument 90+ LLM providers, agent frameworks, and vector databases, then watch every request flow through a tracing dashboard that shows tokens consumed, latency measured, and dollars spent per call, per model, per environment. The requests view lists every LLM interaction with provider, model, cost, and token breakdown in a filterable table, while the trace detail panel lets you drill into individual spans to read the exact prompt sent and response received. Prompt Hub turns prompts into versioned artifacts you deploy, rollback, and A/B test without touching application code. OpenGround compares models side by side on the same input, so you can evaluate cost-versus-quality tradeoffs before committing to a provider. Automated evaluations run LLM-as-a-judge scoring on live production traces, flagging hallucinations, bias, and toxicity in real time. The Vault stores and rotates API keys centrally so secrets stay out of your codebase. Custom dashboards let you build drag-and-drop monitoring views with charts, stat cards, and tables backed by SQL queries against ClickHouse. GPU utilization, memory, temperature, and power metrics feed into the same platform for end-to-end infrastructure visibility. 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.

Agenta delivers a comprehensive open-source LLMOps workspace that covers the full lifecycle of AI application development — from prompt engineering through production monitoring. The platform supports 15+ model providers including OpenAI, Anthropic, Google Gemini, Mistral, Groq, Together AI, Azure, AWS Bedrock, and self-hosted models via Ollama, enabling teams to switch between providers without code changes. The prompt playground allows side-by-side comparison of different configurations, while the evaluation system offers LLM-as-a-Judge assessment, 20+ pre-built evaluators covering semantic similarity, regex matching, and factual accuracy, plus custom Python evaluators for domain-specific requirements. Teams run evaluations through both the web UI for subject matter experts and the Evaluation SDK for programmatic CI/CD integration. The observability layer captures full trace visibility across complex agentic workflows, flagging quality issues like hallucinations and off-topic responses in real time. Human annotation workflows let domain experts review and annotate LLM outputs, feeding corrections back into the evaluation loop. The architecture supports Chain of Prompts, RAG pipelines, and multi-step agent workflows, integrating with frameworks like LangChain and LlamaIndex. Self-hosting deploys via Docker Compose with Traefik for routing, requiring only a clone, environment configuration, and a single docker compose command. On RepoCloud, deploy Agenta on a dedicated VPS with root SSH access, persistent storage for evaluation datasets and traces, and complete control over model provider credentials, all under the MIT license with no usage restrictions.

When an AI agent goes wrong at step seven of twelve, Opik, an open-source LLM observability platform, shows the exact trace, tool call, and prompt behind it, then scores your fix against test datasets. Full trace trees capture every LLM call, retrieval step, and tool execution, and you can annotate traces and spans with feedback scores in the UI or through the SDK. Native integrations for OpenAI, Anthropic, LangChain, LlamaIndex, CrewAI, Google ADK, and DSPy, plus OpenTelemetry for any language with an OpenTelemetry SDK, feed traces in, or add the @track decorator to your own functions. Datasets and experiments compare prompt and model versions, scored by LLM-as-a-judge metrics for hallucination, moderation, and RAG relevance, with a PyTest integration to run evaluations in CI. A Prompt Playground tests prompts across models, and the Agent Optimizer SDK helps improve prompts and agents. Production dashboards track feedback scores, trace counts, and token usage, online evaluation rules score live traces, and optional guardrails add safety checks. An MCP server lets Claude Code, Cursor, VS Code Copilot, Codex, or opencode read traces and run evaluations from chat. Run it yourself with the ./opik.sh script on Docker Compose, or a Helm chart on Kubernetes, so trace data stays in your infrastructure. 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.

Headroom answers the question every multi-plan AI subscriber asks mid-task: which of my accounts still has room to work? It puts the live limits, reset times, credits, and spend of Claude, Codex, Cursor, Copilot, Grok, Antigravity, and Vercel AI Gateway accounts on one self-hosted dashboard instead of seven provider pages. Connect each account once, through its official CLI sign-in or a credential import, and a background scheduler refreshes every figure on schedule, renews tokens before they expire, and keeps 90 days of readings. Five-hour sessions, weekly pools, per-model limits, credit balances, banked resets, and on-demand spend sit side by side, and unreported figures show as unknown rather than a fake zero. Compare ranks same-provider accounts by the room they have left and names the one to use next, while Timeline lays every reset window on a two-week calendar. Analytics charts when you work, when you run dry, and whether each plan fits, and Wallet totals subscriptions, usage spend, and top-ups in one currency with renewals and budget alerts. In-app notices, Telegram messages, and signed webhooks warn about low limits, expiring resets, and broken sign-ins, and optional automations can spend a banked Codex reset or log a credit top-up the moment it lands. Personal, work, and side-project accounts stay separate under one owner login with passkeys and a Privacy Mode that blurs emails on screen. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. MIT licensed.

Preloop is a self-hostable control plane that governs every AI agent tool call and model call, and can run ticket-triggered agent work that returns as reviewable pull requests. An MCP firewall can allow, deny, or hold any tool call for approval, with require-justification rules written as YAML and CEL policy. Human approvals arrive on mobile, watch, Slack, Mattermost, email, webhook, or the command line, and agents can ask a person a question before continuing. The model gateway speaks OpenAI, Anthropic, and Gemini formats, applies budgets and allowed-model lists, and attributes token spend by model, agent, session, API key, flow, and user. Flows start agents from GitHub, GitLab, Bitbucket Cloud, Jira, webhooks, or CI jobs, in hosted containers or on private runners that connect over an outbound WebSocket. Twenty-one presets review pull requests, implement issues, triage tickets, scan for vulnerabilities, and collect evidence packs. Operators can steer a running agent from the console, phone, or watch with notes, then review the resulting pull request. One session timeline records tool calls, model calls, policy decisions, approvals, spend, outcomes, and synchronized recordings. Fleet Map shows people, devices, agents, models, and observed work in one view. An account kill switch blocks gateway and tool traffic and stops managed runs, with audited recovery. 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.

Enterprises keep buying AI tools and wondering why output does not compound, when the real gap is governance: nobody can say which agent owns what, what it may touch, or what it cost. Ybkkasi answers those three questions in one console for every MCP server, skill, agent, and AI application you run. Register each asset and move it through a lifecycle state machine from discovery to retirement, with 85 permission points deciding who can view, call, publish, or approve at every step. Work itself is organized as goals that break into projects and tasks, assigned to digital employees who each carry a home organization, a human supervisor, and a roster status. Approvals route through a dedicated center where lifecycle changes and sensitive actions wait for a human decision instead of happening silently. Every call is metered, so usage and cost reports attribute spend by department, by agent, and by skill, making showback a query rather than an argument. The audit log records who did what to which asset and when, giving compliance a trail they can actually read. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. MIT licensed.

PandaDOS is a self-hosted control plane that turns Claude Code and Codex into long-running coding agents you direct through an issue queue from any browser, instead of babysitting a terminal. You file an issue with the outcome and acceptance criteria, and PandaDOS clarifies missing requirements, plans the work, picks the agent, and drives implementation, verification, and delivery in stages. Three approval levels, cautious, balanced, and automatic, decide which actions proceed alone; safe reversible steps continue automatically while destructive, irreversible, production, or secret-related decisions always come back to you. The browser workspace shows the real agent conversation, a native terminal, project files, Git history and diffs, and an execution summary, so you can inspect or intervene at any moment from a phone or laptop. Agents run on local or SSH-connected executor machines inside tmux sessions, and work sharing one repository is serialized while independent projects proceed in parallel without conflicting edits. Modules keep one assigned agent and durable project knowledge, so context from finished issues carries into the next task instead of evaporating when a chat ends. Teams can sign in through Feishu, ask the project manager questions in chat, and receive subscription notifications and approval cards on their phones. 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 change in chat, and LoopForge opens a Docker sandbox, checks out your repositories, hands the work to specialist agent roles, and opens the pull request. That is the conversational path: a Main Bot coordinates planning, implementation, review, and testing roles, each with its own prompt, executor, model, rules, skills, and tools, and you can queue or steer messages mid-reply, then pause, resume, or take over a run at any point. When a way of working proves itself, you freeze it as an SOP: a visual canvas of agent steps, deterministic script steps, human gates, and sub-workflows that every requirement then follows in the same order with the same checks. Four built-in SOPs cover backend delivery, frontend delivery, product proposals, and bug fixes, and each one can be copied, edited, and versioned per project. A Needs review inbox collects every gate waiting on you, with per-node status, tool traces, logs, and artifact snapshots as the evidence behind each approval. Recurring AI tasks run on schedules with the same workspace and workflow access, and insights reports track engineering metrics and token costs per run and per conversation. 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 team of coding agents, run in parallel from your desk, your browser, and your phone: Vicoa is an agentic IDE and control center, so one developer can steer a whole fleet instead of babysitting terminal tabs. Run 40+ coding agents side by side in one workspace: Claude Code, Codex, OpenCode, Gemini, Cursor, GitHub Copilot, Kimi, and more are built in, and 30+ additional agents connect through the Agent Client Protocol. Each agent gets its own git worktree and branch, so several can change one repository without overwriting each other, and every session's status sits in one list. Connect Mac, Windows or Linux machines, a VPS, or a remote server, pick where each session runs, and bring existing subscriptions or API keys. Start a session at your desk and steer it from the iOS or Android app on the train: approve a step, answer a question by dictation, or review the live git diff and file tree from your phone, with push notifications when an agent needs a decision or finishes. Plan work on the task board and start a session straight from a task, schedule cron automations that pick work up on their own, and share a live session link so teammates can watch or prompt alongside you. Host the backend and realtime server yourself with Docker, or drive everything from the CLI. 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.