# Can Agents Use

> Search agent-friendly tools by API, CLI, MCP, browser support, pricing clarity, docs quality, sandbox support, and account setup.

Can Agents Use is designed for both people and software agents. Prefer the agent interfaces below before scraping pages or touching a database. The public API, OpenAPI document, and MCP endpoint are read-only catalog surfaces.

## Agent Interfaces

- [Install guide](https://www.canagentsuse.com/agents): Human-readable guide for adding Can Agents Use to an agent with the CLI, MCP, skills, or direct JSON APIs.
- [Install JSON](https://www.canagentsuse.com/api/agent/install): Structured setup contract for agents choosing between CLI, MCP, skills, API, and Markdown surfaces.
- [CLI installer](https://www.npmjs.com/package/canagentsuse): Run `npx canagentsuse@latest setup --all-agents --yes` to install MCP config plus bundled skills for supported agents.
- [skills.sh skill](https://github.com/phuctm97/canagentsuse/tree/main/skills/can-agents-use): Fallback install path with `npx skills add phuctm97/canagentsuse --skill can-agents-use`.
- [Skill Markdown](https://www.canagentsuse.com/skill.md): Copyable SKILL.md-style fallback for agents that support persistent skills.
- [Catalog JSON](https://www.canagentsuse.com/api/agent/catalog): Full structured catalog with tools, categories, capabilities, and use cases.
- [Search JSON](https://www.canagentsuse.com/api/agent/search?q=stripe&page=1&limit=10): Query tools by name, category, capability, pricing, auth, docs, CLI, API, MCP, and browser support.
- [Tool JSON](https://www.canagentsuse.com/api/agent/tools/stripe): Stable per-tool record; replace "stripe" with any tool slug.
- [MCP endpoint](https://www.canagentsuse.com/api/mcp): Read-only JSON-RPC endpoint for agent clients that support MCP-style tool discovery and calls.
- [OpenAPI](https://www.canagentsuse.com/openapi.json): Machine-readable HTTP API contract.
- [Sitemap](https://www.canagentsuse.com/sitemap.xml): Human-readable pages for search and browsing.

## How To Use This Site As An Agent

- Fetch `/api/agent/install`, call MCP `get_agent_install_guide`, or read `canagentsuse://install` when you need setup instructions.
- Use `search_agent_tools` over MCP or `/api/agent/search` to discover candidates.
- Search results are paginated; default to `limit=10` and request the next `page` only when `hasMore` is true.
- For complete information, call MCP `get_agent_catalog`, read MCP resource `canagentsuse://catalog`, or fetch `/api/agent/catalog` once per session.
- Avoid paging through search when you need all records; fetch the full catalog and search locally in agent context.
- Use `get_agent_tool` or `/api/agent/tools/{slug}` before recommending a tool.
- Requests are read-only, cached, and bounded; never ask for or use database credentials.
- Treat scores and summaries as discovery signals, not legal, security, or purchasing approval.
- Check evidence URLs and official docs before taking irreversible action, spending money, or moving live customer data.

## Agent-Friendliness Score Model

- Machine operability: 25% (API, MCP, CLI, Browser fallback)
- Agent safety: 25% (Sandbox or test mode, Scoped auth, Dry-run or preview, Human review guidance, Idempotency or retry safety)
- Agent readability: 20% (Docs quality, Pricing clarity, Evidence links, Dedicated docs URL)
- Auth and setup: 15% (Account setup, Auth model clarity, Self-serve onboarding)
- Production reliability: 15% (Webhooks or events, Logs or audit trail, Versioned API, Rate limit clarity)

## Categories

- Billing & payments (billing-payments): Payments, subscriptions, invoicing, tax, and pricing APIs.
- AI models (ai-models): Model APIs, inference gateways, embeddings, reranking, and generation.
- Social media (social-media): Publishing, monitoring, community, and social APIs.
- Scraping & content (scraping-content): Web extraction, search, crawling, browser automation, and content APIs.
- Search & RAG (search-rag): Vector databases, search engines, retrieval APIs, and indexing tools.
- Databases & storage (databases-storage): Postgres, object storage, vector search, and data backends.
- Auth & accounts (auth-accounts): Authentication, identity, user management, and account flows.
- Deployment & infra (deployment-infra): Hosting, serverless, queues, workers, and cloud operations.
- Automation & integrations (automation-integrations): Workflow automation, connectors, forms, and cross-SaaS orchestration.
- Email & messaging (email-messaging): Transactional email, SMS, chat, and collaboration surfaces.
- CRM & sales (crm-sales): CRM records, support tickets, sales operations, and customer systems.
- Observability (observability): Errors, logs, analytics, monitoring, and product telemetry.
- Analytics & product (analytics-product): Product analytics, event pipelines, experiments, and business metrics.
- Project workflows (project-workflows): Issues, docs, CRM, spreadsheets, and team operations.
- Spreadsheets & data (spreadsheets-data): Sheets, no-code databases, forms, and lightweight operational data.
- Design & media (design-media): Design files, assets, images, uploads, transformations, and media workflows.
- Commerce (commerce): Stores, merchant operations, checkouts, tax, subscriptions, and order APIs.
- Support & success (support-success): Customer support, knowledge bases, tickets, chat, and helpdesk workflows.
- Self-hosted (self-hosted): Software that can run on user-controlled infrastructure.
- Analytics (selfhosted-analytics): Analytics is the systematic computational analysis of data or statistics. It is used for the discovery, interpretation, and communication of meaningful patterns in data.
- Archiving and Digital Preservation (DP) (selfhosted-archiving-and-digital-preservation-dp): Digital archiving and preservation software.
- Automation (selfhosted-automation): Automation software designed to reduce human intervention in processes.
- Blogging Platforms (selfhosted-blogging-platforms): A blog is a discussion or informational website consisting of discrete, diary-style text entries (posts).
- Booking and Scheduling (selfhosted-booking-and-scheduling): Event scheduling, reservation, and appointment management software.
- Bookmarks and Link Sharing (selfhosted-bookmarks-and-link-sharing): Software which allows users to add, annotate, edit, and share bookmarks) of web documents.
- Calendar & Contacts (selfhosted-calendar-and-contacts): CalDAV and CardDAV protocol servers and web clients/interfaces for Electronic calendar, address book and contact management.
- Communication - Custom Communication Systems (selfhosted-communication-custom-communication-systems): Communication software used to provide remote access to systems and exchange files and messages in text, audio and/or video formats between different computers or users, using their own custom protocols.
- Communication - Email - Complete Solutions (selfhosted-communication-email-complete-solutions): Simple deployment of E-mail servers, e.g. for inexperienced or impatient admins.
- Communication - Email - Mail Delivery Agents (selfhosted-communication-email-mail-delivery-agents): Mail Delivery Agents (MDAs) - IMAP/POP3 server software.
- Communication - Email - Mail Transfer Agents (selfhosted-communication-email-mail-transfer-agents): Mail Transfer Agents (MTAs) - SMTP servers.
- Communication - Email - Mailing Lists and Newsletters (selfhosted-communication-email-mailing-lists-and-newsletters): Mailing list servers and mass mailing software - one message to many recipients.
- Communication - Email - Webmail Clients (selfhosted-communication-email-webmail-clients): Webmail clients.
- Communication - IRC (selfhosted-communication-irc): IRC communication software.
- Communication - SIP (selfhosted-communication-sip): SIP/IPBX telephony software.
- Communication - Social Networks and Forums (selfhosted-communication-social-networks-and-forums): Social Networking and Forum software.
- Communication - Video Conferencing (selfhosted-communication-video-conferencing): Video/Web Conferencing tools and software.
- Communication - XMPP - Servers (selfhosted-communication-xmpp-servers): Extensible Messaging and Presence Protocol servers.
- Communication - XMPP - Web Clients (selfhosted-communication-xmpp-web-clients): Extensible Messaging and Presence Protocol Web clients/interfaces.
- Community-Supported Agriculture (CSA) (selfhosted-community-supported-agriculture-csa): Management and administration tools for community supported agriculture and food cooperatives.
- Conference Management (selfhosted-conference-management): Software for submission of abstracts and preparation/management of academic conferences.
- Content Management Systems (CMS) (selfhosted-content-management-systems-cms): Content Management Systems offer a practical way to setup a website with many features, using third party plugins, themes and functionality that are easy to add and customize.
- Customer Relationship Management (CRM) (selfhosted-customer-relationship-management-crm): Customer relationship management (CRM) is a strategic process that organizations use to manage, analyze, and improve their interactions with customers.
- Database Management (selfhosted-database-management): Web interfaces for database management. Includes tools for database analytics and visualization.
- DNS (selfhosted-dns): DNS servers and management tools with advertisement blocking functionality, primarily aimed at home or small networks.
- Document Management - E-books (selfhosted-document-management-e-books): Ebook library management software.
- Document Management - Institutional Repository and Digital Library Software (selfhosted-document-management-institutional-repository-and-digital-library-software): Institutional repository and digital library management software.
- Document Management - Integrated Library Systems (ILS) (selfhosted-document-management-integrated-library-systems-ils): An integrated library system is an enterprise resource planning system for a library, used to track items owned, orders made, bills paid, and patrons who have borrowed.
- Document Management (selfhosted-document-management): A document management system (DMS) is a system used to receive, track, manage and store documents and reduce paper.
- E-commerce (selfhosted-e-commerce): E-commerce software.
- Feed Readers (selfhosted-feed-readers): A news aggregator, also termed a feed aggregator, feed reader, news reader, RSS reader, is an application that aggregates web content such as newspapers/blogs/vlogs/podcasts in one location for easy viewing.
- File Transfer - Object Storage & File Servers (selfhosted-file-transfer-object-storage-and-file-servers): Object storage is a computer data storage that manages data as objects, as opposed to other storage architectures like file systems which manages data as a file hierarchy, and block storage which manages data as...
- File Transfer - Peer-to-peer Filesharing (selfhosted-file-transfer-peer-to-peer-filesharing): Peer-to-peer file sharing is the distribution and sharing of digital media using peer-to-peer (P2P) networking technology.
- File Transfer - Single-click & Drag-n-drop Upload (selfhosted-file-transfer-single-click-and-drag-n-drop-upload): Simplified file servers for sharing of one-time/short-lived/temporary files, providing single-click or drag-and-drop upload functionality.
- File Transfer - Web-based File Managers (selfhosted-file-transfer-web-based-file-managers): Web-based file managers.
- File Transfer & Synchronization (selfhosted-file-transfer-and-synchronization): File transfer, sharing and synchronization software software.
- Games - Administrative Utilities & Control Panels (selfhosted-games-administrative-utilities-and-control-panels): Utilities for managing game servers and game libraries.
- Games (selfhosted-games): Multiplayer game servers and browser games.
- Genealogy (selfhosted-genealogy): Genealogy software used to record, organize, and publish genealogical data.
- Generative Artificial Intelligence (GenAI) (selfhosted-generative-artificial-intelligence-genai): Generative Artificial Intelligence (GenAI) is a subset of artificial intelligence that uses generative models to produce text, images, videos, or other forms of data.
- Groupware (selfhosted-groupware): Collaborative software or groupware is designed to help people working on a common task to attain their goals. Groupware often regroups multiple services such as file sharing, calendar/events management, appointment...
- Health and Fitness (selfhosted-health-and-fitness): Medical, Health and Fitness software.
- Human Resources Management (HRM) (selfhosted-human-resources-management-hrm): A human resources management system combines a number of systems and processes to ensure the easy management of human resources, business processes and data.
- Internet of Things (IoT) (selfhosted-internet-of-things-iot): Internet of Things describes physical objects with sensors, processing ability, software, and other technologies that connect and exchange data with other devices over the Internet.
- Inventory Management (selfhosted-inventory-management): Inventory management software.
- Knowledge Management Tools (selfhosted-knowledge-management-tools): Knowledge management is the collection of methods relating to creating, sharing, using and managing the knowledge and information.
- Learning and Courses (selfhosted-learning-and-courses): Tools and software to help with education and learning.
- Manufacturing (selfhosted-manufacturing): Software to manage 3D printers, CNC machines and other physical manufacturing tools.
- Maps and Global Positioning System (GPS) (selfhosted-maps-and-global-positioning-system-gps): Maps, cartography, GIS and GPS software.
- Media Management (selfhosted-media-management): Digital media management tools and software.
- Media Streaming - Audio Streaming (selfhosted-media-streaming-audio-streaming): Audio streaming tools and software.
- Media Streaming - Multimedia Streaming (selfhosted-media-streaming-multimedia-streaming): Multimedia streaming tools and software.
- Media Streaming - Video Streaming (selfhosted-media-streaming-video-streaming): Video streaming tools and software.
- Miscellaneous (selfhosted-miscellaneous): Software that does not fit in another section.
- Money, Budgeting & Management (selfhosted-money-budgeting-and-management): Money management and budgeting software.
- Network Utilities (selfhosted-network-utilities): Network utilities are tools and software that help manage, monitor, and troubleshoot computer networks.
- Note-taking & Editors (selfhosted-note-taking-and-editors): Note taking editors.
- Office Suites (selfhosted-office-suites): An office suite is a collection of productivity software usually containing at least a word processor, spreadsheet and a presentation program.
- Password Managers (selfhosted-password-managers): A password manager allows users to store, generate, and manage their passwords for local applications and online services.
- Pastebins (selfhosted-pastebins): A pastebin is a type of online content-hosting service used for sharing and storing code and text.
- Personal Dashboards (selfhosted-personal-dashboards): Dashboards for accessing information and applications.
- Photo Galleries (selfhosted-photo-galleries): A gallery is software that helps the user publish or share photos, pictures, videos or other digital media.
- Polls and Events (selfhosted-polls-and-events): Software for organising polls and events.
- Proxy (selfhosted-proxy): A proxy is a server application that acts as an intermediary between a client requesting a resource and the server providing that resource. This section about forward (i.e. outgoing) proxies. For reverse proxies, see...
- Recipe Management (selfhosted-recipe-management): Software and tools for managing recipes.
- Remote Access (selfhosted-remote-access): Remote desktop and SSH servers and web interfaces for remote management of computer systems.
- Resource Planning (selfhosted-resource-planning): Software and tools to help with resource and supply planning, including enterprise resource and supply planning (ERP).
- Search Engines (selfhosted-search-engines): A search engine) is an information retrieval system designed to help find information stored on a computer system. This includes Web search engines.
- Self-hosting Solutions (selfhosted-self-hosting-solutions): Software for easy installation, management and configuration of self-hosted services and applications.
- Software Development - API Management (selfhosted-software-development-api-management): API management is the process of creating and publishing application programming interfaces (APIs), enforcing their usage policies, controlling access, nurturing the subscriber community, collecting and analyzing...
- Software Development - Feature Toggle (selfhosted-software-development-feature-toggle): A feature toggle in software development provides an alternative to maintaining multiple feature branches in source code.
- Software Development - IDE & Tools (selfhosted-software-development-ide-and-tools): An integrated development environment (IDE) is a software application that provides comprehensive facilities to computer programmers for software development.
- Software Development - Localization (selfhosted-software-development-localization): Localization is the process of adapting code and software to other languages.
- Software Development - Low Code (selfhosted-software-development-low-code): A low-code development platform (LCDP) provides a development environment used to create application software through a graphical user interface.
- Software Development - Project Management (selfhosted-software-development-project-management): Tools and software for software project management.
- Software Development - Testing (selfhosted-software-development-testing): Tools and software for software testing.
- Task Management & To-do Lists (selfhosted-task-management-and-to-do-lists): Task management software.
- Ticketing (selfhosted-ticketing): Helpdesk, bug and issue tracking software to help the tracking of user requests, bugs and missing features.
- Time Tracking (selfhosted-time-tracking): Time-tracking software is a category of computer software that allows its users to record time spent on tasks or projects.
- URL Shorteners (selfhosted-url-shorteners): URL shortening is the action of shortening a URL to make it substantially shorter and still direct to the required page. Before hosting one, please see disadvantages of URL shorteners.
- Video Surveillance (selfhosted-video-surveillance): Video surveillance, also known as Closed-circuit television (CCTV), is the use of video cameras for surveillance in areas that require additional security or ongoing monitoring.
- Web Servers (selfhosted-web-servers): Web Servers and Reverse Proxies. A web server is a piece of software and underlying hardware that accepts requests via HTTP (the network protocol created to distribute web content) or its secure variant HTTPS. A...
- Wikis (selfhosted-wikis): A wiki is a publication collaboratively edited and managed by its own audience directly using a web browser.

## Capabilities

- CLI (cli): Official or strong command-line workflow an agent can use locally.
- API (api): Documented API with machine-friendly auth and examples.
- MCP (mcp): Official or community MCP server for direct agent/tool integration.
- Browser (browser): Agent can operate the product through browser automation when needed.
- Account creation (account-creation): Signup and setup are clear enough for assisted or scripted onboarding.
- Pricing clarity (pricing-clarity): Pricing, limits, and free tiers are easy to inspect before use.
- Docs quality (docs-quality): Docs are complete enough for an agent to reason over safely.
- Sandbox (sandbox): Supports test mode, preview environments, or safe dry runs.

## Tools

### Stripe

- Slug: stripe
- URL: https://www.canagentsuse.com/tools/stripe
- Website: https://stripe.com
- Docs: https://docs.stripe.com
- Agent score: 96
- Agent tier: Native agent-ready
- Categories: Billing & payments
- Use cases: Charge a customer, Ship an app
- Best for: Billing setup, subscription catalogs, webhooks, and payment automation.
- Limitations: Stripe has test mode, test clocks, idempotency keys, request IDs, API versioning, webhook events, request logs, and documented rate limits; live money movement, tax, Connect onboarding, and compliance still need human review.
- Pricing: Public usage-based pricing with card processing, Billing, and add-on fees.
- Auth: API keys, restricted keys, OAuth for Connect, webhook secrets, API versioning, request IDs, idempotency keys, and OAuth or restricted-key auth for Stripe MCP.
- Account creation: Self-serve signup; live activation requires business verification.
- Browser support: Dashboard is usable by browser automation for review and setup gaps.
- CLI: stripe
- API base: https://api.stripe.com
- MCP server: https://mcp.stripe.com

Excellent for agents that need to create products, prices, checkout sessions, invoices, webhook tests, customer billing flows, inspect request logs, use idempotency keys, or connect Stripe's official MCP server from supported agent clients.

Score breakdown:
- Machine operability: 25/25
- Agent safety: 24.4/25
- Agent readability: 19/20
- Auth and setup: 13/15
- Production reliability: 15/15

Capabilities:
- CLI: native. Official CLI supports listen, trigger, fixtures, logs, and local webhook testing. Evidence: https://docs.stripe.com/stripe-cli
- API: native. Extensive REST APIs and typed SDKs for payments and billing. Evidence: https://docs.stripe.com/api
- MCP: native. Official remote MCP server exposes Stripe API tools and Stripe knowledge-base search; local @stripe/mcp is also available. Evidence: https://docs.stripe.com/mcp
- Browser: native. Dashboard is usable by browser automation for review and setup gaps. Evidence: https://stripe.com
- Account creation: strong. Self-serve signup; live activation requires business verification. Evidence: https://stripe.com
- Pricing clarity: strong. Public pricing pages and object-level cost concepts are well documented. Evidence: https://stripe.com/pricing
- Docs quality: native. Task-oriented docs include examples, API references, and testing guidance. Evidence: https://docs.stripe.com
- Sandbox: native. Test mode, test clocks, and separate MCP sandbox/live access make agent-created billing flows safer. Evidence: https://docs.stripe.com/test-mode

### GitHub

- Slug: github
- URL: https://www.canagentsuse.com/tools/github
- Website: https://github.com
- Docs: https://docs.github.com
- Agent score: 82
- Agent tier: Strong
- Categories: Project workflows, Deployment & infra
- Use cases: Ship an app, Triage work
- Best for: Repository operations, CI, code review, issue triage, and release flows.
- Limitations: Key limitations: Permission scopes and org policies matter; destructive git operations need guardrails. Deploys, secret changes, IAM, billing, networking, deletes, and rollback paths have high production blast radius; require scoped credentials and review gates. MCP servers inherit the connected account's scopes and may send prompts or data to third-party services; configure read-only or narrow scopes when available. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials.
- Pricing: Public pricing with free, Team, Enterprise, Actions, storage, and Copilot dimensions.
- Auth: Git credentials, fine-grained PATs, GitHub Apps, OAuth, device login, and remote MCP OAuth/PAT authentication.
- Account creation: Self-serve signup with email verification.
- Browser support: The web UI is agent-operable for logged-in workflows when APIs are insufficient.
- CLI: gh
- API base: https://api.github.com
- MCP server: https://api.githubcopilot.com/mcp/

Agents can create repos, push code, inspect issues, open PRs, run workflows, and read review feedback through CLI and APIs.

Score breakdown:
- Machine operability: 24/25
- Agent safety: 17.4/25
- Agent readability: 17.4/20
- Auth and setup: 13/15
- Production reliability: 10.2/15

Capabilities:
- CLI: native. Official gh CLI covers repo, PR, issue, release, workflow, and auth tasks. Evidence: https://cli.github.com/manual/
- API: native. REST and GraphQL APIs cover most platform data. Evidence: https://docs.github.com/en/rest
- MCP: native. GitHub's official MCP server supports repository, issue, pull request, Actions, code search, and support-doc workflows. Evidence: https://github.com/github/github-mcp-server
- Browser: strong. Browser flows are useful for settings and marketplace gaps. Evidence: https://docs.github.com
- Account creation: strong. Self-serve signup with email verification. Evidence: https://github.com
- Pricing clarity: strong. Public pricing with free, Team, Enterprise, Actions, storage, and Copilot dimensions. Evidence: https://github.com/pricing
- Docs quality: strong. Docs include API references, auth, webhooks, and Actions examples. Evidence: https://docs.github.com
- Sandbox: partial. The tool has documented test, local, preview, self-hosted, or staging paths that let agents validate changes away from production. Evidence: https://docs.github.com

### Terraform

- Slug: terraform
- URL: https://www.canagentsuse.com/tools/terraform
- Website: https://www.terraform.io
- Docs: https://developer.hashicorp.com/terraform/docs
- Agent score: 82
- Agent tier: Strong
- Categories: Deployment & infra
- Use cases: Manage infra, Ship an app
- Best for: Infrastructure provisioning, reviewable cloud changes, drift inspection, and repeatable environments.
- Limitations: Key limitations: Never let agents apply production plans without human review, locked state, and scoped credentials. Deploys, secret changes, IAM, billing, networking, deletes, and rollback paths have high production blast radius; require scoped credentials and review gates. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Open-source CLI plus HCP Terraform paid team/governance plans.
- Auth: Provider credentials, cloud tokens, HCP tokens, workspace permissions.
- Account creation: CLI is local; HCP Terraform is self-serve.
- Browser support: HCP Terraform UI supports plans, state, runs, and policy review.
- CLI: terraform
- API base: https://app.terraform.io/api/v2
- MCP server: Not listed

Very agent-friendly because changes can be proposed in code and reviewed through plan output before apply.

Score breakdown:
- Machine operability: 18/25
- Agent safety: 23.2/25
- Agent readability: 19/20
- Auth and setup: 12/15
- Production reliability: 9.4/15

Capabilities:
- CLI: native. CLI supports init, plan, validate, apply, import, state, and providers. Evidence: https://developer.hashicorp.com/terraform/cli
- API: strong. HCP Terraform API supports runs, workspaces, state versions, policies, and variables. Evidence: https://developer.hashicorp.com/terraform/cloud-docs/api-docs
- Browser: strong. HCP Terraform UI supports plans, state, runs, and policy review. Evidence: https://www.terraform.io
- Account creation: strong. CLI is local; HCP Terraform is self-serve. Evidence: https://www.terraform.io
- Pricing clarity: strong. Open-source CLI plus HCP Terraform paid team/governance plans. Evidence: https://github.com/hashicorp/terraform
- Docs quality: native. Docs include CLI, language, providers, and cloud API references. Evidence: https://developer.hashicorp.com/terraform/docs
- Sandbox: native. plan and validate provide reviewable dry-run behavior before apply. Evidence: https://developer.hashicorp.com/terraform/cli/commands/plan

### Cloudflare

- Slug: cloudflare
- URL: https://www.canagentsuse.com/tools/cloudflare
- Website: https://www.cloudflare.com
- Docs: https://developers.cloudflare.com
- Agent score: 81
- Agent tier: Strong
- Categories: Deployment & infra, Databases & storage, AI models
- Use cases: Ship an app, Manage infra, Call models
- Best for: Edge deployment, DNS, Workers, storage, observability, and agent infrastructure.
- Limitations: Key limitations: DNS, firewall, and production deployment changes need explicit human approval. Model behavior, costs, rate limits, data retention, and safety policies can change by model and account tier; use evals, spend caps, and data controls for sensitive workloads. MCP servers inherit the connected account's scopes and may send prompts or data to third-party services; configure read-only or narrow scopes when available. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials.
- Pricing: Public pricing across plans and usage-based developer products.
- Auth: API tokens with scoped permissions, OAuth, account IDs, and Wrangler login.
- Account creation: Self-serve signup.
- Browser support: Dashboard is important for account, DNS, logs, and billing review.
- CLI: wrangler
- API base: https://api.cloudflare.com/client/v4
- MCP server: https://mcp.cloudflare.com/mcp

Agents can deploy Workers, manage DNS, inspect analytics, provision storage, and connect through Cloudflare MCP servers.

Score breakdown:
- Machine operability: 24/25
- Agent safety: 20.4/25
- Agent readability: 17.4/20
- Auth and setup: 13/15
- Production reliability: 6.2/15

Capabilities:
- CLI: native. Wrangler CLI manages Workers, Pages, D1, KV, R2, and local dev. Evidence: https://developers.cloudflare.com/workers/wrangler/
- API: native. Cloudflare API reference covers account, DNS, Workers, Pages, R2, KV, and security products. Evidence: https://developers.cloudflare.com/api/
- MCP: native. Official Cloudflare MCP server exposes the Cloudflare API through token-efficient Code Mode; Cloudflare also publishes a docs MCP server. Evidence: https://github.com/cloudflare/mcp
- Browser: strong. Dashboard is important for account, DNS, logs, and billing review. Evidence: https://www.cloudflare.com
- Account creation: strong. Self-serve signup. Evidence: https://www.cloudflare.com
- Pricing clarity: strong. Public pricing across plans and usage-based developer products. Evidence: https://www.cloudflare.com/pricing
- Docs quality: strong. Official docs are listed for API behavior, authentication, limits, examples, and setup review. Evidence: https://developers.cloudflare.com
- Sandbox: strong. Local dev, preview deployments, and scoped API tokens support safer automation. Evidence: https://developers.cloudflare.com

### Playwright

- Slug: playwright
- URL: https://www.canagentsuse.com/tools/playwright
- Website: https://playwright.dev
- Docs: https://playwright.dev/docs/intro
- Agent score: 76
- Agent tier: Strong
- Categories: Scraping & content, Project workflows
- Use cases: Extract web data, Triage work, Ship an app
- Best for: Browser QA, screenshots, UI flows, and deterministic web automation.
- Limitations: Key limitations: Anti-bot rules and human-sensitive websites need care. Respect robots.txt, site terms, rate limits, copyright, authentication boundaries, and anti-bot controls before asking an agent to crawl or extract content. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Open source; infrastructure cost depends on where browsers run.
- Auth: No hosted account required for the local library.
- Account creation: No account needed.
- Browser support: It is browser automation.
- CLI: playwright
- API base: Not listed
- MCP server: Not listed

Great local primitive for agents that need to see, click, type, screenshot, and validate web apps.

Score breakdown:
- Machine operability: 21/25
- Agent safety: 16.4/25
- Agent readability: 17.4/20
- Auth and setup: 14/15
- Production reliability: 7/15

Capabilities:
- CLI: native. CLI supports install, test, codegen, screenshots, traces, and reports. Evidence: https://playwright.dev/docs/intro
- API: native. Node, Python, Java, and .NET APIs expose browser control. Evidence: https://playwright.dev/docs/intro
- Browser: native. Designed for direct browser operation and assertions. Evidence: https://playwright.dev/docs/intro
- Account creation: native. No account needed. Evidence: https://playwright.dev
- Pricing clarity: strong. Open source; infrastructure cost depends on where browsers run. Evidence: https://github.com/microsoft/playwright
- Docs quality: strong. Docs include testing, locators, auth state, traces, and CI recipes. Evidence: https://playwright.dev/docs/intro
- Sandbox: strong. The tool has documented test, local, preview, self-hosted, or staging paths that let agents validate changes away from production. Evidence: https://playwright.dev/docs/intro

### OpenAI

- Slug: openai
- URL: https://www.canagentsuse.com/tools/openai
- Website: https://openai.com
- Docs: https://platform.openai.com/docs
- Agent score: 74
- Agent tier: Usable
- Categories: AI models
- Use cases: Call models, Build RAG
- Best for: Model calls, embeddings, speech, image generation, evals, and agent backends.
- Limitations: Key limitations: Production agents need budget controls, data-handling review, prompt-injection defenses, and model-specific evals. Model behavior, costs, rate limits, data retention, and safety policies can change by model and account tier; use evals, spend caps, and data controls for sensitive workloads. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Public per-model usage pricing with separate input, output, cached, and media dimensions.
- Auth: API keys, project keys, organization/project scoping, and request IDs for support.
- Account creation: Self-serve signup; paid usage requires billing setup.
- Browser support: Dashboard is useful for keys, usage, logs, evals, and project setup.
- CLI: Not listed
- API base: https://api.openai.com/v1
- MCP server: Not listed

Agents can call chat, responses, embeddings, image, audio, realtime, and tool-oriented APIs with clear request and response schemas.

Score breakdown:
- Machine operability: 14/25
- Agent safety: 18.6/25
- Agent readability: 19/20
- Auth and setup: 12/15
- Production reliability: 10/15

Capabilities:
- API: native. REST API covers model, embedding, realtime, image, and audio workflows. Evidence: https://platform.openai.com/docs/api-reference
- Browser: strong. Dashboard is useful for keys, usage, logs, evals, and project setup. Evidence: https://openai.com
- Account creation: strong. Self-serve signup; paid usage requires billing setup. Evidence: https://openai.com
- Pricing clarity: strong. Pricing is public by model and modality. Evidence: https://platform.openai.com/docs/pricing
- Docs quality: native. API reference and guides include curl examples, SDKs, request IDs, and model-specific notes. Evidence: https://platform.openai.com/docs
- Sandbox: partial. Agents can test in separate projects and enforce usage limits before production rollout.

### Anthropic

- Slug: anthropic
- URL: https://www.canagentsuse.com/tools/anthropic
- Website: https://www.anthropic.com
- Docs: https://docs.anthropic.com
- Agent score: 73
- Agent tier: Usable
- Categories: AI models
- Use cases: Call models
- Best for: Claude-powered agents, tool use, document reasoning, and batch analysis.
- Limitations: Key limitations: Agents need spend limits, tool permission boundaries, and review for high-impact automated decisions. Model behavior, costs, rate limits, data retention, and safety policies can change by model and account tier; use evals, spend caps, and data controls for sensitive workloads. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Public per-token model pricing with cache and batch concepts documented.
- Auth: API keys, workspace/admin controls, and request IDs.
- Account creation: Self-serve Console signup with billing for paid API use.
- Browser support: Console supports keys, usage, workbench testing, and workspace settings.
- CLI: Not listed
- API base: https://api.anthropic.com
- MCP server: Not listed

Strong for agents that need tool-calling, long-context reasoning, batch work, and clear model behavior documentation.

Score breakdown:
- Machine operability: 14/25
- Agent safety: 18.6/25
- Agent readability: 19/20
- Auth and setup: 12/15
- Production reliability: 9.4/15

Capabilities:
- API: native. Messages API supports tool use, streaming, files, batches, and model operations. Evidence: https://docs.anthropic.com/en/api/messages
- Browser: strong. Console supports keys, usage, workbench testing, and workspace settings. Evidence: https://www.anthropic.com
- Account creation: strong. Self-serve Console signup with billing for paid API use. Evidence: https://www.anthropic.com
- Pricing clarity: strong. Model pricing is public and separated by input, output, cache, and batch usage. Evidence: https://www.anthropic.com/pricing#anthropic-api
- Docs quality: native. Docs include API reference, tool-use guidance, prompt caching, and model behavior notes. Evidence: https://docs.anthropic.com
- Sandbox: partial. Console/workbench and low-risk API keys support staged testing.

### Firecrawl

- Slug: firecrawl
- URL: https://www.canagentsuse.com/tools/firecrawl
- Website: https://firecrawl.dev
- Docs: https://docs.firecrawl.dev
- Agent score: 62
- Agent tier: Usable
- Categories: Scraping & content
- Use cases: Extract web data, Triage work
- Best for: Crawling websites, extracting markdown, and feeding research workflows.
- Limitations: Key limitations: Respect robots, terms, rate limits, and content ownership. Respect robots.txt, site terms, rate limits, copyright, authentication boundaries, and anti-bot controls before asking an agent to crawl or extract content. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Public free and paid tiers based on credits and extraction volume.
- Auth: API key.
- Account creation: Self-serve account and API key flow.
- Browser support: Dashboard exists for keys and usage; primary path is API.
- CLI: Not listed
- API base: https://api.firecrawl.dev
- MCP server: Not listed

Useful when an agent needs to inspect websites without writing browser orchestration from scratch.

Score breakdown:
- Machine operability: 14/25
- Agent safety: 10.4/25
- Agent readability: 17.4/20
- Auth and setup: 10.5/15
- Production reliability: 9.4/15

Capabilities:
- API: native. API-first scraping and crawl endpoints. Evidence: https://docs.firecrawl.dev/api-reference
- Browser: strong. Dashboard exists for keys and usage; primary path is API. Evidence: https://firecrawl.dev
- Account creation: strong. Self-serve account and API key flow. Evidence: https://firecrawl.dev
- Pricing clarity: strong. Credit-oriented pricing is visible before implementation. Evidence: https://docs.firecrawl.dev
- Docs quality: strong. Docs are organized around scrape, crawl, map, extract, and SDK flows. Evidence: https://docs.firecrawl.dev

### Kubernetes

- Slug: kubernetes
- URL: https://www.canagentsuse.com/tools/kubernetes
- Website: https://kubernetes.io
- Docs: https://kubernetes.io/docs
- Agent score: 85
- Agent tier: Strong
- Categories: Deployment & infra
- Use cases: Manage infra, Ship an app
- Best for: Cluster operations, deployments, rollouts, logs, events, and declarative app infrastructure.
- Limitations: Key limitations: Cluster-wide permissions, secrets, deletes, and production rollouts need strict human review. Deploys, secret changes, IAM, billing, networking, deletes, and rollback paths have high production blast radius; require scoped credentials and review gates. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Open-source; managed cluster pricing depends on cloud provider.
- Auth: Kubeconfig, RBAC, service accounts, contexts, and admission policies.
- Account creation: Local clusters or managed cloud clusters; no central signup.
- Browser support: Dashboards vary; CLI is usually better for agents.
- CLI: kubectl
- API base: https://kubernetes.default.svc
- MCP server: Not listed

Agents can inspect clusters, propose manifests, diff/apply changes, and read logs if RBAC is scoped tightly.

Score breakdown:
- Machine operability: 20/25
- Agent safety: 22.4/25
- Agent readability: 17.4/20
- Auth and setup: 12/15
- Production reliability: 12.8/15

Capabilities:
- CLI: native. kubectl supports get, describe, logs, diff, apply, rollout, and dry-run workflows. Evidence: https://kubernetes.io/docs/reference/kubectl/
- API: native. Kubernetes API reference covers resources and operations. Evidence: https://kubernetes.io/docs/reference/kubernetes-api/
- Browser: strong. Dashboards vary; CLI is usually better for agents. Evidence: https://kubernetes.io
- Account creation: strong. Local clusters or managed cloud clusters; no central signup. Evidence: https://kubernetes.io
- Pricing clarity: strong. Open-source; managed cluster pricing depends on cloud provider. Evidence: https://github.com/kubernetes/kubernetes
- Docs quality: strong. Docs are comprehensive and versioned. Evidence: https://kubernetes.io/docs/
- Sandbox: strong. dry-run, local clusters, namespaces, and RBAC make staged changes possible. Evidence: https://kubernetes.io/docs/reference/using-api/api-concepts/

### Shopify

- Slug: shopify
- URL: https://www.canagentsuse.com/tools/shopify
- Website: https://www.shopify.com
- Docs: https://shopify.dev/docs
- Agent score: 84
- Agent tier: Strong
- Categories: Commerce, Billing & payments
- Use cases: Charge a customer, Publish content
- Best for: Storefronts, products, orders, app development, checkout integrations, and commerce workflows.
- Limitations: Key limitations: Orders, inventory, customer data, payments, and app review requirements need human review. Live payments, refunds, payouts, tax, disputes, and business verification can move money or create compliance exposure; keep agents in sandbox or test mode until a human approves live changes. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Public store plans and app billing concepts; merchant costs vary by plan/add-ons.
- Auth: OAuth apps, access scopes, app proxies, webhooks, and custom app tokens.
- Account creation: Self-serve stores and development stores through partner/dev flows.
- Browser support: Admin UI is important for app setup, products, and merchant review.
- CLI: shopify
- API base: https://{shop}.myshopify.com/admin/api
- MCP server: Not listed

Agents can manage commerce data, build apps, subscribe to webhooks, and test in development stores with careful scopes.

Score breakdown:
- Machine operability: 20/25
- Agent safety: 21.2/25
- Agent readability: 17.4/20
- Auth and setup: 12/15
- Production reliability: 13.4/15

Capabilities:
- CLI: native. Shopify CLI supports app and theme development, dev stores, config, and deploy workflows. Evidence: https://shopify.dev/docs/api/shopify-cli
- API: native. Shopify Admin GraphQL, Storefront API, and webhooks cover commerce operations. Evidence: https://shopify.dev/docs/api
- Browser: strong. Admin UI is important for app setup, products, and merchant review. Evidence: https://www.shopify.com
- Account creation: strong. Self-serve stores and development stores through partner/dev flows. Evidence: https://www.shopify.com
- Pricing clarity: strong. Public store plans and app billing concepts; merchant costs vary by plan/add-ons. Evidence: https://www.shopify.com/pricing
- Docs quality: strong. Docs include API reference, CLI, webhooks, app auth, and checkout guidance. Evidence: https://shopify.dev/docs
- Sandbox: strong. Development stores and Bogus Gateway support testing. Evidence: https://shopify.dev/docs/apps/build/authentication-authorization/access-tokens

### Salesforce

- Slug: salesforce
- URL: https://www.canagentsuse.com/tools/salesforce
- Website: https://www.salesforce.com
- Docs: https://developer.salesforce.com/docs
- Agent score: 83
- Agent tier: Strong
- Categories: CRM & sales
- Use cases: Sync CRM, Triage work
- Best for: Enterprise CRM, metadata deployments, customer records, integrations, and sales operations.
- Limitations: Key limitations: Production org writes, PII, workflows, and metadata deployments need admin review. Verify official docs, pricing, rate limits, permissions, and production side effects before delegating account-changing actions to an agent. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Public editions and add-ons; enterprise pricing and API limits can be complex.
- Auth: OAuth, connected apps, JWT bearer flow, profiles, permission sets, and org scopes.
- Account creation: Developer orgs are self-serve; enterprise orgs are contracted.
- Browser support: Setup UI is central for permissions, apps, and schema review.
- CLI: sf
- API base: https://login.salesforce.com/services/data
- MCP server: Not listed

Agents can automate CRM and metadata workflows, but enterprise permissions and object models require careful setup.

Score breakdown:
- Machine operability: 21/25
- Agent safety: 23.2/25
- Agent readability: 17.4/20
- Auth and setup: 12/15
- Production reliability: 9.4/15

Capabilities:
- CLI: native. Salesforce CLI supports org auth, metadata deploys, data operations, and scratch orgs. Evidence: https://developer.salesforce.com/tools/salesforcecli
- API: native. Salesforce has REST, SOAP, Bulk, Metadata, and Tooling APIs. Evidence: https://developer.salesforce.com/docs/apis
- Browser: native. Setup UI is central for permissions, apps, and schema review. Evidence: https://www.salesforce.com
- Account creation: strong. Developer orgs are self-serve; enterprise orgs are contracted. Evidence: https://www.salesforce.com
- Pricing clarity: strong. Public editions and add-ons; enterprise pricing and API limits can be complex. Evidence: https://www.salesforce.com/pricing
- Docs quality: strong. Developer docs are broad but require platform expertise. Evidence: https://developer.salesforce.com/docs
- Sandbox: native. Sandboxes and scratch orgs support safer agent testing. Evidence: https://developer.salesforce.com/docs/platform/sfvscode-extensions/guide/scratch-orgs.html

### Netlify

- Slug: netlify
- URL: https://www.canagentsuse.com/tools/netlify
- Website: https://www.netlify.com
- Docs: https://docs.netlify.com
- Agent score: 82
- Agent tier: Strong
- Categories: Deployment & infra
- Use cases: Ship an app, Manage infra
- Best for: Frontend deployment, previews, static sites, serverless functions, and build automation.
- Limitations: Key limitations: Production aliases, env vars, and build settings need review. Deploys, secret changes, IAM, billing, networking, deletes, and rollback paths have high production blast radius; require scoped credentials and review gates. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Public seat and usage-based pricing with free tier.
- Auth: OAuth, personal access tokens, team/site permissions.
- Account creation: Self-serve signup.
- Browser support: Dashboard supports sites, deploy logs, domains, billing, and env vars.
- CLI: netlify
- API base: https://api.netlify.com/api/v1
- MCP server: Not listed

Agents can deploy static/front-end apps, inspect deploys, manage environment variables, and automate builds.

Score breakdown:
- Machine operability: 20/25
- Agent safety: 21.2/25
- Agent readability: 19/20
- Auth and setup: 12/15
- Production reliability: 9.4/15

Capabilities:
- CLI: native. Netlify CLI supports deploys, dev server, functions, env, and site operations. Evidence: https://docs.netlify.com/cli/get-started/
- API: native. Netlify API supports sites, deploys, forms, hooks, DNS, and environment variables. Evidence: https://open-api.netlify.com/
- Browser: strong. Dashboard supports sites, deploy logs, domains, billing, and env vars. Evidence: https://www.netlify.com
- Account creation: strong. Self-serve signup. Evidence: https://www.netlify.com
- Pricing clarity: strong. Public seat and usage-based pricing with free tier. Evidence: https://www.netlify.com/pricing
- Docs quality: native. Official docs are listed for API behavior, authentication, limits, examples, and setup review. Evidence: https://docs.netlify.com
- Sandbox: strong. Deploy previews and branch deploys support safer review workflows. Evidence: https://docs.netlify.com/site-deploys/deploy-previews/

### Supabase

- Slug: supabase
- URL: https://www.canagentsuse.com/tools/supabase
- Website: https://supabase.com
- Docs: https://supabase.com/docs
- Agent score: 82
- Agent tier: Strong
- Categories: Databases & storage, Auth & accounts
- Use cases: Ship an app, Manage users
- Best for: App backends, database-first prototypes, auth, storage, and realtime features.
- Limitations: Key limitations: RLS policies require careful review before exposing data. Schema changes, migrations, deletes, backups, row-level security, and retention policies need explicit review before agents touch production data. MCP servers inherit the connected account's scopes and may send prompts or data to third-party services; configure read-only or narrow scopes when available. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials.
- Pricing: Public project-based pricing with free tier and usage add-ons.
- Auth: Project API keys, JWTs, service role keys, OAuth providers, and hosted MCP OAuth or access-token auth.
- Account creation: Self-serve signup; organizations and billing for production scale.
- Browser support: Dashboard is strong for setup and inspection.
- CLI: supabase
- API base: Not listed
- MCP server: https://mcp.supabase.com/mcp

Agents can create schemas, run local stacks, manage migrations, generate types, query projects, inspect logs, and use Supabase's hosted MCP server with read-only and project-scoped options.

Score breakdown:
- Machine operability: 24/25
- Agent safety: 19.2/25
- Agent readability: 19/20
- Auth and setup: 12/15
- Production reliability: 8/15

Capabilities:
- CLI: native. CLI supports local dev, migrations, generated types, functions, and linking. Evidence: https://supabase.com/docs
- API: native. PostgREST, auth, storage, realtime, and management APIs are documented. Evidence: https://supabase.com/docs
- MCP: native. Official Supabase MCP server covers database, debugging, development, Edge Functions, branching, and docs tools with scope/read-only controls. Evidence: https://supabase.com/docs/guides/ai-tools/mcp
- Browser: strong. Dashboard is strong for setup and inspection. Evidence: https://supabase.com
- Account creation: strong. Self-serve signup; organizations and billing for production scale. Evidence: https://supabase.com
- Pricing clarity: strong. Public project-based pricing with free tier and usage add-ons. Evidence: https://supabase.com/pricing
- Docs quality: native. Official docs are listed for API behavior, authentication, limits, examples, and setup review. Evidence: https://supabase.com/docs
- Sandbox: strong. Local Docker stack is excellent for agent-safe development. Evidence: https://supabase.com/docs

### Docker

- Slug: docker
- URL: https://www.canagentsuse.com/tools/docker
- Website: https://www.docker.com
- Docs: https://docs.docker.com
- Agent score: 81
- Agent tier: Strong
- Categories: Deployment & infra
- Use cases: Manage infra, Ship an app
- Best for: Local dev environments, container builds, integration tests, and deployment artifacts.
- Limitations: Key limitations: Agents need limits around privileged containers, volume mounts, secrets, and registry pushes. Deploys, secret changes, IAM, billing, networking, deletes, and rollback paths have high production blast radius; require scoped credentials and review gates. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Public Docker Desktop/Hub/team pricing plus open-source Engine components.
- Auth: Local daemon access, Docker Hub tokens, registry credentials, and contexts.
- Account creation: CLI can be local; Docker Hub signup is self-serve.
- Browser support: Desktop and Hub UI help inspect images, repos, and billing.
- CLI: docker
- API base: http://localhost/v1.45
- MCP server: Not listed

Agents can build, run, inspect, test, and compose local services with repeatable commands and logs.

Score breakdown:
- Machine operability: 18.5/25
- Agent safety: 23.2/25
- Agent readability: 17.4/20
- Auth and setup: 12/15
- Production reliability: 9.4/15

Capabilities:
- CLI: native. Docker CLI and Compose CLI cover build, run, logs, exec, compose, and registry workflows. Evidence: https://docs.docker.com/reference/
- API: native. Docker Engine API provides programmatic daemon access. Evidence: https://docs.docker.com/reference/api/engine/
- Browser: partial. Desktop and Hub UI help inspect images, repos, and billing. Evidence: https://www.docker.com
- Account creation: strong. CLI can be local; Docker Hub signup is self-serve. Evidence: https://www.docker.com
- Pricing clarity: strong. Public Docker Desktop/Hub/team pricing plus open-source Engine components. Evidence: https://github.com/docker
- Docs quality: strong. Docs include CLI, API, Compose, Dockerfile, and security references. Evidence: https://docs.docker.com/
- Sandbox: native. Local containers provide isolated repeatable test environments. Evidence: https://docs.docker.com

### Pulumi

- Slug: pulumi
- URL: https://www.canagentsuse.com/tools/pulumi
- Website: https://www.pulumi.com
- Docs: https://www.pulumi.com/docs
- Agent score: 81
- Agent tier: Strong
- Categories: Deployment & infra
- Use cases: Manage infra, Ship an app
- Best for: Programmable IaC, previewed infra changes, multi-cloud provisioning, and automation APIs.
- Limitations: Key limitations: Apply/update operations can change production infrastructure; require review and scoped stack tokens. Deploys, secret changes, IAM, billing, networking, deletes, and rollback paths have high production blast radius; require scoped credentials and review gates. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Open-source CLI plus public Pulumi Cloud pricing.
- Auth: Pulumi access tokens, cloud provider credentials, ESC environments, and stack permissions.
- Account creation: CLI can run locally; Pulumi Cloud self-serve signup.
- Browser support: Pulumi Cloud UI supports stacks, previews, resources, and audit review.
- CLI: pulumi
- API base: https://api.pulumi.com
- MCP server: Not listed

Agents can propose infrastructure as code, run previews, and call Pulumi Cloud APIs with JSON output.

Score breakdown:
- Machine operability: 20/25
- Agent safety: 23.2/25
- Agent readability: 17.4/20
- Auth and setup: 12/15
- Production reliability: 8.8/15

Capabilities:
- CLI: native. CLI supports preview, up, destroy, stack, config, and JSON output. Evidence: https://www.pulumi.com/docs/iac/cli/
- API: native. pulumi api can call Pulumi Cloud REST endpoints non-interactively. Evidence: https://www.pulumi.com/docs/iac/cli/api/
- Browser: strong. Pulumi Cloud UI supports stacks, previews, resources, and audit review. Evidence: https://www.pulumi.com
- Account creation: strong. CLI can run locally; Pulumi Cloud self-serve signup. Evidence: https://www.pulumi.com
- Pricing clarity: strong. Open-source CLI plus public Pulumi Cloud pricing. Evidence: https://github.com/pulumi/pulumi
- Docs quality: strong. Docs cover CLI, SDKs, Automation API, and cloud APIs. Evidence: https://www.pulumi.com/docs/
- Sandbox: native. Preview provides a dry-run before infrastructure updates. Evidence: https://www.pulumi.com/docs/iac/cli/commands/pulumi_preview/

### PlanetScale

- Slug: planetscale
- URL: https://www.canagentsuse.com/tools/planetscale
- Website: https://planetscale.com
- Docs: https://planetscale.com/docs
- Agent score: 80
- Agent tier: Strong
- Categories: Databases & storage
- Use cases: Ship an app, Manage infra
- Best for: Database branching, schema review, deploy requests, and agent-safe data workflows.
- Limitations: Key limitations: Production schema deploys and data changes need review and backups. Schema changes, migrations, deletes, backups, row-level security, and retention policies need explicit review before agents touch production data. MCP servers inherit the connected account's scopes and may send prompts or data to third-party services; configure read-only or narrow scopes when available. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials.
- Pricing: Public pricing by organization, database, storage, and usage.
- Auth: OAuth login, service tokens, org/database permissions, and CLI config.
- Account creation: Self-serve signup.
- Browser support: Dashboard helps review branches, deploy requests, and usage.
- CLI: pscale
- API base: https://api.planetscale.com
- MCP server: pscale mcp server

Agents can branch databases, inspect schemas, manage deploy requests, and use CLI/MCP surfaces for database workflows.

Score breakdown:
- Machine operability: 24/25
- Agent safety: 21.2/25
- Agent readability: 17.4/20
- Auth and setup: 12/15
- Production reliability: 5.6/15

Capabilities:
- CLI: native. pscale CLI includes API passthrough, branch workflows, and MCP install/server commands. Evidence: https://planetscale.com/cli
- API: native. PlanetScale API supports databases, branches, deploy requests, and service tokens. Evidence: https://planetscale.com/docs/api/reference/service-tokens
- MCP: native. CLI exposes MCP install and server commands for agent clients. Evidence: https://planetscale.com/cli
- Browser: strong. Dashboard helps review branches, deploy requests, and usage. Evidence: https://planetscale.com
- Account creation: strong. Self-serve signup. Evidence: https://planetscale.com
- Pricing clarity: strong. Public pricing by organization, database, storage, and usage. Evidence: https://planetscale.com/pricing
- Docs quality: strong. Official docs are listed for API behavior, authentication, limits, examples, and setup review. Evidence: https://planetscale.com/docs
- Sandbox: native. Database branching provides safe review environments. Evidence: https://planetscale.com/docs

### Twilio

- Slug: twilio
- URL: https://www.canagentsuse.com/tools/twilio
- Website: https://www.twilio.com
- Docs: https://www.twilio.com/docs
- Agent score: 80
- Agent tier: Strong
- Categories: Email & messaging, Automation & integrations
- Use cases: Publish content, Triage work
- Best for: SMS, WhatsApp, voice, notifications, contact-center prototypes, and communication workflows.
- Limitations: Key limitations: Outbound messaging, phone numbers, consent, compliance, and spend need strict human review. Outbound messages, SMS, email deliverability, consent, unsubscribe behavior, private chats, and customer-facing replies need approval, throttling, and audit logs. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Public per-channel usage pricing by destination and product.
- Auth: Account SID/Auth Token, API keys, subaccounts, OAuth for some products, and webhook signatures.
- Account creation: Self-serve trial with phone verification; production messaging requires compliance setup.
- Browser support: Console is important for number setup, logs, messaging compliance, and billing.
- CLI: twilio
- API base: https://api.twilio.com/2010-04-01
- MCP server: Not listed

Agents can send messages, manage numbers, inspect logs, and automate communications when compliance and approvals are enforced.

Score breakdown:
- Machine operability: 20/25
- Agent safety: 18.2/25
- Agent readability: 19/20
- Auth and setup: 12/15
- Production reliability: 10.4/15

Capabilities:
- CLI: native. Twilio CLI manages resources from the terminal. Evidence: https://www.twilio.com/docs/twilio-cli/quickstart
- API: native. Docs cover messaging, voice, conversations, verification, OpenAPI, SDKs, and webhooks. Evidence: https://www.twilio.com/docs
- Browser: strong. Console is important for number setup, logs, messaging compliance, and billing. Evidence: https://www.twilio.com
- Account creation: strong. Self-serve trial with phone verification; production messaging requires compliance setup. Evidence: https://www.twilio.com
- Pricing clarity: strong. Channel and destination pricing is public. Evidence: https://www.twilio.com/en-us/pricing
- Docs quality: native. Docs include quickstarts, SDKs, API refs, OpenAPI, Postman, status, and error codes. Evidence: https://www.twilio.com/docs
- Sandbox: partial. The tool has documented test, local, preview, self-hosted, or staging paths that let agents validate changes away from production. Evidence: https://www.twilio.com/docs

### PostHog

- Slug: posthog
- URL: https://www.canagentsuse.com/tools/posthog
- Website: https://posthog.com
- Docs: https://posthog.com/docs
- Agent score: 79
- Agent tier: Strong
- Categories: Analytics & product, Observability
- Use cases: Analyze product, Triage work
- Best for: Product analytics, feature flags, experiments, session replay, and event pipelines.
- Limitations: Key limitations: User analytics and recordings may contain PII; use privacy controls and scoped keys. Issue resolution, alert muting, analytics interpretation, PII in logs, sampling, and retention settings can hide incidents or expose user data if automated too broadly. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Public usage-based pricing with free allowances.
- Auth: Project API keys, personal API keys, roles, and organization permissions.
- Account creation: Self-serve cloud signup or self-hosting.
- Browser support: Dashboard is important for insights, flags, and replay review.
- CLI: Not listed
- API base: https://app.posthog.com/api
- MCP server: Not listed

Agents can send events, query product data, manage flags, and inspect behavior with open-source-friendly docs.

Score breakdown:
- Machine operability: 14/25
- Agent safety: 21.6/25
- Agent readability: 18.4/20
- Auth and setup: 12/15
- Production reliability: 12.8/15

Capabilities:
- API: native. Docs cover capture, query, feature flag, persons, projects, and data pipeline APIs. Evidence: https://posthog.com/docs/api
- Browser: strong. Dashboard is important for insights, flags, and replay review. Evidence: https://posthog.com
- Account creation: strong. Self-serve cloud signup or self-hosting. Evidence: https://posthog.com
- Pricing clarity: native. Pricing is public by event/session/replay usage with free tiers. Evidence: https://posthog.com/pricing
- Docs quality: strong. Docs include product analytics, flags, experiments, replay, and self-hosting. Evidence: https://posthog.com/docs
- Sandbox: strong. Self-hosting and test projects support safer experimentation. Evidence: https://posthog.com/docs

### Vercel

- Slug: vercel
- URL: https://www.canagentsuse.com/tools/vercel
- Website: https://vercel.com
- Docs: https://vercel.com/docs
- Agent score: 79
- Agent tier: Strong
- Categories: Deployment & infra
- Use cases: Ship an app, Triage work
- Best for: Next.js deployment, preview URLs, build diagnostics, and production releases.
- Limitations: Key limitations: Environment variable and production deploy permissions need tight control. Deploys, secret changes, IAM, billing, networking, deletes, and rollback paths have high production blast radius; require scoped credentials and review gates. MCP servers inherit the connected account's scopes and may send prompts or data to third-party services; configure read-only or narrow scopes when available. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials.
- Pricing: Public pricing with free, Pro, Enterprise, bandwidth, and function usage dimensions.
- Auth: CLI login, tokens, team scopes, Git provider auth, and OAuth for the hosted Vercel MCP server.
- Account creation: Self-serve signup via Git providers or email.
- Browser support: Dashboard is important for project settings, logs, and billing.
- CLI: vercel
- API base: Not listed
- MCP server: https://mcp.vercel.com

Agents can deploy previews, inspect builds, manage projects, read deployment logs, search docs, and connect through Vercel's hosted MCP server.

Score breakdown:
- Machine operability: 24/25
- Agent safety: 16.2/25
- Agent readability: 19/20
- Auth and setup: 12/15
- Production reliability: 8/15

Capabilities:
- CLI: native. CLI supports deploys, builds, env, logs, projects, and domains. Evidence: https://vercel.com/docs
- API: native. REST API supports deployment and project automation. Evidence: https://vercel.com/docs
- MCP: native. Vercel's official remote MCP server searches docs, manages projects and deployments, and analyzes deployment logs. Evidence: https://vercel.com/docs/agent-resources/vercel-mcp
- Browser: strong. Dashboard helps inspect builds, analytics, and configuration. Evidence: https://vercel.com/docs
- Account creation: strong. Self-serve signup via Git providers or email. Evidence: https://vercel.com
- Pricing clarity: strong. Public pricing with free, Pro, Enterprise, bandwidth, and function usage dimensions. Evidence: https://vercel.com/pricing
- Docs quality: native. Official docs are listed for API behavior, authentication, limits, examples, and setup review. Evidence: https://vercel.com/docs
- Sandbox: partial. The tool has documented test, local, preview, self-hosted, or staging paths that let agents validate changes away from production. Evidence: https://vercel.com/docs

### Google Cloud

- Slug: google-cloud
- URL: https://www.canagentsuse.com/tools/google-cloud
- Website: https://cloud.google.com
- Docs: https://cloud.google.com/docs
- Agent score: 78
- Agent tier: Strong
- Categories: Deployment & infra, Databases & storage, AI models, Analytics & product
- Use cases: Manage infra, Ship an app, Analyze product
- Best for: Cloud Run, BigQuery, GKE, storage, analytics, and AI platform operations.
- Limitations: Key limitations: IAM, billing, production data, and infrastructure changes need human approval. Model behavior, costs, rate limits, data retention, and safety policies can change by model and account tier; use evals, spend caps, and data controls for sensitive workloads. MCP servers inherit the connected account's scopes and may send prompts or data to third-party services; configure read-only or narrow scopes when available. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials.
- Pricing: Public per-service pricing and calculator, but cross-service cost can be complex.
- Auth: Service accounts, OAuth, workload identity, IAM roles, and ADC.
- Account creation: Self-serve account/project creation with billing setup.
- Browser support: Console is important for billing, IAM, logs, and audits.
- CLI: gcloud
- API base: https://cloud.googleapis.com
- MCP server: https://docs.cloud.google.com/mcp

Agents can use gcloud and APIs for cloud resource management when constrained by projects, IAM, and dry-run plans.

Score breakdown:
- Machine operability: 24/25
- Agent safety: 17.4/25
- Agent readability: 17.4/20
- Auth and setup: 13/15
- Production reliability: 6.2/15

Capabilities:
- CLI: native. gcloud CLI is scriptable and includes bq, gsutil, and kubectl tooling. Evidence: https://cloud.google.com/cli
- API: native. Google Cloud APIs cover platform services with client libraries. Evidence: https://cloud.google.com/apis/docs/overview
- MCP: native. Google and Google Cloud provide remote MCP servers for supported Google products and cloud services. Evidence: https://docs.cloud.google.com/mcp
- Browser: strong. Console is important for billing, IAM, logs, and audits. Evidence: https://cloud.google.com
- Account creation: strong. Self-serve account/project creation with billing setup. Evidence: https://cloud.google.com
- Pricing clarity: strong. Public per-service pricing and calculator, but cross-service cost can be complex. Evidence: https://cloud.google.com/pricing
- Docs quality: strong. Docs and reference pages are broad and service-specific. Evidence: https://cloud.google.com/docs
- Sandbox: partial. Separate projects and IAM roles support safer experimentation. Evidence: https://cloud.google.com/docs

### Algolia

- Slug: algolia
- URL: https://www.canagentsuse.com/tools/algolia
- Website: https://www.algolia.com
- Docs: https://www.algolia.com/doc
- Agent score: 77
- Agent tier: Strong
- Categories: Search & RAG, Analytics & product
- Use cases: Build RAG, Analyze product
- Best for: Hosted site search, product search, indexing pipelines, and recommendations.
- Limitations: Key limitations: Search relevance changes can affect revenue; production ranking changes need review. Verify official docs, pricing, rate limits, permissions, and production side effects before delegating account-changing actions to an agent. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Public usage-based pricing by records and requests.
- Auth: Application IDs and scoped API keys.
- Account creation: Self-serve signup with free tier.
- Browser support: Dashboard is important for relevance tuning and analytics review.
- CLI: algolia
- API base: https://{application-id}.algolia.net
- MCP server: Not listed

Agents can create indices, push records, tune ranking, and inspect search behavior through API and dashboards.

Score breakdown:
- Machine operability: 18.8/25
- Agent safety: 19.4/25
- Agent readability: 17.4/20
- Auth and setup: 12/15
- Production reliability: 9.4/15

Capabilities:
- CLI: strong. Algolia CLI supports scripting index and app tasks. Evidence: https://www.algolia.com/doc/tools/cli/
- API: native. REST and client APIs cover search, indexing, settings, rules, and analytics. Evidence: https://www.algolia.com/doc/rest-api/search/
- Browser: strong. Dashboard is important for relevance tuning and analytics review. Evidence: https://www.algolia.com
- Account creation: strong. Self-serve signup with free tier. Evidence: https://www.algolia.com
- Pricing clarity: strong. Public usage-based pricing by records and requests. Evidence: https://www.algolia.com/pricing
- Docs quality: strong. Docs include API references, guides, and examples. Evidence: https://www.algolia.com/doc/
- Sandbox: partial. The tool has documented test, local, preview, self-hosted, or staging paths that let agents validate changes away from production. Evidence: https://www.algolia.com/doc

### AWS

- Slug: aws
- URL: https://www.canagentsuse.com/tools/aws
- Website: https://aws.amazon.com
- Docs: https://docs.aws.amazon.com
- Agent score: 77
- Agent tier: Strong
- Categories: Deployment & infra, Databases & storage, AI models
- Use cases: Manage infra, Ship an app, Call models
- Best for: Cloud provisioning, compute, storage, queues, AI services, logs, and enterprise infrastructure.
- Limitations: Key limitations: High blast radius: IAM, billing, data deletion, networking, and production changes require strict review. Model behavior, costs, rate limits, data retention, and safety policies can change by model and account tier; use evals, spend caps, and data controls for sensitive workloads. MCP servers inherit the connected account's scopes and may send prompts or data to third-party services; configure read-only or narrow scopes when available. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials.
- Pricing: Public service pricing calculators and per-service rates; complex at scale.
- Auth: IAM users/roles, STS, SSO, policies, permission boundaries, and access keys.
- Account creation: Self-serve account creation with billing and identity verification.
- Browser support: Console is broad and useful but risky for unsupervised agents.
- CLI: aws
- API base: https://aws.amazon.com/api
- MCP server: https://awslabs.github.io/mcp/

Powerful for agents that can operate within least-privilege IAM and infrastructure-as-code guardrails.

Score breakdown:
- Machine operability: 23.2/25
- Agent safety: 16.2/25
- Agent readability: 17.4/20
- Auth and setup: 12/15
- Production reliability: 8.6/15

Capabilities:
- CLI: native. AWS CLI supports scriptable access to AWS services. Evidence: https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html
- API: native. AWS services expose APIs and SDKs with service-specific references. Evidence: https://docs.aws.amazon.com/
- MCP: strong. AWS provides managed and open-source MCP servers for AWS docs, APIs, infrastructure, databases, observability, and service-specific workflows. Evidence: https://awslabs.github.io/mcp/
- Browser: strong. Console is broad and useful but risky for unsupervised agents. Evidence: https://aws.amazon.com
- Account creation: strong. Self-serve account creation with billing and identity verification. Evidence: https://aws.amazon.com
- Pricing clarity: strong. Public service pricing calculators and per-service rates; complex at scale. Evidence: https://aws.amazon.com/pricing
- Docs quality: strong. Docs are extensive, service-specific, and versioned. Evidence: https://docs.aws.amazon.com/
- Sandbox: partial. Separate accounts, IAM boundaries, and IaC plans can make agent work safer. Evidence: https://docs.aws.amazon.com

### GitLab

- Slug: gitlab
- URL: https://www.canagentsuse.com/tools/gitlab
- Website: https://about.gitlab.com
- Docs: https://docs.gitlab.com
- Agent score: 77
- Agent tier: Strong
- Categories: Project workflows, Deployment & infra
- Use cases: Triage work, Ship an app
- Best for: Source control, CI/CD automation, issue triage, and release operations.
- Limitations: Key limitations: Repository permissions, pipeline variables, and destructive git operations need guardrails. Deploys, secret changes, IAM, billing, networking, deletes, and rollback paths have high production blast radius; require scoped credentials and review gates. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Public SaaS/self-managed pricing with free and paid tiers.
- Auth: Personal/project/group access tokens, OAuth, deploy tokens, and roles.
- Account creation: Self-serve SaaS signup or self-managed deployment.
- Browser support: Browser UI is useful for reviews, pipelines, and permissions.
- CLI: glab
- API base: https://gitlab.com/api/v4
- MCP server: Not listed

Agents can manage repos, merge requests, issues, pipelines, and releases through CLI/API workflows.

Score breakdown:
- Machine operability: 20/25
- Agent safety: 18.2/25
- Agent readability: 17.4/20
- Auth and setup: 12/15
- Production reliability: 9.4/15

Capabilities:
- CLI: native. glab CLI supports issues, merge requests, pipelines, releases, and API calls. Evidence: https://docs.gitlab.com/editor_extensions/gitlab_cli/
- API: native. REST and GraphQL APIs cover projects, issues, merge requests, pipelines, and releases. Evidence: https://docs.gitlab.com/api/
- Browser: strong. Browser UI is useful for reviews, pipelines, and permissions. Evidence: https://about.gitlab.com
- Account creation: strong. Self-serve SaaS signup or self-managed deployment. Evidence: https://about.gitlab.com
- Pricing clarity: strong. Public SaaS/self-managed pricing with free and paid tiers. Evidence: https://about.gitlab.com/pricing
- Docs quality: strong. Docs are broad and versioned across SaaS/self-managed workflows. Evidence: https://docs.gitlab.com
- Sandbox: partial. The tool has documented test, local, preview, self-hosted, or staging paths that let agents validate changes away from production. Evidence: https://docs.gitlab.com

### Microsoft Azure

- Slug: microsoft-azure
- URL: https://www.canagentsuse.com/tools/microsoft-azure
- Website: https://azure.microsoft.com/en-us
- Docs: https://learn.microsoft.com/azure
- Agent score: 77
- Agent tier: Strong
- Categories: Deployment & infra, Databases & storage, AI models
- Use cases: Manage infra, Ship an app, Call models
- Best for: Enterprise cloud operations, Azure AI, Functions, Container Apps, storage, and DevOps.
- Limitations: Key limitations: Subscription-wide permissions, Entra ID, networking, and billing need strict guardrails. Model behavior, costs, rate limits, data retention, and safety policies can change by model and account tier; use evals, spend caps, and data controls for sensitive workloads. MCP servers inherit the connected account's scopes and may send prompts or data to third-party services; configure read-only or narrow scopes when available. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials.
- Pricing: Public per-service pricing and calculator; enterprise discounts can vary.
- Auth: Entra ID, service principals, managed identities, RBAC, and CLI login.
- Account creation: Self-serve signup with billing and identity verification.
- Browser support: Portal is useful for IAM, monitoring, and billing review.
- CLI: az
- API base: https://management.azure.com
- MCP server: npx -y @azure/mcp@latest server start

Agents can inspect and manage Azure resources through CLI/API with resource group, subscription, and RBAC boundaries.

Score breakdown:
- Machine operability: 22.5/25
- Agent safety: 16.2/25
- Agent readability: 17.4/20
- Auth and setup: 12/15
- Production reliability: 8.6/15

Capabilities:
- CLI: native. Azure CLI covers resource and service management. Evidence: https://learn.microsoft.com/en-us/cli/azure/
- API: native. Azure REST APIs and ARM resource APIs are documented. Evidence: https://learn.microsoft.com/en-us/rest/api/azure/
- MCP: native. Microsoft's Azure MCP Server connects agent clients to Azure services and resources through Azure credentials. Evidence: https://learn.microsoft.com/azure/developer/azure-mcp-server/overview
- Browser: partial. Portal is useful for IAM, monitoring, and billing review. Evidence: https://azure.microsoft.com/en-us
- Account creation: strong. Self-serve signup with billing and identity verification. Evidence: https://azure.microsoft.com/en-us
- Pricing clarity: strong. Public per-service pricing and calculator; enterprise discounts can vary. Evidence: https://azure.microsoft.com/en-us/pricing/calculator/
- Docs quality: strong. Microsoft Learn provides service docs, API refs, and CLI refs. Evidence: https://learn.microsoft.com/azure/
- Sandbox: partial. The tool has documented test, local, preview, self-hosted, or staging paths that let agents validate changes away from production. Evidence: https://learn.microsoft.com/azure

### Discord

- Slug: discord
- URL: https://www.canagentsuse.com/tools/discord
- Website: https://discord.com
- Docs: https://docs.discord.com
- Agent score: 75
- Agent tier: Strong
- Categories: Email & messaging, Social media
- Use cases: Publish content, Triage work
- Best for: Community bots, support servers, internal chatops, and event-driven workflows.
- Limitations: Key limitations: Posting, moderation, and member data require clear permissions and rate-limit handling. Outbound messages, SMS, email deliverability, consent, unsubscribe behavior, private chats, and customer-facing replies need approval, throttling, and audit logs. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Developer API is generally free; app monetization and premium features have separate rules.
- Auth: Bot tokens, OAuth2, application commands, permissions, and webhook URLs.
- Account creation: Self-serve developer app creation.
- Browser support: Developer portal and server UI are needed for app setup and permissions.
- CLI: Not listed
- API base: https://discord.com/api/v10
- MCP server: Not listed

Agents can build bots, slash commands, and community workflows when token permissions and moderation are constrained.

Score breakdown:
- Machine operability: 12.5/25
- Agent safety: 18.6/25
- Agent readability: 17.4/20
- Auth and setup: 12/15
- Production reliability: 14/15

Capabilities:
- API: native. REST API and Gateway support bots, interactions, webhooks, applications, and guild workflows. Evidence: https://docs.discord.com/developers/reference
- Browser: partial. Developer portal and server UI are needed for app setup and permissions. Evidence: https://discord.com
- Account creation: strong. Self-serve developer app creation. Evidence: https://discord.com
- Pricing clarity: strong. Developer API is generally free; app monetization and premium features have separate rules. Evidence: https://docs.discord.com/developers/topics/rate-limits
- Docs quality: strong. Official docs include reference, changelog, OAuth, and interaction guides. Evidence: https://docs.discord.com
- Sandbox: partial. Test servers and development apps allow safer bot testing.

### Elasticsearch

- Slug: elasticsearch
- URL: https://www.canagentsuse.com/tools/elasticsearch
- Website: https://www.elastic.co/elasticsearch
- Docs: https://www.elastic.co/docs
- Agent score: 75
- Agent tier: Strong
- Categories: Search & RAG, Observability
- Use cases: Build RAG, Triage work
- Best for: Search infrastructure, log search, vector search, and analytics-heavy retrieval.
- Limitations: Key limitations: Cluster operations and index deletion are high-impact; use scoped credentials and dry-run checks. Issue resolution, alert muting, analytics interpretation, PII in logs, sampling, and retention settings can hide incidents or expose user data if automated too broadly. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Open-source/self-managed options plus public Elastic Cloud pricing.
- Auth: API keys, service accounts, users, roles, and cloud auth.
- Account creation: Self-serve Elastic Cloud signup or local deployment.
- Browser support: Kibana is useful for inspection, dashboards, and safe query iteration.
- CLI: Not listed
- API base: https://www.elastic.co/docs/api
- MCP server: Not listed

Agents can query, index, inspect, and automate search clusters if permissions and destructive actions are constrained.

Score breakdown:
- Machine operability: 14/25
- Agent safety: 22.4/25
- Agent readability: 17.4/20
- Auth and setup: 12/15
- Production reliability: 8.8/15

Capabilities:
- API: native. Elastic API docs cover search, indexing, security, cluster, and vector operations. Evidence: https://www.elastic.co/docs/api
- Browser: strong. Kibana is useful for inspection, dashboards, and safe query iteration. Evidence: https://www.elastic.co/elasticsearch
- Account creation: strong. Self-serve Elastic Cloud signup or local deployment. Evidence: https://www.elastic.co/elasticsearch
- Pricing clarity: strong. Open-source/self-managed options plus public Elastic Cloud pricing. Evidence: https://github.com/elastic/elasticsearch
- Docs quality: strong. Docs are broad and versioned for stack components. Evidence: https://www.elastic.co/docs
- Sandbox: strong. Local Docker and trial cloud deployments support safe testing. Evidence: https://www.elastic.co/docs/deploy-manage/deploy/self-managed/install-elasticsearch-docker-basic

### Lemon Squeezy

- Slug: lemon-squeezy
- URL: https://www.canagentsuse.com/tools/lemon-squeezy
- Website: https://www.lemonsqueezy.com
- Docs: https://docs.lemonsqueezy.com
- Agent score: 75
- Agent tier: Strong
- Categories: Billing & payments, Commerce
- Use cases: Charge a customer
- Best for: Indie SaaS payments, digital products, subscriptions, license keys, and checkout links.
- Limitations: Key limitations: Live money, taxes, refunds, and license entitlements require review. Live payments, refunds, payouts, tax, disputes, and business verification can move money or create compliance exposure; keep agents in sandbox or test mode until a human approves live changes. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Account setup or elevated access may require vendor, admin, or compliance approval before an agent can operate independently.
- Pricing: Public merchant-of-record transaction pricing.
- Auth: API keys and webhook signing secrets.
- Account creation: Self-serve signup; store activation required for live sales.
- Browser support: Dashboard is useful for products, licenses, and store activation.
- CLI: Not listed
- API base: https://api.lemonsqueezy.com/v1
- MCP server: Not listed

Agents can create commerce and licensing workflows with a simple API, but live selling still needs business verification.

Score breakdown:
- Machine operability: 14/25
- Agent safety: 18.4/25
- Agent readability: 17.4/20
- Auth and setup: 12/15
- Production reliability: 13.4/15

Capabilities:
- API: native. API docs cover products, variants, checkouts, subscriptions, customers, licenses, and webhooks. Evidence: https://docs.lemonsqueezy.com/api
- Browser: strong. Dashboard is useful for products, licenses, and store activation. Evidence: https://www.lemonsqueezy.com
- Account creation: strong. Self-serve signup; store activation required for live sales. Evidence: https://www.lemonsqueezy.com
- Pricing clarity: strong. Pricing is public and transaction-based. Evidence: https://www.lemonsqueezy.com/pricing
- Docs quality: strong. Official docs are listed for API behavior, authentication, limits, examples, and setup review. Evidence: https://docs.lemonsqueezy.com
- Sandbox: native. Test mode supports checkout, products, discounts, subscriptions, license keys, webhooks, and API integrations. Evidence: https://docs.lemonsqueezy.com/help/getting-started/test-mode

### Neon

- Slug: neon
- URL: https://www.canagentsuse.com/tools/neon
- Website: https://neon.tech
- Docs: https://neon.tech/docs
- Agent score: 75
- Agent tier: Strong
- Categories: Databases & storage, Deployment & infra
- Use cases: Ship an app
- Best for: Preview DBs, Postgres apps, migration testing, and serverless deployment.
- Limitations: Key limitations: Branch and production connection strings need explicit safety rules. Schema changes, migrations, deletes, backups, row-level security, and retention policies need explicit review before agents touch production data. MCP servers inherit the connected account's scopes and may send prompts or data to third-party services; configure read-only or narrow scopes when available. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials.
- Pricing: Public pricing with free tier, compute, storage, and scale dimensions.
- Auth: API keys, OAuth for hosted MCP, org/project permissions, and database connection strings.
- Account creation: Self-serve signup.
- Browser support: Console is useful for branch inspection and credentials.
- CLI: neonctl
- API base: Not listed
- MCP server: https://mcp.neon.tech/mcp

Great for agents that need preview databases, branch-per-change workflows, normal Postgres tooling, and Neon MCP project/branch/database operations.

Score breakdown:
- Machine operability: 24/25
- Agent safety: 19.2/25
- Agent readability: 17.4/20
- Auth and setup: 12/15
- Production reliability: 2.4/15

Capabilities:
- CLI: native. CLI supports projects, branches, databases, and connection strings. Evidence: https://neon.tech/docs
- API: native. Management API supports project and branch automation. Evidence: https://neon.tech/docs
- MCP: native. Official Neon MCP server manages projects, branches, databases, SQL, migrations, and Neon docs through OAuth or API-key auth. Evidence: https://neon.com/docs/ai/neon-mcp-server
- Browser: strong. Console is useful for branch inspection and credentials. Evidence: https://neon.tech
- Account creation: strong. Self-serve signup. Evidence: https://neon.tech
- Pricing clarity: strong. Public pricing with free tier, compute, storage, and scale dimensions. Evidence: https://neon.tech/pricing
- Docs quality: strong. Official docs are listed for API behavior, authentication, limits, examples, and setup review. Evidence: https://neon.tech/docs
- Sandbox: strong. Database branching is a strong safety affordance for agents. Evidence: https://neon.tech/docs

### Railway

- Slug: railway
- URL: https://www.canagentsuse.com/tools/railway
- Website: https://railway.com
- Docs: https://docs.railway.com
- Agent score: 75
- Agent tier: Strong
- Categories: Deployment & infra, Databases & storage
- Use cases: Ship an app, Manage infra
- Best for: Quick app deployment, preview-ish environments, logs, and small managed services.
- Limitations: Key limitations: Environment variables, redeploys, and deletes need review. Schema changes, migrations, deletes, backups, row-level security, and retention policies need explicit review before agents touch production data. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Public usage-based pricing with free/trial credits depending on plan.
- Auth: User login, account/workspace tokens, and project permissions.
- Account creation: Self-serve signup.
- Browser support: Dashboard is useful for logs, variables, billing, and service topology.
- CLI: railway
- API base: https://backboard.railway.com/graphql/v2
- MCP server: Not listed

Agents can deploy, inspect services, manage environment variables, and read logs through a compact CLI.

Score breakdown:
- Machine operability: 18/25
- Agent safety: 18.2/25
- Agent readability: 17.4/20
- Auth and setup: 12/15
- Production reliability: 9.4/15

Capabilities:
- CLI: native. Railway CLI supports deployment, variables, logs, linking, and service operations. Evidence: https://docs.railway.com/cli
- API: strong. Railway exposes GraphQL/API workflows for project automation. Evidence: https://docs.railway.com/reference/public-api
- Browser: strong. Dashboard is useful for logs, variables, billing, and service topology. Evidence: https://railway.com
- Account creation: strong. Self-serve signup. Evidence: https://railway.com
- Pricing clarity: strong. Public usage-based pricing with free/trial credits depending on plan. Evidence: https://railway.com/pricing
- Docs quality: strong. Docs cover CLI, deployments, variables, and public API. Evidence: https://docs.railway.com
- Sandbox: partial. The tool has documented test, local, preview, self-hosted, or staging paths that let agents validate changes away from production. Evidence: https://docs.railway.com

### Render

- Slug: render
- URL: https://www.canagentsuse.com/tools/render
- Website: https://render.com
- Docs: https://render.com/docs
- Agent score: 75
- Agent tier: Strong
- Categories: Deployment & infra, Databases & storage
- Use cases: Ship an app, Manage infra
- Best for: Web services, background workers, cron jobs, managed databases, and deployment automation.
- Limitations: Key limitations: Deploys, env vars, and deletion operations should be reviewed. Schema changes, migrations, deletes, backups, row-level security, and retention policies need explicit review before agents touch production data. MCP servers inherit the connected account's scopes and may send prompts or data to third-party services; configure read-only or narrow scopes when available. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials.
- Pricing: Public pricing by service type and resource class.
- Auth: API keys, workspace permissions, REST API tokens, and Render MCP API-key auth.
- Account creation: Self-serve signup.
- Browser support: Dashboard helps inspect logs, deploys, env vars, and billing.
- CLI: render
- API base: https://api.render.com/v1
- MCP server: https://mcp.render.com/mcp

Agents can inspect services, deploy from images, manage env vars, and use API/CLI workflows with review.

Score breakdown:
- Machine operability: 22.8/25
- Agent safety: 16.2/25
- Agent readability: 17.4/20
- Auth and setup: 12/15
- Production reliability: 6.2/15

Capabilities:
- CLI: strong. Render CLI can authenticate with API keys and deploy image-backed services. Evidence: https://render.com/docs/cli
- API: native. Render API supports services, deploys, jobs, environment variables, and databases. Evidence: https://render.com/docs/api
- MCP: native. Official hosted Render MCP server manages Render services, databases, metrics, and logs from compatible agent clients. Evidence: https://render.com/docs/mcp-server
- Browser: strong. Dashboard helps inspect logs, deploys, env vars, and billing. Evidence: https://render.com
- Account creation: strong. Self-serve signup. Evidence: https://render.com
- Pricing clarity: strong. Public pricing by service type and resource class. Evidence: https://render.com/pricing
- Docs quality: strong. Docs include API, CLI, deploys, logs, and blueprints. Evidence: https://render.com/docs
- Sandbox: partial. The tool has documented test, local, preview, self-hosted, or staging paths that let agents validate changes away from production. Evidence: https://render.com/docs

### Grafana Cloud

- Slug: grafana-cloud
- URL: https://www.canagentsuse.com/tools/grafana-cloud
- Website: https://grafana.com/products/cloud/
- Docs: https://grafana.com/docs/grafana-cloud
- Agent score: 74
- Agent tier: Usable
- Categories: Observability, Analytics & product
- Use cases: Triage work, Analyze product
- Best for: Dashboards, alerts, Prometheus/Loki/Tempo workflows, and observability automation.
- Limitations: Key limitations: Alert changes and production observability queries need review and rate-limit awareness. Issue resolution, alert muting, analytics interpretation, PII in logs, sampling, and retention settings can hide incidents or expose user data if automated too broadly. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Public free and usage-based cloud pricing.
- Auth: Service accounts, tokens, org roles, stack IDs, and data source permissions.
- Account creation: Self-serve cloud signup or open-source self-hosting.
- Browser support: Dashboard UI is the main review surface for panels and alerts.
- CLI: Not listed
- API base: https://grafana.com/api
- MCP server: Not listed

Agents can automate dashboards, alerts, and observability queries when service accounts and folders are scoped.

Score breakdown:
- Machine operability: 14/25
- Agent safety: 21.6/25
- Agent readability: 17.4/20
- Auth and setup: 12/15
- Production reliability: 9.4/15

Capabilities:
- API: native. Grafana APIs cover dashboards, folders, alerting, data sources, service accounts, and cloud resources. Evidence: https://grafana.com/docs/grafana-cloud/developer-resources/api-reference/
- Browser: strong. Dashboard UI is the main review surface for panels and alerts. Evidence: https://grafana.com/products/cloud/
- Account creation: strong. Self-serve cloud signup or open-source self-hosting. Evidence: https://grafana.com/products/cloud/
- Pricing clarity: strong. Pricing is public with free and usage-based tiers. Evidence: https://grafana.com/pricing/
- Docs quality: strong. Docs cover cloud, OSS, APIs, alerting, dashboards, and data sources. Evidence: https://grafana.com/docs/
- Sandbox: strong. The tool has documented test, local, preview, self-hosted, or staging paths that let agents validate changes away from production. Evidence: https://grafana.com/docs/grafana-cloud

### Qdrant

- Slug: qdrant
- URL: https://www.canagentsuse.com/tools/qdrant
- Website: https://qdrant.tech
- Docs: https://qdrant.tech/documentation
- Agent score: 74
- Agent tier: Usable
- Categories: Search & RAG, Databases & storage
- Use cases: Build RAG
- Best for: RAG indexes, semantic search, hybrid filtering, and self-hosted vector storage.
- Limitations: Key limitations: Deletion, payload privacy, and collection migrations need explicit safeguards. Schema changes, migrations, deletes, backups, row-level security, and retention policies need explicit review before agents touch production data. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Open-source self-hosting plus public Qdrant Cloud pricing.
- Auth: API keys for cloud; configurable keys for self-hosted deployments.
- Account creation: Self-serve cloud signup or local Docker deployment.
- Browser support: Cloud console supports cluster and collection inspection.
- CLI: Not listed
- API base: https://api.qdrant.tech
- MCP server: Not listed

Agents can create collections, upsert points, search, filter, and run local or cloud vector workflows.

Score breakdown:
- Machine operability: 14/25
- Agent safety: 21.6/25
- Agent readability: 17.4/20
- Auth and setup: 12/15
- Production reliability: 8.8/15

Capabilities:
- API: native. REST API reference covers collections, points, search, snapshots, and service operations. Evidence: https://api.qdrant.tech/
- Browser: strong. Cloud console supports cluster and collection inspection. Evidence: https://qdrant.tech
- Account creation: strong. Self-serve cloud signup or local Docker deployment. Evidence: https://qdrant.tech
- Pricing clarity: strong. Open-source self-hosting plus public Qdrant Cloud pricing. Evidence: https://github.com/qdrant/qdrant
- Docs quality: strong. Docs include local, cloud, client, and filtering examples. Evidence: https://qdrant.tech/documentation/
- Sandbox: strong. Local Docker and open-source deployment make safe testing easy. Evidence: https://qdrant.tech/documentation/quick-start/

### Replicate

- Slug: replicate
- URL: https://www.canagentsuse.com/tools/replicate
- Website: https://replicate.com
- Docs: https://replicate.com/docs
- Agent score: 74
- Agent tier: Usable
- Categories: AI models, Design & media
- Use cases: Call models, Manage media
- Best for: Image/video/audio generation, model demos, and hosted inference jobs.
- Limitations: Key limitations: Model licenses, output safety, and per-model cost/latency vary widely. Model behavior, costs, rate limits, data retention, and safety policies can change by model and account tier; use evals, spend caps, and data controls for sensitive workloads. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Usage-based pricing by model hardware and runtime.
- Auth: API tokens.
- Account creation: Self-serve signup; billing required for sustained usage.
- Browser support: Web UI is helpful for model discovery and prediction inspection.
- CLI: replicate
- API base: https://api.replicate.com/v1
- MCP server: Not listed

Agents can run many media and AI models, inspect predictions, and automate model deployments through API or CLI.

Score breakdown:
- Machine operability: 18.8/25
- Agent safety: 13.4/25
- Agent readability: 17.4/20
- Auth and setup: 10.5/15
- Production reliability: 14/15

Capabilities:
- CLI: strong. CLI supports running and managing Replicate workflows. Evidence: https://github.com/replicate/cli
- API: native. HTTP API supports predictions, models, deployments, files, and webhooks. Evidence: https://replicate.com/docs/reference/http
- Browser: strong. Web UI is helpful for model discovery and prediction inspection. Evidence: https://replicate.com
- Account creation: strong. Self-serve signup; billing required for sustained usage. Evidence: https://replicate.com
- Pricing clarity: strong. Usage-based pricing by model hardware and runtime. Evidence: https://replicate.com/pricing
- Docs quality: strong. Docs include model, webhook, and deployment examples. Evidence: https://replicate.com/docs
- Sandbox: partial. The tool has documented test, local, preview, self-hosted, or staging paths that let agents validate changes away from production. Evidence: https://replicate.com/docs

### Typesense

- Slug: typesense
- URL: https://www.canagentsuse.com/tools/typesense
- Website: https://typesense.org
- Docs: https://typesense.org/docs
- Agent score: 74
- Agent tier: Usable
- Categories: Search & RAG
- Use cases: Build RAG
- Best for: Self-hosted search, lightweight product search, and hybrid vector/keyword retrieval.
- Limitations: Key limitations: Schema migrations and production relevance changes need human review. Verify official docs, pricing, rate limits, permissions, and production side effects before delegating account-changing actions to an agent. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Open-source self-hosting plus public cloud pricing.
- Auth: API keys with search-only and admin use patterns.
- Account creation: Self-serve cloud signup or local Docker setup.
- Browser support: Cloud dashboard and local APIs are enough for most operations.
- CLI: Not listed
- API base: https://typesense.org/docs/latest/api/
- MCP server: Not listed

Agents can create collections, index documents, tune schema, and run local search workflows safely.

Score breakdown:
- Machine operability: 14/25
- Agent safety: 21.6/25
- Agent readability: 17.4/20
- Auth and setup: 12/15
- Production reliability: 9.4/15

Capabilities:
- API: native. API docs cover collections, documents, search, aliases, keys, and metrics. Evidence: https://typesense.org/docs/latest/api/
- Browser: strong. Cloud dashboard and local APIs are enough for most operations. Evidence: https://typesense.org
- Account creation: strong. Self-serve cloud signup or local Docker setup. Evidence: https://typesense.org
- Pricing clarity: strong. Open-source self-hosting plus public cloud pricing. Evidence: https://github.com/typesense/typesense
- Docs quality: strong. Docs are concise and developer-oriented. Evidence: https://typesense.org/docs/
- Sandbox: strong. Local Docker and open-source setup allow safe test indexes. Evidence: https://typesense.org/docs/guide/install-typesense.html

### Weaviate

- Slug: weaviate
- URL: https://www.canagentsuse.com/tools/weaviate
- Website: https://weaviate.io
- Docs: https://docs.weaviate.io
- Agent score: 74
- Agent tier: Usable
- Categories: Search & RAG, Databases & storage
- Use cases: Build RAG
- Best for: AI-native vector search, hybrid retrieval, and local/cloud RAG workflows.
- Limitations: Key limitations: Schema changes, vectorizer configuration, and data deletion need review. Schema changes, migrations, deletes, backups, row-level security, and retention policies need explicit review before agents touch production data. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Open-source self-hosting plus public Weaviate Cloud pricing.
- Auth: API keys, OIDC, and cloud auth depending on deployment.
- Account creation: Self-serve cloud signup or local Docker setup.
- Browser support: Cloud console and docs support setup and inspection.
- CLI: Not listed
- API base: https://docs.weaviate.io/weaviate/api
- MCP server: Not listed

Agents can manage collections, import objects, run hybrid/vector search, and choose local or cloud test environments.

Score breakdown:
- Machine operability: 14/25
- Agent safety: 21.6/25
- Agent readability: 17.4/20
- Auth and setup: 12/15
- Production reliability: 9.4/15

Capabilities:
- API: native. Weaviate exposes REST, GraphQL, and gRPC APIs for management and search. Evidence: https://docs.weaviate.io/weaviate/api
- Browser: strong. Cloud console and docs support setup and inspection. Evidence: https://weaviate.io
- Account creation: strong. Self-serve cloud signup or local Docker setup. Evidence: https://weaviate.io
- Pricing clarity: strong. Open-source self-hosting plus public Weaviate Cloud pricing. Evidence: https://github.com/weaviate/weaviate
- Docs quality: strong. Docs explain APIs, clients, deployment, and retrieval patterns. Evidence: https://docs.weaviate.io
- Sandbox: strong. Local Docker deployment supports safe experimentation. Evidence: https://docs.weaviate.io/deploy/installation-guides/docker-installation

### Datadog

- Slug: datadog
- URL: https://www.canagentsuse.com/tools/datadog
- Website: https://www.datadoghq.com
- Docs: https://docs.datadoghq.com
- Agent score: 73
- Agent tier: Usable
- Categories: Observability, Analytics & product
- Use cases: Triage work, Analyze product
- Best for: Production monitoring, log search, incident triage, dashboards, and SLO workflows.
- Limitations: Key limitations: Monitor changes, incident updates, and sensitive logs need human review. Issue resolution, alert muting, analytics interpretation, PII in logs, sampling, and retention settings can hide incidents or expose user data if automated too broadly. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Public product pricing but total cost can be complex across metrics, logs, APM, and hosts.
- Auth: API keys, application keys, service accounts, roles, and audit logs.
- Account creation: Self-serve trial/signup.
- Browser support: Dashboard is central for graphs, logs, monitors, and incidents.
- CLI: Not listed
- API base: https://api.datadoghq.com
- MCP server: Not listed

Agents can query observability data, manage monitors, inspect logs, and triage production systems with scoped API keys.

Score breakdown:
- Machine operability: 15/25
- Agent safety: 21.6/25
- Agent readability: 15.9/20
- Auth and setup: 12/15
- Production reliability: 8.8/15

Capabilities:
- API: native. Datadog API covers monitors, dashboards, logs, metrics, incidents, SLOs, and service catalog. Evidence: https://docs.datadoghq.com/api/latest/
- Browser: native. Dashboard is central for graphs, logs, monitors, and incidents. Evidence: https://www.datadoghq.com
- Account creation: strong. Self-serve trial/signup. Evidence: https://www.datadoghq.com
- Pricing clarity: partial. Pricing is public, but multi-product usage can be complex. Evidence: https://www.datadoghq.com/pricing/
- Docs quality: strong. Docs include API reference, integrations, observability guides, and examples. Evidence: https://docs.datadoghq.com/

### Meilisearch

- Slug: meilisearch
- URL: https://www.canagentsuse.com/tools/meilisearch
- Website: https://www.meilisearch.com
- Docs: https://www.meilisearch.com/docs
- Agent score: 73
- Agent tier: Usable
- Categories: Search & RAG
- Use cases: Build RAG
- Best for: Small and medium search apps, quick indexing, and local search experiments.
- Limitations: Key limitations: Production relevance and deletion operations still need review. Verify official docs, pricing, rate limits, permissions, and production side effects before delegating account-changing actions to an agent. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Open-source self-hosting plus public cloud pricing.
- Auth: Master keys and scoped API keys.
- Account creation: Self-serve cloud signup or local binary/Docker.
- Browser support: Cloud UI and API task views help debug ingestion.
- CLI: Not listed
- API base: https://www.meilisearch.com/docs/reference/api/overview
- MCP server: Not listed

Agents can spin up local search, index documents, and inspect asynchronous tasks with a small API surface.

Score breakdown:
- Machine operability: 12.5/25
- Agent safety: 21.6/25
- Agent readability: 17.4/20
- Auth and setup: 12/15
- Production reliability: 9.4/15

Capabilities:
- API: native. REST API covers indexes, documents, search, tasks, keys, and settings. Evidence: https://www.meilisearch.com/docs/reference/api/overview
- Browser: partial. Cloud UI and API task views help debug ingestion. Evidence: https://www.meilisearch.com
- Account creation: strong. Self-serve cloud signup or local binary/Docker. Evidence: https://www.meilisearch.com
- Pricing clarity: strong. Open-source self-hosting plus public cloud pricing. Evidence: https://github.com/meilisearch/meilisearch
- Docs quality: strong. Docs include quickstarts, API reference, and self-hosted guides. Evidence: https://www.meilisearch.com/docs
- Sandbox: strong. Local binary and Docker setup make safe experiments easy. Evidence: https://www.meilisearch.com/docs/learn/getting_started/installation

### MongoDB Atlas

- Slug: mongodb-atlas
- URL: https://www.canagentsuse.com/tools/mongodb-atlas
- Website: https://www.mongodb.com/products/platform/atlas-database
- Docs: https://www.mongodb.com/docs/atlas
- Agent score: 73
- Agent tier: Usable
- Categories: Databases & storage, Search & RAG
- Use cases: Ship an app, Build RAG, Manage infra
- Best for: MongoDB cloud operations, database provisioning, search, vector search, and app data.
- Limitations: Key limitations: Cluster changes, network access, and destructive database operations need human review. Schema changes, migrations, deletes, backups, row-level security, and retention policies need explicit review before agents touch production data. MCP servers inherit the connected account's scopes and may send prompts or data to third-party services; configure read-only or narrow scopes when available. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials.
- Pricing: Public pricing with free clusters, serverless/dedicated tiers, and usage dimensions.
- Auth: Atlas API keys, database credentials, connection strings, service accounts, and MongoDB MCP configuration.
- Account creation: Self-serve Atlas signup.
- Browser support: Atlas UI is useful for cluster, access, logs, and billing review.
- CLI: atlas
- API base: https://cloud.mongodb.com/api/atlas
- MCP server: npx -y mongodb-mcp-server

Agents can operate MongoDB Atlas through API/CLI and use the official MongoDB MCP server for Atlas administration, database operations, query analysis, and schema exploration.

Score breakdown:
- Machine operability: 22.5/25
- Agent safety: 17.4/25
- Agent readability: 17.4/20
- Auth and setup: 12/15
- Production reliability: 3.2/15

Capabilities:
- CLI: native. Atlas CLI supports programmatic cluster and project operations. Evidence: https://www.mongodb.com/docs/atlas/cli/current/
- API: native. Atlas Administration API supports projects, clusters, users, and administrative objects. Evidence: https://www.mongodb.com/docs/atlas/api/
- MCP: native. Official MongoDB MCP server works with Atlas and local MongoDB deployments for cluster administration, database operations, query analysis, and performance recommendations. Evidence: https://www.mongodb.com/docs/mcp-server/overview/
- Browser: partial. Atlas UI is useful for cluster, access, logs, and billing review. Evidence: https://www.mongodb.com/products/platform/atlas-database
- Account creation: strong. Self-serve Atlas signup. Evidence: https://www.mongodb.com/products/platform/atlas-database
- Pricing clarity: strong. Public pricing with free clusters, serverless/dedicated tiers, and usage dimensions. Evidence: https://www.mongodb.com/pricing
- Docs quality: strong. Docs cover Admin API, CLI, Terraform, and vector search. Evidence: https://www.mongodb.com/docs/atlas/
- Sandbox: partial. The tool has documented test, local, preview, self-hosted, or staging paths that let agents validate changes away from production. Evidence: https://www.mongodb.com/docs/atlas

### Google Sheets API

- Slug: google-sheets
- URL: https://www.canagentsuse.com/tools/google-sheets
- Website: https://workspace.google.com/products/sheets/
- Docs: https://developers.google.com/workspace/sheets/api
- Agent score: 72
- Agent tier: Usable
- Categories: Spreadsheets & data, Project workflows
- Use cases: Triage work, Analyze product
- Best for: Lightweight data edits, reports, operational spreadsheets, and workflow glue.
- Limitations: Key limitations: Sheets often hold sensitive data; require least-privilege OAuth scopes and change review. Project, CRM, document, and spreadsheet writes depend on team context and privacy rules; require least-privilege scopes and review for workflow-changing actions. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: API usage is generally tied to Google Cloud quota and Workspace plan context.
- Auth: OAuth, service accounts, API keys for limited public access, and Workspace scopes.
- Account creation: Google account and Cloud project setup are self-serve.
- Browser support: Browser UI remains best for visual review and sheet layout.
- CLI: Not listed
- API base: https://sheets.googleapis.com/v4
- MCP server: Not listed

Agents can operate spreadsheets through well-documented APIs when OAuth/service account access is configured.

Score breakdown:
- Machine operability: 14/25
- Agent safety: 18.6/25
- Agent readability: 17.4/20
- Auth and setup: 13/15
- Production reliability: 9.4/15

Capabilities:
- API: native. Sheets API supports spreadsheet values, batch updates, formatting, and metadata. Evidence: https://developers.google.com/workspace/sheets/api/guides/concepts
- Browser: strong. Browser UI remains best for visual review and sheet layout. Evidence: https://workspace.google.com/products/sheets/
- Account creation: strong. Google account and Cloud project setup are self-serve. Evidence: https://workspace.google.com/products/sheets/
- Pricing clarity: strong. API usage is generally tied to Google Cloud quota and Workspace plan context. Evidence: https://developers.google.com/workspace/sheets/api/limits
- Docs quality: strong. Docs include guides, reference, auth, and quickstarts. Evidence: https://developers.google.com/workspace/sheets/api
- Sandbox: partial. Copies and test spreadsheets allow low-risk automation.

### Hugging Face

- Slug: hugging-face
- URL: https://www.canagentsuse.com/tools/hugging-face
- Website: https://huggingface.co
- Docs: https://huggingface.co/docs
- Agent score: 72
- Agent tier: Usable
- Categories: AI models, Search & RAG
- Use cases: Call models, Build RAG
- Best for: Model discovery, inference endpoints, datasets, and AI app prototypes.
- Limitations: Key limitations: Open model licenses, gated models, and hardware costs need review. Model behavior, costs, rate limits, data retention, and safety policies can change by model and account tier; use evals, spend caps, and data controls for sensitive workloads. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Public pricing for inference endpoints, Spaces hardware, and Pro/team plans.
- Auth: User access tokens, organizations, and repo permissions.
- Account creation: Self-serve signup.
- Browser support: Model and dataset pages are highly browser-friendly for discovery.
- CLI: huggingface-cli
- API base: https://huggingface.co/api
- MCP server: Not listed

Agents can search model metadata, call inference endpoints, upload artifacts, and manage repos through API or CLI.

Score breakdown:
- Machine operability: 17.3/25
- Agent safety: 18.2/25
- Agent readability: 17.4/20
- Auth and setup: 12/15
- Production reliability: 7/15

Capabilities:
- CLI: strong. CLI and hub libraries manage auth, uploads, downloads, and repos. Evidence: https://huggingface.co/docs/huggingface_hub/guides/cli
- API: native. Hub and inference APIs expose models, datasets, repos, and inference operations. Evidence: https://huggingface.co/docs/api-inference/index
- Browser: partial. Model and dataset pages are highly browser-friendly for discovery. Evidence: https://huggingface.co
- Account creation: strong. Self-serve signup. Evidence: https://huggingface.co
- Pricing clarity: strong. Public pricing for inference endpoints, Spaces hardware, and Pro/team plans. Evidence: https://huggingface.co/pricing
- Docs quality: strong. Docs cover hub, inference, datasets, Spaces, and libraries. Evidence: https://huggingface.co/docs
- Sandbox: partial. The tool has documented test, local, preview, self-hosted, or staging paths that let agents validate changes away from production. Evidence: https://huggingface.co/docs

### Paddle

- Slug: paddle
- URL: https://www.canagentsuse.com/tools/paddle
- Website: https://www.paddle.com
- Docs: https://developer.paddle.com
- Agent score: 72
- Agent tier: Usable
- Categories: Billing & payments, Commerce
- Use cases: Charge a customer
- Best for: SaaS billing, subscriptions, checkout, tax handling, and merchant-of-record workflows.
- Limitations: Key limitations: Live billing, tax, refunds, and customer communication need review. Live payments, refunds, payouts, tax, disputes, and business verification can move money or create compliance exposure; keep agents in sandbox or test mode until a human approves live changes. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Account setup or elevated access may require vendor, admin, or compliance approval before an agent can operate independently.
- Pricing: Public transaction-based pricing for Paddle Billing.
- Auth: API keys, client-side tokens, notification/webhook signatures.
- Account creation: Self-serve signup with business verification for live selling.
- Browser support: Dashboard is useful for review, verification, and billing operations.
- CLI: Not listed
- API base: https://api.paddle.com
- MCP server: Not listed

Agents can manage SaaS billing objects and checkout flows with tax/MoR handled by Paddle, subject to business review.

Score breakdown:
- Machine operability: 14/25
- Agent safety: 18.4/25
- Agent readability: 17.4/20
- Auth and setup: 12/15
- Production reliability: 10.4/15

Capabilities:
- API: native. Developer docs describe a unified API for payments, tax, subscriptions, checkout, and metrics. Evidence: https://developer.paddle.com/
- Browser: strong. Dashboard is useful for review, verification, and billing operations. Evidence: https://www.paddle.com
- Account creation: strong. Self-serve signup with business verification for live selling. Evidence: https://www.paddle.com
- Pricing clarity: strong. Paddle publishes transaction pricing. Evidence: https://www.paddle.com/pricing
- Docs quality: strong. Docs include API reference, webhooks, checkout, and billing guides. Evidence: https://developer.paddle.com/api-reference/overview
- Sandbox: native. Sandbox environment supports testing checkout and subscription workflows. Evidence: https://developer.paddle.com/sdks/sandbox/

### Upstash

- Slug: upstash
- URL: https://www.canagentsuse.com/tools/upstash
- Website: https://upstash.com
- Docs: https://upstash.com/docs
- Agent score: 72
- Agent tier: Usable
- Categories: Databases & storage, Deployment & infra, Search & RAG
- Use cases: Ship an app, Manage infra, Build RAG
- Best for: Serverless Redis, queues, rate limiting, vector search, workflows, and cron-like jobs.
- Limitations: Key limitations: Queue fanout, deletes, and token exposure need careful scoping. Schema changes, migrations, deletes, backups, row-level security, and retention policies need explicit review before agents touch production data. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Public usage-based pricing with free tiers across products.
- Auth: REST URLs/tokens, API keys, and environment variables.
- Account creation: Self-serve signup.
- Browser support: Console supports database, token, usage, and log inspection.
- CLI: upstash
- API base: https://api.upstash.com
- MCP server: Not listed

Agents can provision lightweight state, queues, vector indexes, and scheduled workflows with HTTP-first APIs.

Score breakdown:
- Machine operability: 20/25
- Agent safety: 13.4/25
- Agent readability: 17.4/20
- Auth and setup: 12/15
- Production reliability: 9.4/15

Capabilities:
- CLI: native. CLI can run Redis commands against the REST API and manage resources. Evidence: https://upstash.com/docs/agent-resources/cli
- API: native. Redis REST, QStash, Vector, and management APIs are documented. Evidence: https://upstash.com/docs/redis/features/restapi
- Browser: strong. Console supports database, token, usage, and log inspection. Evidence: https://upstash.com
- Account creation: strong. Self-serve signup. Evidence: https://upstash.com
- Pricing clarity: strong. Pricing is public across Redis, QStash, Vector, and Workflow. Evidence: https://upstash.com/pricing
- Docs quality: strong. Official docs are listed for API behavior, authentication, limits, examples, and setup review. Evidence: https://upstash.com/docs
- Sandbox: partial. The tool has documented test, local, preview, self-hosted, or staging paths that let agents validate changes away from production. Evidence: https://upstash.com/docs

### Apify

- Slug: apify
- URL: https://www.canagentsuse.com/tools/apify
- Website: https://apify.com
- Docs: https://docs.apify.com
- Agent score: 71
- Agent tier: Usable
- Categories: Scraping & content
- Use cases: Extract web data
- Best for: Reusable scraping actors, scheduled crawls, proxies, and dataset pipelines.
- Limitations: Key limitations: Actor quality varies; marketplace actors should be reviewed before automation. Respect robots.txt, site terms, rate limits, copyright, authentication boundaries, and anti-bot controls before asking an agent to crawl or extract content. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Public platform pricing with free credits and compute/usage dimensions.
- Auth: API token and platform account.
- Account creation: Self-serve signup; billing needed for larger usage.
- Browser support: Console is usable for actor setup and inspection.
- CLI: apify
- API base: https://api.apify.com
- MCP server: Not listed

Agents can run existing actors, create automation tasks, inspect datasets, and connect outputs into workflows.

Score breakdown:
- Machine operability: 20/25
- Agent safety: 13.4/25
- Agent readability: 19/20
- Auth and setup: 12/15
- Production reliability: 7/15

Capabilities:
- CLI: native. CLI supports actor development and platform operations. Evidence: https://docs.apify.com/cli
- API: native. API covers actors, runs, datasets, key-value stores, and schedules. Evidence: https://docs.apify.com
- Browser: strong. Console is useful when choosing and configuring actors. Evidence: https://docs.apify.com
- Account creation: strong. Self-serve signup; billing needed for larger usage. Evidence: https://apify.com
- Pricing clarity: strong. Public platform pricing with free credits and compute/usage dimensions. Evidence: https://apify.com/pricing
- Docs quality: native. Official docs are listed for API behavior, authentication, limits, examples, and setup review. Evidence: https://docs.apify.com
- Sandbox: partial. The tool has documented test, local, preview, self-hosted, or staging paths that let agents validate changes away from production. Evidence: https://docs.apify.com

### Telegram Bot API

- Slug: telegram-bot-api
- URL: https://www.canagentsuse.com/tools/telegram-bot-api
- Website: https://telegram.org
- Docs: https://core.telegram.org/bots/api
- Agent score: 71
- Agent tier: Usable
- Categories: Email & messaging, Social media
- Use cases: Publish content, Triage work
- Best for: Bot notifications, chat automations, support intake, and lightweight messaging workflows.
- Limitations: Key limitations: Chat privacy, group permissions, and accidental broadcasts need safeguards. Outbound messages, SMS, email deliverability, consent, unsubscribe behavior, private chats, and customer-facing replies need approval, throttling, and audit logs. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Bot API is free; paid platform features are separate.
- Auth: Bot tokens from BotFather and webhook secrets.
- Account creation: Telegram account and BotFather bot creation.
- Browser support: Bot setup is chat-first rather than browser-first.
- CLI: Not listed
- API base: https://api.telegram.org/bot{token}
- MCP server: Not listed

Agents can operate bots and chat workflows with a straightforward HTTP API and webhook/polling model.

Score breakdown:
- Machine operability: 12.5/25
- Agent safety: 18.6/25
- Agent readability: 17.4/20
- Auth and setup: 9.9/15
- Production reliability: 12.8/15

Capabilities:
- API: native. Bot API documents methods for messages, chats, files, updates, and webhooks. Evidence: https://core.telegram.org/bots/api
- Browser: partial. Bot setup is chat-first rather than browser-first. Evidence: https://telegram.org
- Account creation: partial. Telegram account and BotFather bot creation. Evidence: https://telegram.org
- Pricing clarity: strong. Bot API is free; paid platform features are separate. Evidence: https://telegram.org/pricing
- Docs quality: strong. Docs are compact, stable, and HTTP-oriented. Evidence: https://core.telegram.org/bots
- Sandbox: partial. Private test bots and test chats support safer development.

### Figma

- Slug: figma
- URL: https://www.canagentsuse.com/tools/figma
- Website: https://www.figma.com
- Docs: https://developers.figma.com
- Agent score: 70
- Agent tier: Usable
- Categories: Design & media, Project workflows
- Use cases: Manage media, Triage work
- Best for: Design-to-code context, asset export, comment triage, and design system metadata.
- Limitations: Key limitations: Design files can include private roadmap and brand assets; write/comment actions need review. Project, CRM, document, and spreadsheet writes depend on team context and privacy rules; require least-privilege scopes and review for workflow-changing actions. MCP servers inherit the connected account's scopes and may send prompts or data to third-party services; configure read-only or narrow scopes when available. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Public seat-based pricing; API access depends on team/file permissions.
- Auth: OAuth, file permissions, API tokens for REST APIs, and Figma MCP OAuth.
- Account creation: Self-serve signup.
- Browser support: Browser/editor UI is central for visual review.
- CLI: Not listed
- API base: https://api.figma.com
- MCP server: https://mcp.figma.com/mcp

Agents can inspect design context through REST APIs and use Figma's remote MCP server to extract design data, generate code context, and write supported Figma content.

Score breakdown:
- Machine operability: 19/25
- Agent safety: 9.2/25
- Agent readability: 17.4/20
- Auth and setup: 12/15
- Production reliability: 12.8/15

Capabilities:
- API: native. REST API uses api.figma.com and covers files, images, comments, components, variables, and webhooks. Evidence: https://developers.figma.com/docs/rest-api/
- MCP: native. Official Figma MCP server gives supported clients direct design context, live UI capture, code generation context, and write-to-canvas tools. Evidence: https://developers.figma.com/docs/figma-mcp-server/remote-server-installation/
- Browser: native. Visual design review is best performed in the browser/editor. Evidence: https://developers.figma.com
- Account creation: strong. Self-serve signup. Evidence: https://www.figma.com
- Pricing clarity: strong. Public seat-based pricing; API access depends on team/file permissions. Evidence: https://www.figma.com/pricing
- Docs quality: strong. Developer docs include REST, plugins, widgets, auth, and examples. Evidence: https://developers.figma.com

### Jira

- Slug: jira
- URL: https://www.canagentsuse.com/tools/jira
- Website: https://www.atlassian.com/software/jira
- Docs: https://developer.atlassian.com/cloud/jira/platform/rest/v3/
- Agent score: 70
- Agent tier: Usable
- Categories: Project workflows
- Use cases: Triage work
- Best for: Issue triage, sprint hygiene, workflow updates, and project operations.
- Limitations: Key limitations: Workflow transitions, permissions, and customer data need review. Project, CRM, document, and spreadsheet writes depend on team context and privacy rules; require least-privilege scopes and review for workflow-changing actions. MCP servers inherit the connected account's scopes and may send prompts or data to third-party services; configure read-only or narrow scopes when available. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Public Atlassian plan pricing with free and paid tiers.
- Auth: Atlassian API tokens, OAuth apps, user permissions, and Atlassian Rovo MCP OAuth/API-token access.
- Account creation: Self-serve Atlassian Cloud signup.
- Browser support: Browser UI is useful for workflow, board, and permission review.
- CLI: Not listed
- API base: https://your-domain.atlassian.net/rest/api/3
- MCP server: https://mcp.atlassian.com/v1/mcp/authv2

Agents can automate Jira through REST APIs and Atlassian's Rovo MCP server for Jira, Confluence, and Compass search, summaries, issue creation, and updates.

Score breakdown:
- Machine operability: 18/25
- Agent safety: 9.2/25
- Agent readability: 17.4/20
- Auth and setup: 12/15
- Production reliability: 13.4/15

Capabilities:
- API: native. Jira Cloud REST API covers issues, projects, fields, transitions, and search. Evidence: https://developer.atlassian.com/cloud/jira/platform/rest/v3/
- MCP: native. Atlassian Rovo MCP Server connects AI clients to Jira, Confluence, and Compass through OAuth 2.1 and existing user permissions. Evidence: https://support.atlassian.com/atlassian-rovo-mcp-server/docs/getting-started-with-the-atlassian-remote-mcp-server/
- Browser: strong. Browser UI is useful for workflow, board, and permission review. Evidence: https://www.atlassian.com/software/jira
- Account creation: strong. Self-serve Atlassian Cloud signup. Evidence: https://www.atlassian.com/software/jira
- Pricing clarity: strong. Jira pricing is public by plan and user count. Evidence: https://www.atlassian.com/software/jira/pricing
- Docs quality: strong. Atlassian developer docs include REST, Forge, OAuth, and webhooks. Evidence: https://developer.atlassian.com/cloud/jira/platform/

### Linear

- Slug: linear
- URL: https://www.canagentsuse.com/tools/linear
- Website: https://linear.app
- Docs: https://developers.linear.app
- Agent score: 70
- Agent tier: Usable
- Categories: Project workflows
- Use cases: Triage work
- Best for: Issue triage, roadmaps, changelogs, and lightweight project operations.
- Limitations: Key limitations: Workspace conventions and prioritization still need team context. Project, CRM, document, and spreadsheet writes depend on team context and privacy rules; require least-privilege scopes and review for workflow-changing actions. MCP servers inherit the connected account's scopes and may send prompts or data to third-party services; configure read-only or narrow scopes when available. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Public per-seat pricing with free and paid plans.
- Auth: API keys, OAuth apps, webhooks, and authenticated remote MCP.
- Account creation: Self-serve workspace signup.
- Browser support: Browser UI is highly usable for manual review and operations.
- CLI: Not listed
- API base: https://api.linear.app/graphql
- MCP server: https://mcp.linear.app/mcp

Agents can create, update, search, and triage issues, projects, comments, and related Linear objects through GraphQL or Linear's official MCP server.

Score breakdown:
- Machine operability: 18/25
- Agent safety: 9.2/25
- Agent readability: 17.4/20
- Auth and setup: 12/15
- Production reliability: 13.4/15

Capabilities:
- API: native. GraphQL API supports issues, comments, projects, cycles, and teams. Evidence: https://developers.linear.app
- MCP: native. Official authenticated remote MCP server supports finding, creating, and updating Linear objects such as issues, projects, and comments. Evidence: https://linear.app/docs/mcp
- Browser: strong. UI is quick for issue browsing and edits. Evidence: https://developers.linear.app
- Account creation: strong. Self-serve workspace signup. Evidence: https://linear.app
- Pricing clarity: strong. Public per-seat pricing with free and paid plans. Evidence: https://linear.app/pricing
- Docs quality: strong. Developer docs include schema, webhooks, and OAuth. Evidence: https://developers.linear.app

### Fly.io

- Slug: fly-io
- URL: https://www.canagentsuse.com/tools/fly-io
- Website: https://fly.io
- Docs: https://fly.io/docs
- Agent score: 69
- Agent tier: Usable
- Categories: Deployment & infra, Databases & storage
- Use cases: Ship an app, Manage infra
- Best for: Global app deployment, edge workers, machines, Postgres apps, and agent-managed services.
- Limitations: Key limitations: Secrets, destroy commands, scaling, and production deploys need review. Schema changes, migrations, deletes, backups, row-level security, and retention policies need explicit review before agents touch production data. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Public usage-based pricing by compute, storage, bandwidth, and managed services.
- Auth: Access tokens, organizations, deploy tokens, and CLI auth.
- Account creation: Self-serve signup.
- Browser support: Dashboard supports org, billing, apps, and deployment review.
- CLI: flyctl
- API base: https://api.machines.dev
- MCP server: Not listed

Agents can deploy apps, inspect logs, manage secrets, create machines, and automate infrastructure with flyctl/API.

Score breakdown:
- Machine operability: 20/25
- Agent safety: 13.4/25
- Agent readability: 17.4/20
- Auth and setup: 12/15
- Production reliability: 6.4/15

Capabilities:
- CLI: native. flyctl manages apps, deploys, secrets, logs, volumes, machines, and Postgres. Evidence: https://fly.io/docs/flyctl/
- API: native. Machines API supports programmatic machine lifecycle operations. Evidence: https://fly.io/docs/machines/api/
- Browser: strong. Dashboard supports org, billing, apps, and deployment review. Evidence: https://fly.io
- Account creation: strong. Self-serve signup. Evidence: https://fly.io
- Pricing clarity: strong. Public usage-based pricing by compute, storage, bandwidth, and managed services. Evidence: https://fly.io/pricing
- Docs quality: strong. Docs cover flyctl, apps, Machines, Postgres, and networking. Evidence: https://fly.io/docs/
- Sandbox: partial. The tool has documented test, local, preview, self-hosted, or staging paths that let agents validate changes away from production. Evidence: https://fly.io/docs

### Postmark

- Slug: postmark
- URL: https://www.canagentsuse.com/tools/postmark
- Website: https://postmarkapp.com
- Docs: https://postmarkapp.com/developer
- Agent score: 69
- Agent tier: Usable
- Categories: Email & messaging
- Use cases: Publish content
- Best for: Transactional email, templates, inbound processing, and delivery troubleshooting.
- Limitations: Key limitations: Outbound email still requires domain authentication, test sends, and approval for customer-facing content. Outbound messages, SMS, email deliverability, consent, unsubscribe behavior, private chats, and customer-facing replies need approval, throttling, and audit logs. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Account setup or elevated access may require vendor, admin, or compliance approval before an agent can operate independently.
- Pricing: Public monthly pricing by email volume.
- Auth: Server API tokens, account API tokens, webhooks, and domain verification.
- Account creation: Self-serve trial/signup.
- Browser support: Dashboard supports streams, templates, logs, and suppressions.
- CLI: Not listed
- API base: https://api.postmarkapp.com
- MCP server: Not listed

Agents can send transactional email and inspect delivery events with a simpler operational model than broad marketing suites.

Score breakdown:
- Machine operability: 14/25
- Agent safety: 15.6/25
- Agent readability: 17.4/20
- Auth and setup: 12/15
- Production reliability: 10.4/15

Capabilities:
- API: native. Developer API covers sending, templates, inbound, suppressions, message streams, and webhooks. Evidence: https://postmarkapp.com/developer/api/overview
- Browser: strong. Dashboard supports streams, templates, logs, and suppressions. Evidence: https://postmarkapp.com
- Account creation: strong. Self-serve trial/signup. Evidence: https://postmarkapp.com
- Pricing clarity: strong. Pricing is public by monthly volume. Evidence: https://postmarkapp.com/pricing
- Docs quality: strong. Docs include API reference, webhooks, and delivery concepts. Evidence: https://postmarkapp.com/developer

### Turso

- Slug: turso
- URL: https://www.canagentsuse.com/tools/turso
- Website: https://turso.tech
- Docs: https://docs.turso.tech
- Agent score: 69
- Agent tier: Usable
- Categories: Databases & storage, Deployment & infra
- Use cases: Ship an app, Manage infra
- Best for: Edge SQLite apps, small product databases, local-first workflows, and embedded replicas.
- Limitations: Key limitations: Production schema/data changes should use backups and human review. Schema changes, migrations, deletes, backups, row-level security, and retention policies need explicit review before agents touch production data. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Public plan pricing with free and usage-based dimensions.
- Auth: API tokens, database auth tokens, org/user scoping.
- Account creation: Self-serve signup.
- Browser support: Dashboard supports org, database, token, and usage inspection.
- CLI: turso
- API base: https://api.turso.tech
- MCP server: Not listed

Agents can create databases, manage groups/locations/tokens, and use SQLite-compatible workflows from CLI or API.

Score breakdown:
- Machine operability: 20/25
- Agent safety: 13.4/25
- Agent readability: 17.4/20
- Auth and setup: 12/15
- Production reliability: 6.4/15

Capabilities:
- CLI: native. Turso CLI manages databases, auth tokens, groups, and shell workflows. Evidence: https://docs.turso.tech/cli
- API: native. Platform API supports org, database, group, location, and token operations. Evidence: https://docs.turso.tech/api-reference/introduction
- Browser: strong. Dashboard supports org, database, token, and usage inspection. Evidence: https://turso.tech
- Account creation: strong. Self-serve signup. Evidence: https://turso.tech
- Pricing clarity: strong. Public plan pricing with free and usage-based dimensions. Evidence: https://turso.tech/pricing
- Docs quality: strong. Docs include CLI, SDKs, platform API, and local development. Evidence: https://docs.turso.tech
- Sandbox: partial. The tool has documented test, local, preview, self-hosted, or staging paths that let agents validate changes away from production. Evidence: https://docs.turso.tech

### Twilio SendGrid

- Slug: sendgrid
- URL: https://www.canagentsuse.com/tools/sendgrid
- Website: https://sendgrid.com
- Docs: https://www.twilio.com/docs/sendgrid
- Agent score: 69
- Agent tier: Usable
- Categories: Email & messaging
- Use cases: Publish content
- Best for: Transactional email, marketing sends, templates, suppression management, and delivery analytics.
- Limitations: Key limitations: Outbound email can damage sender reputation; use review, test addresses, and unsubscribe safeguards. Outbound messages, SMS, email deliverability, consent, unsubscribe behavior, private chats, and customer-facing replies need approval, throttling, and audit logs. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Account setup or elevated access may require vendor, admin, or compliance approval before an agent can operate independently.
- Pricing: Public plan pricing by email volume and feature set.
- Auth: API keys with scopes, sender/domain authentication, webhooks.
- Account creation: Self-serve signup with sender/domain verification.
- Browser support: Console helps review sender auth, templates, stats, and suppression lists.
- CLI: Not listed
- API base: https://api.sendgrid.com/v3
- MCP server: Not listed

Agents can send transactional email and manage templates/lists when domains and approvals are configured.

Score breakdown:
- Machine operability: 14/25
- Agent safety: 15.6/25
- Agent readability: 17.4/20
- Auth and setup: 12/15
- Production reliability: 10.4/15

Capabilities:
- API: native. Mail Send API and v3 APIs cover email sending, templates, contacts, and stats. Evidence: https://www.twilio.com/docs/sendgrid/api-reference/mail-send/mail-send
- Browser: strong. Console helps review sender auth, templates, stats, and suppression lists. Evidence: https://sendgrid.com
- Account creation: strong. Self-serve signup with sender/domain verification. Evidence: https://sendgrid.com
- Pricing clarity: strong. Pricing is public by email volume and product. Evidence: https://sendgrid.com/en-us/pricing
- Docs quality: strong. Docs cover API reference, scheduling, webhooks, and delivery concepts. Evidence: https://www.twilio.com/docs/sendgrid

### Audioserve

- Slug: audioserve
- URL: https://www.canagentsuse.com/tools/audioserve
- Website: https://github.com/izderadicka/audioserve
- Docs: https://github.com/izderadicka/audioserve
- Agent score: 68
- Agent tier: Usable
- Categories: Self-hosted, Media Streaming - Audio Streaming
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted media streaming - audio streaming workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Rust. Source code: https://github.com/izderadicka/audioserve
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Audioserve is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 12/25
- Agent safety: 21.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/izderadicka/audioserve
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/izderadicka/audioserve
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/izderadicka/audioserve
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/izderadicka/audioserve
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/izderadicka/audioserve
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/izderadicka/audioserve
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/izderadicka/audioserve

### bittorrent-tracker

- Slug: bittorrent-tracker
- URL: https://www.canagentsuse.com/tools/bittorrent-tracker
- Website: https://webtorrent.io/
- Docs: https://github.com/webtorrent/bittorrent-tracker
- Agent score: 68
- Agent tier: Usable
- Categories: Self-hosted, File Transfer - Peer-to-peer Filesharing
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted file transfer - peer-to-peer filesharing workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs. Source code: https://github.com/webtorrent/bittorrent-tracker
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

bittorrent-tracker is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 12/25
- Agent safety: 21.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/webtorrent/bittorrent-tracker
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/webtorrent/bittorrent-tracker
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://webtorrent.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/webtorrent/bittorrent-tracker
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/webtorrent/bittorrent-tracker
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/webtorrent/bittorrent-tracker
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/webtorrent/bittorrent-tracker

### Bytebase

- Slug: bytebase
- URL: https://www.canagentsuse.com/tools/bytebase
- Website: https://www.bytebase.com/
- Docs: https://github.com/bytebase/bytebase
- Agent score: 68
- Agent tier: Usable
- Categories: Self-hosted, Database Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Triage work
- Best for: Self-hosted database management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, K8S, Go. Source code: https://github.com/bytebase/bytebase
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Bytebase is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 12/25
- Agent safety: 21.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/bytebase/bytebase
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/bytebase/bytebase
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.bytebase.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/bytebase/bytebase
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/bytebase/bytebase
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/bytebase/bytebase
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/bytebase/bytebase

### Calibre

- Slug: calibre
- URL: https://www.canagentsuse.com/tools/calibre
- Website: https://calibre-ebook.com/
- Docs: https://github.com/kovidgoyal/calibre
- Agent score: 68
- Agent tier: Usable
- Categories: Self-hosted, Document Management - E-books
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Analyze product, Publish content
- Best for: Self-hosted document management - e-books workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python, deb. Source code: https://github.com/kovidgoyal/calibre
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Calibre is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 12/25
- Agent safety: 21.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/kovidgoyal/calibre
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/kovidgoyal/calibre
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://calibre-ebook.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/kovidgoyal/calibre
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/kovidgoyal/calibre
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/kovidgoyal/calibre
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/kovidgoyal/calibre

### Canva

- Slug: canva
- URL: https://www.canagentsuse.com/tools/canva
- Website: https://www.canva.com
- Docs: https://www.canva.dev/docs
- Agent score: 68
- Agent tier: Usable
- Categories: Design & media
- Use cases: Manage media, Publish content
- Best for: Design asset sync, generated design workflows, comments, and export automation.
- Limitations: Key limitations: Public integrations need Canva review; brand assets and design mutations require approval. Verify official docs, pricing, rate limits, permissions, and production side effects before delegating account-changing actions to an agent. MCP servers inherit the connected account's scopes and may send prompts or data to third-party services; configure read-only or narrow scopes when available. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Public Canva pricing; API integration access may depend on use case and plan.
- Auth: OAuth, Canva app/integration credentials, and Canva MCP per-user authentication.
- Account creation: Self-serve user/team signup; developer app review for public integrations.
- Browser support: Browser UI remains central for design review and editing.
- CLI: Not listed
- API base: https://api.canva.com/rest/v1
- MCP server: https://mcp.canva.com/mcp

Agents can use Canva APIs and the Canva MCP server for design creation, editing, asset search, export, commenting, and brand workflows.

Score breakdown:
- Machine operability: 19/25
- Agent safety: 9.2/25
- Agent readability: 17.4/20
- Auth and setup: 12/15
- Production reliability: 10/15

Capabilities:
- API: native. Canva Connect APIs expose assets, designs, comments, folders, and exports with OpenAPI. Evidence: https://www.canva.dev/docs/connect/
- MCP: native. Canva provides a remote MCP server for design creation/editing, asset and brand management, library search, export, and comments. Evidence: https://www.canva.dev/docs/mcp/
- Browser: native. Design creation and review are browser-first workflows. Evidence: https://www.canva.dev/docs
- Account creation: strong. Self-serve user/team signup; developer app review for public integrations. Evidence: https://www.canva.com
- Pricing clarity: strong. Public Canva pricing; API integration access may depend on use case and plan. Evidence: https://www.canva.com/pricing
- Docs quality: strong. Docs include Connect API, apps SDK, app components, and review rules. Evidence: https://www.canva.dev/docs/

### CookCLI

- Slug: cookcli
- URL: https://www.canagentsuse.com/tools/cookcli
- Website: https://cooklang.org
- Docs: https://github.com/cooklang/CookCLI
- Agent score: 68
- Agent tier: Usable
- Categories: Self-hosted, Recipe Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted recipe management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Rust. Source code: https://github.com/cooklang/CookCLI
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

CookCLI is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 12/25
- Agent safety: 21.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/cooklang/CookCLI
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/cooklang/CookCLI
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://cooklang.org
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/cooklang/CookCLI
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/cooklang/CookCLI
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/cooklang/CookCLI
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/cooklang/CookCLI

### Dagu

- Slug: dagu
- URL: https://www.canagentsuse.com/tools/dagu
- Website: https://docs.dagu.cloud/
- Docs: https://github.com/dagucloud/dagu
- Agent score: 68
- Agent tier: Usable
- Categories: Self-hosted, Automation
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted automation workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker. Source code: https://github.com/dagucloud/dagu
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Dagu is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 12/25
- Agent safety: 21.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/dagucloud/dagu
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/dagucloud/dagu
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://docs.dagu.cloud/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/dagucloud/dagu
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/dagucloud/dagu
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/dagucloud/dagu
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/dagucloud/dagu

### DavMail

- Slug: davmail
- URL: https://www.canagentsuse.com/tools/davmail
- Website: https://davmail.sourceforge.net/
- Docs: https://github.com/mguessan/davmail
- Agent score: 68
- Agent tier: Usable
- Categories: Self-hosted, Communication - Email - Mail Delivery Agents, Calendar & Contacts
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - email - mail delivery agents workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Java. Source code: https://github.com/mguessan/davmail
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

DavMail is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 12/25
- Agent safety: 21.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/mguessan/davmail
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/mguessan/davmail
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://davmail.sourceforge.net/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/mguessan/davmail
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/mguessan/davmail
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/mguessan/davmail
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/mguessan/davmail

### Eclipse Che

- Slug: eclipse-che
- URL: https://www.canagentsuse.com/tools/eclipse-che
- Website: https://www.eclipse.org/che/
- Docs: https://github.com/eclipse-che/che
- Agent score: 68
- Agent tier: Usable
- Categories: Self-hosted, Software Development - IDE & Tools
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted software development - ide & tools workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Self-hosted/open-source licensing listed as EPL-1.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Java. Source code: https://github.com/eclipse-che/che
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Eclipse Che is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 12/25
- Agent safety: 21.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/eclipse-che/che
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/eclipse-che/che
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.eclipse.org/che/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/eclipse-che/che
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/eclipse-che/che
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/eclipse-che/che
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/eclipse-che/che

### Gokapi

- Slug: gokapi
- URL: https://www.canagentsuse.com/tools/gokapi
- Website: https://github.com/Forceu/gokapi
- Docs: https://github.com/Forceu/gokapi
- Agent score: 68
- Agent tier: Usable
- Categories: Self-hosted, File Transfer - Single-click & Drag-n-drop Upload
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted file transfer - single-click & drag-n-drop upload workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker. Source code: https://github.com/Forceu/gokapi
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Gokapi is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 12/25
- Agent safety: 21.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/Forceu/gokapi
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/Forceu/gokapi
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/Forceu/gokapi
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Forceu/gokapi
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Forceu/gokapi
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Forceu/gokapi
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Forceu/gokapi

### goploader

- Slug: goploader
- URL: https://www.canagentsuse.com/tools/goploader
- Website: https://depado.github.io/goploader/
- Docs: https://github.com/Depado/goploader
- Agent score: 68
- Agent tier: Usable
- Categories: Self-hosted, File Transfer - Single-click & Drag-n-drop Upload
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted file transfer - single-click & drag-n-drop upload workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go. Source code: https://github.com/Depado/goploader
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

goploader is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 12/25
- Agent safety: 21.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/Depado/goploader
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/Depado/goploader
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://depado.github.io/goploader/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Depado/goploader
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Depado/goploader
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Depado/goploader
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Depado/goploader

### Gotify

- Slug: gotify
- URL: https://www.canagentsuse.com/tools/gotify
- Website: https://gotify.net/
- Docs: https://github.com/gotify/server
- Agent score: 68
- Agent tier: Usable
- Categories: Self-hosted, Communication - Custom Communication Systems
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - custom communication systems workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker. Source code: https://github.com/gotify/server
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Gotify is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 12/25
- Agent safety: 21.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/gotify/server
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/gotify/server
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://gotify.net/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/gotify/server
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/gotify/server
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/gotify/server
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/gotify/server

### Guacamole

- Slug: guacamole
- URL: https://www.canagentsuse.com/tools/guacamole
- Website: https://guacamole.apache.org
- Docs: https://github.com/apache/guacamole-server
- Agent score: 68
- Agent tier: Usable
- Categories: Self-hosted, Remote Access
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted remote access workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Java, C. Source code: https://github.com/apache/guacamole-server
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Guacamole is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 12/25
- Agent safety: 21.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/apache/guacamole-server
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/apache/guacamole-server
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://guacamole.apache.org
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/apache/guacamole-server
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/apache/guacamole-server
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/apache/guacamole-server
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/apache/guacamole-server

### Jellyfin

- Slug: jellyfin
- URL: https://www.canagentsuse.com/tools/jellyfin
- Website: https://jellyfin.org
- Docs: https://github.com/jellyfin/jellyfin
- Agent score: 68
- Agent tier: Usable
- Categories: Self-hosted, Media Streaming - Multimedia Streaming
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted media streaming - multimedia streaming workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C#, deb, Docker. Source code: https://github.com/jellyfin/jellyfin
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Jellyfin is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 12/25
- Agent safety: 21.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/jellyfin/jellyfin
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/jellyfin/jellyfin
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://jellyfin.org
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/jellyfin/jellyfin
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/jellyfin/jellyfin
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/jellyfin/jellyfin
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/jellyfin/jellyfin

### Lila

- Slug: lila
- URL: https://www.canagentsuse.com/tools/lila
- Website: https://lichess.org/
- Docs: https://github.com/lichess-org/lila
- Agent score: 68
- Agent tier: Usable
- Categories: Self-hosted, Games
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted games workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Scala. Source code: https://github.com/lichess-org/lila
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Lila is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 12/25
- Agent safety: 21.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/lichess-org/lila
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/lichess-org/lila
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://lichess.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/lichess-org/lila
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/lichess-org/lila
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/lichess-org/lila
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/lichess-org/lila

### LinuxGSM

- Slug: linuxgsm
- URL: https://www.canagentsuse.com/tools/linuxgsm
- Website: https://linuxgsm.com/
- Docs: https://github.com/GameServerManagers/LinuxGSM
- Agent score: 68
- Agent tier: Usable
- Categories: Self-hosted, Games - Administrative Utilities & Control Panels
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted games - administrative utilities & control panels workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Shell. Source code: https://github.com/GameServerManagers/LinuxGSM
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

LinuxGSM is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 12/25
- Agent safety: 21.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/GameServerManagers/LinuxGSM
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/GameServerManagers/LinuxGSM
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://linuxgsm.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/GameServerManagers/LinuxGSM
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/GameServerManagers/LinuxGSM
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/GameServerManagers/LinuxGSM
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/GameServerManagers/LinuxGSM

### LLM Harbor

- Slug: llm-harbor
- URL: https://www.canagentsuse.com/tools/llm-harbor
- Website: https://github.com/av/harbor
- Docs: https://github.com/av/harbor
- Agent score: 68
- Agent tier: Usable
- Categories: Self-hosted, Generative Artificial Intelligence (GenAI)
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted generative artificial intelligence (genai) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Shell. Source code: https://github.com/av/harbor
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

LLM Harbor is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 12/25
- Agent safety: 21.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/av/harbor
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/av/harbor
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/av/harbor
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/av/harbor
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/av/harbor
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/av/harbor
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/av/harbor

### musikcube

- Slug: musikcube
- URL: https://www.canagentsuse.com/tools/musikcube
- Website: https://musikcube.com/
- Docs: https://github.com/clangen/musikcube
- Agent score: 68
- Agent tier: Usable
- Categories: Self-hosted, Media Streaming - Audio Streaming
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted media streaming - audio streaming workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Self-hosted/open-source licensing listed as BSD-3-Clause; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C++, deb. Source code: https://github.com/clangen/musikcube
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

musikcube is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 12/25
- Agent safety: 21.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/clangen/musikcube
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/clangen/musikcube
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://musikcube.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/clangen/musikcube
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/clangen/musikcube
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/clangen/musikcube
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/clangen/musikcube

### Open-Meteo

- Slug: open-meteo
- URL: https://www.canagentsuse.com/tools/open-meteo
- Website: https://open-meteo.com/
- Docs: https://github.com/open-meteo/open-meteo
- Agent score: 68
- Agent tier: Usable
- Categories: Self-hosted, Miscellaneous
- Use cases: Self-host a tool, Inspect open source, Triage work
- Best for: Self-hosted miscellaneous workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/open-meteo/open-meteo
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Open-Meteo is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 12/25
- Agent safety: 21.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/open-meteo/open-meteo
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/open-meteo/open-meteo
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://open-meteo.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/open-meteo/open-meteo
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/open-meteo/open-meteo
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/open-meteo/open-meteo
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/open-meteo/open-meteo

### OpenMediaVault

- Slug: openmediavault
- URL: https://www.canagentsuse.com/tools/openmediavault
- Website: https://www.openmediavault.org/
- Docs: https://github.com/openmediavault/openmediavault
- Agent score: 68
- Agent tier: Usable
- Categories: Self-hosted, Self-hosting Solutions
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted self-hosting solutions workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/openmediavault/openmediavault
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

OpenMediaVault is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 12/25
- Agent safety: 21.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/openmediavault/openmediavault
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/openmediavault/openmediavault
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.openmediavault.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/openmediavault/openmediavault
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/openmediavault/openmediavault
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/openmediavault/openmediavault
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/openmediavault/openmediavault

### Pastefy

- Slug: pastefy
- URL: https://www.canagentsuse.com/tools/pastefy
- Website: https://pastefy.app/
- Docs: https://github.com/interaapps/pastefy
- Agent score: 68
- Agent tier: Usable
- Categories: Self-hosted, Pastebins
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted pastebins workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, K8S, Java. Source code: https://github.com/interaapps/pastefy
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Pastefy is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 12/25
- Agent safety: 21.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/interaapps/pastefy
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/interaapps/pastefy
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://pastefy.app/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/interaapps/pastefy
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/interaapps/pastefy
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/interaapps/pastefy
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/interaapps/pastefy

### PictShare

- Slug: pictshare
- URL: https://www.canagentsuse.com/tools/pictshare
- Website: https://www.pictshare.net/
- Docs: https://github.com/HaschekSolutions/pictshare
- Agent score: 68
- Agent tier: Usable
- Categories: Self-hosted, File Transfer - Single-click & Drag-n-drop Upload
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted file transfer - single-click & drag-n-drop upload workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP, Docker. Source code: https://github.com/HaschekSolutions/pictshare
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

PictShare is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 12/25
- Agent safety: 21.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/HaschekSolutions/pictshare
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/HaschekSolutions/pictshare
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.pictshare.net/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/HaschekSolutions/pictshare
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/HaschekSolutions/pictshare
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/HaschekSolutions/pictshare
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/HaschekSolutions/pictshare

### pyLoad

- Slug: pyload
- URL: https://www.canagentsuse.com/tools/pyload
- Website: https://pyload.net/
- Docs: https://github.com/pyload/pyload
- Agent score: 68
- Agent tier: Usable
- Categories: Self-hosted, Automation
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted automation workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python. Source code: https://github.com/pyload/pyload
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

pyLoad is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 12/25
- Agent safety: 21.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/pyload/pyload
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/pyload/pyload
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://pyload.net/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/pyload/pyload
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/pyload/pyload
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/pyload/pyload
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/pyload/pyload

### Rapidbay

- Slug: rapidbay
- URL: https://www.canagentsuse.com/tools/rapidbay
- Website: https://github.com/hauxir/rapidbay/
- Docs: https://github.com/hauxir/rapidbay/
- Agent score: 68
- Agent tier: Usable
- Categories: Self-hosted, Media Streaming - Video Streaming
- Use cases: Self-host a tool, Inspect open source, Triage work
- Best for: Self-hosted media streaming - video streaming workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python, Docker. Source code: https://github.com/hauxir/rapidbay/
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Rapidbay is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 12/25
- Agent safety: 21.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/hauxir/rapidbay/
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/hauxir/rapidbay/
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/hauxir/rapidbay/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/hauxir/rapidbay/
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/hauxir/rapidbay/
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/hauxir/rapidbay/
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/hauxir/rapidbay/

### RconCli

- Slug: rconcli
- URL: https://www.canagentsuse.com/tools/rconcli
- Website: https://github.com/gorcon/rcon-cli
- Docs: https://github.com/gorcon/rcon-cli
- Agent score: 68
- Agent tier: Usable
- Categories: Self-hosted, Games - Administrative Utilities & Control Panels
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted games - administrative utilities & control panels workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go. Source code: https://github.com/gorcon/rcon-cli
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

RconCli is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 12/25
- Agent safety: 21.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/gorcon/rcon-cli
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/gorcon/rcon-cli
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/gorcon/rcon-cli
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/gorcon/rcon-cli
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/gorcon/rcon-cli
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/gorcon/rcon-cli
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/gorcon/rcon-cli

### ShellHub

- Slug: shellhub
- URL: https://www.canagentsuse.com/tools/shellhub
- Website: https://www.shellhub.io
- Docs: https://github.com/shellhub-io/shellhub
- Agent score: 68
- Agent tier: Usable
- Categories: Self-hosted, Remote Access
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted remote access workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/shellhub-io/shellhub
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

ShellHub is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 12/25
- Agent safety: 21.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/shellhub-io/shellhub
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/shellhub-io/shellhub
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.shellhub.io
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/shellhub-io/shellhub
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/shellhub-io/shellhub
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/shellhub-io/shellhub
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/shellhub-io/shellhub

### Shlink

- Slug: shlink
- URL: https://www.canagentsuse.com/tools/shlink
- Website: https://shlink.io
- Docs: https://github.com/shlinkio/shlink
- Agent score: 68
- Agent tier: Usable
- Categories: Self-hosted, URL Shorteners
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted url shorteners workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP, Docker. Source code: https://github.com/shlinkio/shlink
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Shlink is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 12/25
- Agent safety: 21.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/shlinkio/shlink
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/shlinkio/shlink
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://shlink.io
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/shlinkio/shlink
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/shlinkio/shlink
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/shlinkio/shlink
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/shlinkio/shlink

### slskd

- Slug: slskd
- URL: https://www.canagentsuse.com/tools/slskd
- Website: https://github.com/slskd/slskd
- Docs: https://github.com/slskd/slskd
- Agent score: 68
- Agent tier: Usable
- Categories: Self-hosted, File Transfer - Peer-to-peer Filesharing
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted file transfer - peer-to-peer filesharing workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, C#. Source code: https://github.com/slskd/slskd
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

slskd is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 12/25
- Agent safety: 21.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/slskd/slskd
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/slskd/slskd
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/slskd/slskd
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/slskd/slskd
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/slskd/slskd
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/slskd/slskd
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/slskd/slskd

### Snikket

- Slug: snikket
- URL: https://www.canagentsuse.com/tools/snikket
- Website: https://snikket.org/
- Docs: https://github.com/snikket-im/snikket-server
- Agent score: 68
- Agent tier: Usable
- Categories: Self-hosted, Communication - XMPP - Servers
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted communication - xmpp - servers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/snikket-im/snikket-server
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Snikket is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 12/25
- Agent safety: 21.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/snikket-im/snikket-server
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/snikket-im/snikket-server
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://snikket.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/snikket-im/snikket-server
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/snikket-im/snikket-server
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/snikket-im/snikket-server
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/snikket-im/snikket-server

### Svix

- Slug: svix
- URL: https://www.canagentsuse.com/tools/svix
- Website: https://svix.com
- Docs: https://github.com/svix/svix-webhooks
- Agent score: 68
- Agent tier: Usable
- Categories: Self-hosted, Software Development - API Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted software development - api management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Rust. Source code: https://github.com/svix/svix-webhooks
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Svix is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 12.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/svix/svix-webhooks
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://svix.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/svix/svix-webhooks
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/svix/svix-webhooks
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/svix/svix-webhooks
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/svix/svix-webhooks

### SWAG (Secure Web Application Gateway)

- Slug: swag-secure-web-application-gateway
- URL: https://www.canagentsuse.com/tools/swag-secure-web-application-gateway
- Website: https://github.com/linuxserver/docker-swag
- Docs: https://github.com/linuxserver/docker-swag
- Agent score: 68
- Agent tier: Usable
- Categories: Self-hosted, Web Servers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted web servers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/linuxserver/docker-swag
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

SWAG (Secure Web Application Gateway) is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 12/25
- Agent safety: 21.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/linuxserver/docker-swag
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/linuxserver/docker-swag
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/linuxserver/docker-swag
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/linuxserver/docker-swag
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/linuxserver/docker-swag
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/linuxserver/docker-swag
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/linuxserver/docker-swag

### Sync-in

- Slug: sync-in
- URL: https://www.canagentsuse.com/tools/sync-in
- Website: https://sync-in.com
- Docs: https://github.com/Sync-in/server
- Agent score: 68
- Agent tier: Usable
- Categories: Self-hosted, File Transfer & Synchronization, File Transfer - Web-based File Managers, Groupware
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted file transfer & synchronization workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/Sync-in/server
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Sync-in is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 12/25
- Agent safety: 21.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/Sync-in/server
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/Sync-in/server
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://sync-in.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Sync-in/server
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Sync-in/server
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Sync-in/server
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Sync-in/server

### Termix

- Slug: termix
- URL: https://www.canagentsuse.com/tools/termix
- Website: https://docs.termix.site/
- Docs: https://github.com/Termix-SSH/Termix
- Agent score: 68
- Agent tier: Usable
- Categories: Self-hosted, Remote Access
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted remote access workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/Termix-SSH/Termix
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Termix is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 12/25
- Agent safety: 21.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/Termix-SSH/Termix
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/Termix-SSH/Termix
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://docs.termix.site/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Termix-SSH/Termix
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Termix-SSH/Termix
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Termix-SSH/Termix
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Termix-SSH/Termix

### Tipi

- Slug: tipi
- URL: https://www.canagentsuse.com/tools/tipi
- Website: https://runtipi.io/
- Docs: https://github.com/runtipi/runtipi
- Agent score: 68
- Agent tier: Usable
- Categories: Self-hosted, Self-hosting Solutions
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted self-hosting solutions workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Shell. Source code: https://github.com/runtipi/runtipi
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Tipi is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 12/25
- Agent safety: 21.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/runtipi/runtipi
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/runtipi/runtipi
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://runtipi.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/runtipi/runtipi
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/runtipi/runtipi
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/runtipi/runtipi
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/runtipi/runtipi

### WebHook Tester

- Slug: webhook-tester
- URL: https://www.canagentsuse.com/tools/webhook-tester
- Website: https://github.com/tarampampam/webhook-tester
- Docs: https://github.com/tarampampam/webhook-tester
- Agent score: 68
- Agent tier: Usable
- Categories: Self-hosted, Software Development - Testing
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted software development - testing workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Go, deb, K8S. Source code: https://github.com/tarampampam/webhook-tester
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

WebHook Tester is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 12.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/tarampampam/webhook-tester
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/tarampampam/webhook-tester
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/tarampampam/webhook-tester
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/tarampampam/webhook-tester
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/tarampampam/webhook-tester
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/tarampampam/webhook-tester

### Websoft9

- Slug: websoft9
- URL: https://www.canagentsuse.com/tools/websoft9
- Website: https://www.websoft9.com
- Docs: https://github.com/websoft9/websoft9
- Agent score: 68
- Agent tier: Usable
- Categories: Self-hosted, Self-hosting Solutions
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted self-hosting solutions workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Self-hosted/open-source licensing listed as LGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Shell, Python. Source code: https://github.com/websoft9/websoft9
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Websoft9 is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 12/25
- Agent safety: 21.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/websoft9/websoft9
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/websoft9/websoft9
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.websoft9.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/websoft9/websoft9
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/websoft9/websoft9
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/websoft9/websoft9
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/websoft9/websoft9

### XBackBone

- Slug: xbackbone
- URL: https://www.canagentsuse.com/tools/xbackbone
- Website: https://xbackbone.app/
- Docs: https://github.com/SergiX44/XBackBone
- Agent score: 68
- Agent tier: Usable
- Categories: Self-hosted, File Transfer - Single-click & Drag-n-drop Upload
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted file transfer - single-click & drag-n-drop upload workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP, Docker. Source code: https://github.com/SergiX44/XBackBone
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

XBackBone is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 12/25
- Agent safety: 21.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/SergiX44/XBackBone
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/SergiX44/XBackBone
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://xbackbone.app/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/SergiX44/XBackBone
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/SergiX44/XBackBone
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/SergiX44/XBackBone
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/SergiX44/XBackBone

### Zipline

- Slug: zipline
- URL: https://www.canagentsuse.com/tools/zipline
- Website: https://github.com/diced/zipline
- Docs: https://github.com/diced/zipline
- Agent score: 68
- Agent tier: Usable
- Categories: Self-hosted, File Transfer - Single-click & Drag-n-drop Upload
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted file transfer - single-click & drag-n-drop upload workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Nodejs. Source code: https://github.com/diced/zipline
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Zipline is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 12/25
- Agent safety: 21.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/diced/zipline
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/diced/zipline
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/diced/zipline
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/diced/zipline
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/diced/zipline
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/diced/zipline
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/diced/zipline

### Airtable

- Slug: airtable
- URL: https://www.canagentsuse.com/tools/airtable
- Website: https://www.airtable.com
- Docs: https://airtable.com/developers
- Agent score: 67
- Agent tier: Usable
- Categories: Spreadsheets & data, Automation & integrations, Project workflows
- Use cases: Triage work, Sync CRM
- Best for: Lightweight operations databases, editorial calendars, lead lists, and no-code back offices.
- Limitations: Key limitations: Schema changes, rate limits, and accidental record edits need guardrails. Project, CRM, document, and spreadsheet writes depend on team context and privacy rules; require least-privilege scopes and review for workflow-changing actions. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Public seat-based pricing; API limits vary by plan.
- Auth: OAuth and personal access tokens with scopes and base access.
- Account creation: Self-serve signup.
- Browser support: Browser UI is important for base schema and interface design.
- CLI: Not listed
- API base: https://api.airtable.com/v0
- MCP server: Not listed

Agents can read and update structured operational data if bases, fields, and scopes are carefully constrained.

Score breakdown:
- Machine operability: 14/25
- Agent safety: 10.4/25
- Agent readability: 17.4/20
- Auth and setup: 12/15
- Production reliability: 13.4/15

Capabilities:
- API: native. Airtable Web API supports records, bases, tables, metadata, OAuth, and webhooks. Evidence: https://airtable.com/developers/web/api/introduction
- Browser: strong. Browser UI is important for base schema and interface design. Evidence: https://www.airtable.com
- Account creation: strong. Self-serve signup. Evidence: https://www.airtable.com
- Pricing clarity: strong. Pricing and plan limits are public. Evidence: https://www.airtable.com/pricing
- Docs quality: strong. Base-specific API docs help agents map fields safely. Evidence: https://support.airtable.com/docs/getting-started-with-airtables-web-api

### Asana

- Slug: asana
- URL: https://www.canagentsuse.com/tools/asana
- Website: https://asana.com
- Docs: https://developers.asana.com
- Agent score: 67
- Agent tier: Usable
- Categories: Project workflows, Automation & integrations
- Use cases: Triage work
- Best for: Task triage, project updates, status reporting, and operational workflows.
- Limitations: Key limitations: Task mutations and private project data need review and clear ownership. Project, CRM, document, and spreadsheet writes depend on team context and privacy rules; require least-privilege scopes and review for workflow-changing actions. MCP servers inherit the connected account's scopes and may send prompts or data to third-party services; configure read-only or narrow scopes when available. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Public seat-based pricing with plan-specific features.
- Auth: Personal access tokens, OAuth apps, webhooks, and Asana MCP app integration.
- Account creation: Self-serve signup.
- Browser support: Browser UI is helpful for project structure and approval review.
- CLI: Not listed
- API base: https://app.asana.com/api/1.0
- MCP server: https://mcp.asana.com/sse

Agents can search, create, update, and organize work if workspace permissions are scoped carefully.

Score breakdown:
- Machine operability: 18/25
- Agent safety: 9.2/25
- Agent readability: 17.4/20
- Auth and setup: 12/15
- Production reliability: 10.4/15

Capabilities:
- API: native. Developer docs cover tasks, projects, users, goals, webhooks, and events. Evidence: https://developers.asana.com/docs
- MCP: native. Asana offers an official MCP server for accessing the Asana Work Graph from compatible AI assistants. Evidence: https://developers.asana.com/docs/mcp-server
- Browser: strong. Browser UI is helpful for project structure and approval review. Evidence: https://asana.com
- Account creation: strong. Self-serve signup. Evidence: https://asana.com
- Pricing clarity: strong. Pricing is public by plan and seat. Evidence: https://asana.com/pricing
- Docs quality: strong. Docs include API reference, guides, auth, and webhook examples. Evidence: https://developers.asana.com

### Browserbase

- Slug: browserbase
- URL: https://www.canagentsuse.com/tools/browserbase
- Website: https://www.browserbase.com
- Docs: https://docs.browserbase.com
- Agent score: 67
- Agent tier: Usable
- Categories: Scraping & content, Deployment & infra
- Use cases: Extract web data, Ship an app
- Best for: Remote browser automation, logged-in workflows, and agent web tasks.
- Limitations: Key limitations: Use responsibly and respect site terms; browser automation can trigger risk systems. Respect robots.txt, site terms, rate limits, copyright, authentication boundaries, and anti-bot controls before asking an agent to crawl or extract content. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Public tiers and usage-based session pricing.
- Auth: API key and hosted account.
- Account creation: Self-serve signup.
- Browser support: Core product is remote browser access.
- CLI: Not listed
- API base: https://api.browserbase.com
- MCP server: Not listed

Strong fit when local Playwright is not enough and an agent needs durable remote browser sessions.

Score breakdown:
- Machine operability: 15/25
- Agent safety: 15.6/25
- Agent readability: 17.4/20
- Auth and setup: 12/15
- Production reliability: 7/15

Capabilities:
- API: native. API creates and manages browser sessions. Evidence: https://docs.browserbase.com
- Browser: native. Provides hosted browser execution for agents. Evidence: https://docs.browserbase.com
- Account creation: strong. Self-serve signup. Evidence: https://www.browserbase.com
- Pricing clarity: strong. Public tiers and usage-based session pricing. Evidence: https://www.browserbase.com/pricing
- Docs quality: strong. Docs focus on automation recipes and integrations. Evidence: https://docs.browserbase.com

### Sentry

- Slug: sentry
- URL: https://www.canagentsuse.com/tools/sentry
- Website: https://sentry.io
- Docs: https://docs.sentry.io
- Agent score: 67
- Agent tier: Usable
- Categories: Observability
- Use cases: Triage work, Ship an app
- Best for: Production bug triage, error monitoring, performance traces, and release health.
- Limitations: Key limitations: Issue muting/resolution should follow product judgment, not just silence noise. Issue resolution, alert muting, analytics interpretation, PII in logs, sampling, and retention settings can hide incidents or expose user data if automated too broadly. MCP servers inherit the connected account's scopes and may send prompts or data to third-party services; configure read-only or narrow scopes when available. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Public event-volume pricing with free and team tiers.
- Auth: Auth tokens, org/project scopes, DSNs, integrations, and Sentry MCP OAuth or user-token auth.
- Account creation: Self-serve signup.
- Browser support: Web UI is important for traces, screenshots, and issue context.
- CLI: Not listed
- API base: https://sentry.io/api/0
- MCP server: https://mcp.sentry.dev

Agents can inspect issues, stack traces, events, releases, traces, and Sentry MCP debugging tools to connect production errors back to code.

Score breakdown:
- Machine operability: 18/25
- Agent safety: 9.2/25
- Agent readability: 17.4/20
- Auth and setup: 12/15
- Production reliability: 10.4/15

Capabilities:
- API: native. API covers orgs, projects, issues, events, releases, and more. Evidence: https://docs.sentry.io
- MCP: native. Official Sentry MCP service and @sentry/mcp-server package are optimized for human-in-the-loop coding agents and debugging workflows. Evidence: https://github.com/getsentry/sentry-mcp
- Browser: strong. UI exposes issue context that is sometimes richer than API summaries. Evidence: https://docs.sentry.io
- Account creation: strong. Self-serve signup. Evidence: https://sentry.io
- Pricing clarity: strong. Public event-volume pricing with free and team tiers. Evidence: https://sentry.io/pricing
- Docs quality: strong. SDK setup docs are broad and framework-specific. Evidence: https://docs.sentry.io

### Slack

- Slug: slack
- URL: https://www.canagentsuse.com/tools/slack
- Website: https://slack.com
- Docs: https://api.slack.com
- Agent score: 67
- Agent tier: Usable
- Categories: Social media, Email & messaging, Project workflows
- Use cases: Publish content, Triage work
- Best for: Team notifications, chatops, support workflows, and operational alerts.
- Limitations: Key limitations: Workspace permissions, private data, and posting behavior need careful scopes. Outbound messages, SMS, email deliverability, consent, unsubscribe behavior, private chats, and customer-facing replies need approval, throttling, and audit logs. MCP servers inherit the connected account's scopes and may send prompts or data to third-party services; configure read-only or narrow scopes when available. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Public seat-based pricing with free and paid plans.
- Auth: OAuth apps, user tokens for MCP, bot tokens, signing secrets, and webhooks.
- Account creation: Self-serve workspace signup and app creation.
- Browser support: Admin and app setup often requires browser flows.
- CLI: Not listed
- API base: https://slack.com/api
- MCP server: https://mcp.slack.com/mcp

Useful for agents that need to notify teams, search approved workspace content, read threads, create canvases, or automate operational messages with Slack's MCP server.

Score breakdown:
- Machine operability: 16.5/25
- Agent safety: 9.2/25
- Agent readability: 17.4/20
- Auth and setup: 12/15
- Production reliability: 11.4/15

Capabilities:
- API: native. Web API, Events API, slash commands, and webhooks are documented. Evidence: https://api.slack.com
- MCP: native. Official Slack MCP server supports workspace search, reading channels and threads, sending messages, and related Slack actions through Streamable HTTP. Evidence: https://docs.slack.dev/ai/slack-mcp-server/
- Browser: partial. Admin permissions and app installs can need human/browser approval. Evidence: https://slack.com
- Account creation: strong. Self-serve workspace signup and app creation. Evidence: https://slack.com
- Pricing clarity: strong. Public seat-based pricing with free and paid plans. Evidence: https://slack.com/pricing
- Docs quality: strong. API docs are broad but permission-heavy. Evidence: https://api.slack.com

### HubSpot

- Slug: hubspot
- URL: https://www.canagentsuse.com/tools/hubspot
- Website: https://www.hubspot.com
- Docs: https://developers.hubspot.com/docs
- Agent score: 66
- Agent tier: Usable
- Categories: CRM & sales, Automation & integrations
- Use cases: Sync CRM, Triage work
- Best for: CRM sync, lead enrichment, ticket operations, customer data, and sales workflows.
- Limitations: Key limitations: Customer data, email sending, and CRM writes require scoped apps and human approval. Verify official docs, pricing, rate limits, permissions, and production side effects before delegating account-changing actions to an agent. MCP servers inherit the connected account's scopes and may send prompts or data to third-party services; configure read-only or narrow scopes when available. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Public product pricing but feature/API limits vary by hub and plan.
- Auth: Private app tokens, OAuth apps, CRM scopes, and HubSpot MCP OAuth credentials.
- Account creation: Self-serve CRM signup; app setup requires developer configuration.
- Browser support: Browser UI is important for schema, permissions, and workflow review.
- CLI: Not listed
- API base: https://api.hubapi.com
- MCP server: https://mcp.hubspot.com

Agents can read and update customer records, deals, tickets, and marketing data when scopes are configured carefully.

Score breakdown:
- Machine operability: 18/25
- Agent safety: 9.2/25
- Agent readability: 15.9/20
- Auth and setup: 12/15
- Production reliability: 11/15

Capabilities:
- API: native. CRM APIs cover contacts, companies, deals, tickets, associations, and custom objects. Evidence: https://developers.hubspot.com/docs/api/crm/understanding-the-crm
- MCP: native. HubSpot's remote MCP server lets compatible clients query HubSpot CRM data using OAuth-controlled app scopes. Evidence: https://developers.hubspot.com/docs/apps/developer-platform/build-apps/integrate-with-the-remote-hubspot-mcp-server
- Browser: strong. Browser UI is important for schema, permissions, and workflow review. Evidence: https://www.hubspot.com
- Account creation: strong. Self-serve CRM signup; app setup requires developer configuration. Evidence: https://www.hubspot.com
- Pricing clarity: partial. Product pricing is public, but API access and limits depend on hubs and plan. Evidence: https://www.hubspot.com/pricing
- Docs quality: strong. Developer docs include API reference, guides, scopes, and webhooks. Evidence: https://developers.hubspot.com/docs

### Intercom

- Slug: intercom
- URL: https://www.canagentsuse.com/tools/intercom
- Website: https://www.intercom.com
- Docs: https://developers.intercom.com
- Agent score: 66
- Agent tier: Usable
- Categories: Support & success, CRM & sales
- Use cases: Triage work, Sync CRM
- Best for: Support inbox triage, customer messaging, help center content, and product support automation.
- Limitations: Key limitations: Customer messages and helpdesk changes require approval, privacy review, and escalation paths. Verify official docs, pricing, rate limits, permissions, and production side effects before delegating account-changing actions to an agent. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Public plan pricing with add-ons and usage dimensions.
- Auth: OAuth apps, access tokens, and workspace permissions.
- Account creation: Self-serve trial/signup.
- Browser support: Inbox UI is important for human review and escalation.
- CLI: Not listed
- API base: https://api.intercom.io
- MCP server: Not listed

Agents can assist support and success workflows by reading conversations and updating records with careful permissions.

Score breakdown:
- Machine operability: 14/25
- Agent safety: 10.4/25
- Agent readability: 15.9/20
- Auth and setup: 12/15
- Production reliability: 13.4/15

Capabilities:
- API: native. REST API covers contacts, conversations, tickets, articles, data events, and admins. Evidence: https://developers.intercom.com/docs/references/rest-api/api.intercom.io/
- Browser: strong. Inbox UI is important for human review and escalation. Evidence: https://www.intercom.com
- Account creation: strong. Self-serve trial/signup. Evidence: https://www.intercom.com
- Pricing clarity: partial. Pricing is public but add-ons and usage can vary. Evidence: https://www.intercom.com/pricing
- Docs quality: strong. Developer docs include API references, auth, webhooks, and messenger concepts. Evidence: https://developers.intercom.com

### Pipedream

- Slug: pipedream
- URL: https://www.canagentsuse.com/tools/pipedream
- Website: https://pipedream.com
- Docs: https://pipedream.com/docs
- Agent score: 66
- Agent tier: Usable
- Categories: Automation & integrations
- Use cases: Triage work, Publish content, Sync CRM
- Best for: Webhook-driven automation, managed OAuth connectors, developer workflows, and agent tool backends.
- Limitations: Key limitations: Connected accounts and workflow side effects need explicit permissioning and review. Verify official docs, pricing, rate limits, permissions, and production side effects before delegating account-changing actions to an agent. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Public credit/usage-based pricing with free tier.
- Auth: Bearer tokens, OAuth, project/user scoping, and connected accounts.
- Account creation: Self-serve signup.
- Browser support: Workflow editor helps review code, logs, and connected accounts.
- CLI: Not listed
- API base: https://api.pipedream.com/v1
- MCP server: Not listed

Agents can create workflows, manage event sources, invoke actions, and connect user accounts through APIs.

Score breakdown:
- Machine operability: 12.5/25
- Agent safety: 10.4/25
- Agent readability: 17.4/20
- Auth and setup: 12/15
- Production reliability: 14/15

Capabilities:
- API: native. REST API manages workflows, event sources, subscriptions, and account resources. Evidence: https://pipedream.com/docs/rest-api/
- Browser: partial. Workflow editor helps review code, logs, and connected accounts. Evidence: https://pipedream.com
- Account creation: strong. Self-serve signup. Evidence: https://pipedream.com
- Pricing clarity: strong. Pricing is public with credits and workflow dimensions. Evidence: https://pipedream.com/pricing
- Docs quality: strong. Docs include REST API, Connect API, SDKs, sources, and workflows. Evidence: https://pipedream.com/docs/connect/api-ref

### Typeform

- Slug: typeform
- URL: https://www.canagentsuse.com/tools/typeform
- Website: https://www.typeform.com
- Docs: https://www.typeform.com/developers
- Agent score: 66
- Agent tier: Usable
- Categories: Automation & integrations, Spreadsheets & data
- Use cases: Publish content, Triage work
- Best for: Lead capture, surveys, research forms, onboarding forms, and structured intake.
- Limitations: Key limitations: Respondent PII, consent, and webhook destinations need review. Verify official docs, pricing, rate limits, permissions, and production side effects before delegating account-changing actions to an agent. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Public form/product pricing with response and feature limits.
- Auth: OAuth apps and personal access tokens.
- Account creation: Self-serve signup.
- Browser support: Form design and brand review are often browser-first.
- CLI: Not listed
- API base: https://api.typeform.com
- MCP server: Not listed

Agents can create intake forms, retrieve submissions, and connect form events into workflows.

Score breakdown:
- Machine operability: 12.5/25
- Agent safety: 10.4/25
- Agent readability: 17.4/20
- Auth and setup: 12/15
- Production reliability: 13.4/15

Capabilities:
- API: native. Developer docs cover Create API, Responses API, webhooks, and embeds. Evidence: https://www.typeform.com/developers/
- Browser: partial. Form design and brand review are often browser-first. Evidence: https://www.typeform.com
- Account creation: strong. Self-serve signup. Evidence: https://www.typeform.com
- Pricing clarity: strong. Plans and response limits are public. Evidence: https://www.typeform.com/pricing/
- Docs quality: strong. Docs include reference, auth, examples, and webhook flows. Evidence: https://www.typeform.com/developers/

### Zendesk

- Slug: zendesk
- URL: https://www.canagentsuse.com/tools/zendesk
- Website: https://www.zendesk.com
- Docs: https://developer.zendesk.com
- Agent score: 66
- Agent tier: Usable
- Categories: Support & success, CRM & sales
- Use cases: Triage work, Sync CRM
- Best for: Customer support automation, ticket triage, help center workflows, and customer success.
- Limitations: Key limitations: Customer PII and outbound replies require approval and auditability. Verify official docs, pricing, rate limits, permissions, and production side effects before delegating account-changing actions to an agent. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Public seat-based pricing; suite features vary by plan.
- Auth: OAuth, API tokens, basic auth variants, and role permissions.
- Account creation: Self-serve trial/signup.
- Browser support: Agent workspace is useful for review and human escalation.
- CLI: Not listed
- API base: https://{subdomain}.zendesk.com/api/v2
- MCP server: Not listed

Agents can triage support queues, draft replies, inspect users, and update tickets with scoped credentials.

Score breakdown:
- Machine operability: 12.5/25
- Agent safety: 10.4/25
- Agent readability: 17.4/20
- Auth and setup: 12/15
- Production reliability: 14/15

Capabilities:
- API: native. API reference covers tickets, users, organizations, help center, webhooks, and messaging. Evidence: https://developer.zendesk.com/api-reference/
- Browser: partial. Agent workspace is useful for review and human escalation. Evidence: https://www.zendesk.com
- Account creation: strong. Self-serve trial/signup. Evidence: https://www.zendesk.com
- Pricing clarity: strong. Pricing is public by suite and support plan. Evidence: https://www.zendesk.com/pricing/
- Docs quality: strong. Developer docs include guides, app framework, and API refs. Evidence: https://developer.zendesk.com

### OpenRouter

- Slug: openrouter
- URL: https://www.canagentsuse.com/tools/openrouter
- Website: https://openrouter.ai
- Docs: https://openrouter.ai/docs
- Agent score: 65
- Agent tier: Usable
- Categories: AI models
- Use cases: Call models
- Best for: Model routing, fallback experiments, quick access to many providers, and cost comparison.
- Limitations: Key limitations: Provider-specific reliability, data policy, and model versioning need review before sensitive workloads. Model behavior, costs, rate limits, data retention, and safety policies can change by model and account tier; use evals, spend caps, and data controls for sensitive workloads. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Public model catalog with per-token prices and provider routing details.
- Auth: API keys and optional app attribution headers.
- Account creation: Self-serve signup and credit-based usage.
- Browser support: Dashboard supports keys, credits, activity, and model selection.
- CLI: Not listed
- API base: https://openrouter.ai/api/v1
- MCP server: Not listed

Good for agents that need model fallback or broad model selection through one API, but provider variability needs monitoring.

Score breakdown:
- Machine operability: 14/25
- Agent safety: 10.4/25
- Agent readability: 18.4/20
- Auth and setup: 12/15
- Production reliability: 10/15

Capabilities:
- API: native. OpenAI-compatible chat completions API supports many models. Evidence: https://openrouter.ai/docs/api-reference/overview
- Browser: strong. Dashboard supports keys, credits, activity, and model selection. Evidence: https://openrouter.ai
- Account creation: strong. Self-serve signup and credit-based usage. Evidence: https://openrouter.ai
- Pricing clarity: native. Model pages expose provider and per-token pricing. Evidence: https://openrouter.ai/models
- Docs quality: strong. Docs explain routing, headers, parameters, and provider behavior. Evidence: https://openrouter.ai/docs

### Trello

- Slug: trello
- URL: https://www.canagentsuse.com/tools/trello
- Website: https://trello.com
- Docs: https://developer.atlassian.com/cloud/trello
- Agent score: 65
- Agent tier: Usable
- Categories: Project workflows
- Use cases: Triage work
- Best for: Simple project boards, content workflows, checklists, and operational task tracking.
- Limitations: Key limitations: Card moves and public/private board permissions need review. Project, CRM, document, and spreadsheet writes depend on team context and privacy rules; require least-privilege scopes and review for workflow-changing actions. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Public Trello plan pricing.
- Auth: API key/token, OAuth-like token authorization, and workspace permissions.
- Account creation: Self-serve Atlassian/Trello signup.
- Browser support: Board UI is the main review surface.
- CLI: Not listed
- API base: https://api.trello.com/1
- MCP server: Not listed

Agents can move cards, create tasks, and inspect lightweight workflows when board permissions are constrained.

Score breakdown:
- Machine operability: 12.5/25
- Agent safety: 10.4/25
- Agent readability: 17.4/20
- Auth and setup: 12/15
- Production reliability: 12.8/15

Capabilities:
- API: native. REST API covers boards, cards, lists, actions, members, and webhooks. Evidence: https://developer.atlassian.com/cloud/trello/rest/
- Browser: partial. Board UI is the main review surface. Evidence: https://trello.com
- Account creation: strong. Self-serve Atlassian/Trello signup. Evidence: https://trello.com
- Pricing clarity: strong. Pricing is public by plan. Evidence: https://trello.com/pricing
- Docs quality: strong. Developer docs include API reference and auth patterns. Evidence: https://developer.atlassian.com/cloud/trello/

### Activepieces

- Slug: activepieces
- URL: https://www.canagentsuse.com/tools/activepieces
- Website: https://www.activepieces.com
- Docs: https://github.com/activepieces/activepieces
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Automation
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted automation workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/activepieces/activepieces
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Activepieces is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/activepieces/activepieces
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.activepieces.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/activepieces/activepieces
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/activepieces/activepieces
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/activepieces/activepieces
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/activepieces/activepieces

### AdGuard Home

- Slug: adguard-home
- URL: https://www.canagentsuse.com/tools/adguard-home
- Website: https://adguard.com/en/adguard-home/overview.html
- Docs: https://github.com/AdguardTeam/AdGuardHome
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, DNS
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted dns workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/AdguardTeam/AdGuardHome
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

AdGuard Home is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/AdguardTeam/AdGuardHome
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://adguard.com/en/adguard-home/overview.html
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/AdguardTeam/AdGuardHome
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/AdguardTeam/AdGuardHome
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/AdguardTeam/AdGuardHome
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/AdguardTeam/AdGuardHome

### Adminer

- Slug: adminer
- URL: https://www.canagentsuse.com/tools/adminer
- Website: https://www.adminer.org/
- Docs: https://github.com/vrana/adminer
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Database Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Triage work
- Best for: Self-hosted database management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0, GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/vrana/adminer
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Adminer is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/vrana/adminer
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.adminer.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/vrana/adminer
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/vrana/adminer
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/vrana/adminer
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/vrana/adminer

### Algernon

- Slug: algernon
- URL: https://www.canagentsuse.com/tools/algernon
- Website: https://algernon.roboticoverlords.org/
- Docs: https://github.com/xyproto/algernon
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Web Servers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted web servers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as BSD-3-Clause; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker. Source code: https://github.com/xyproto/algernon
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Algernon is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/xyproto/algernon
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://algernon.roboticoverlords.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/xyproto/algernon
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/xyproto/algernon
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/xyproto/algernon
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/xyproto/algernon

### AliasVault

- Slug: aliasvault
- URL: https://www.canagentsuse.com/tools/aliasvault
- Website: https://www.aliasvault.net
- Docs: https://github.com/aliasvault/aliasvault
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Password Managers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted password managers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/aliasvault/aliasvault
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

AliasVault is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/aliasvault/aliasvault
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.aliasvault.net
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/aliasvault/aliasvault
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/aliasvault/aliasvault
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/aliasvault/aliasvault
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/aliasvault/aliasvault

### Ansible-NAS

- Slug: ansible-nas
- URL: https://www.canagentsuse.com/tools/ansible-nas
- Website: https://github.com/DaveStephens/ansible-nas
- Docs: https://github.com/DaveStephens/ansible-nas
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Self-hosting Solutions
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted self-hosting solutions workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Ansible, Docker. Source code: https://github.com/DaveStephens/ansible-nas
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Ansible-NAS is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/DaveStephens/ansible-nas
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/DaveStephens/ansible-nas
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/DaveStephens/ansible-nas
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/DaveStephens/ansible-nas
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/DaveStephens/ansible-nas
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/DaveStephens/ansible-nas

### AnyCable

- Slug: anycable
- URL: https://www.canagentsuse.com/tools/anycable
- Website: https://anycable.io/
- Docs: https://github.com/anycable/anycable
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Communication - Custom Communication Systems
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - custom communication systems workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker. Source code: https://github.com/anycable/anycable
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

AnyCable is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/anycable/anycable
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://anycable.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/anycable/anycable
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/anycable/anycable
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/anycable/anycable
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/anycable/anycable

### Apache Airflow

- Slug: apache-airflow
- URL: https://www.canagentsuse.com/tools/apache-airflow
- Website: https://airflow.apache.org/
- Docs: https://github.com/apache/airflow/
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Automation
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Analyze product
- Best for: Self-hosted automation workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python, Docker. Source code: https://github.com/apache/airflow/
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Apache Airflow is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/apache/airflow/
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://airflow.apache.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/apache/airflow/
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/apache/airflow/
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/apache/airflow/
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/apache/airflow/

### Appwrite

- Slug: appwrite
- URL: https://www.canagentsuse.com/tools/appwrite
- Website: https://appwrite.io
- Docs: https://github.com/appwrite/appwrite
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Software Development - Low Code
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted software development - low code workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as BSD-3-Clause; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/appwrite/appwrite
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Appwrite is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/appwrite/appwrite
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://appwrite.io
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/appwrite/appwrite
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/appwrite/appwrite
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/appwrite/appwrite
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/appwrite/appwrite

### asciinema

- Slug: asciinema
- URL: https://www.canagentsuse.com/tools/asciinema
- Website: https://asciinema.org/
- Docs: https://github.com/asciinema/asciinema-server
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Miscellaneous
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted miscellaneous workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Elixir, Docker. Source code: https://github.com/asciinema/asciinema-server
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

asciinema is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/asciinema/asciinema-server
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://asciinema.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/asciinema/asciinema-server
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/asciinema/asciinema-server
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/asciinema/asciinema-server
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/asciinema/asciinema-server

### Asterisk

- Slug: asterisk
- URL: https://www.canagentsuse.com/tools/asterisk
- Website: https://www.asterisk.org/
- Docs: https://github.com/asterisk/asterisk
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Communication - SIP
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - sip workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C, deb. Source code: https://github.com/asterisk/asterisk
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Asterisk is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/asterisk/asterisk
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.asterisk.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/asterisk/asterisk
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/asterisk/asterisk
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/asterisk/asterisk
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/asterisk/asterisk

### Atomic Server

- Slug: atomic-server
- URL: https://www.canagentsuse.com/tools/atomic-server
- Website: https://atomicserver.eu/
- Docs: https://github.com/ontola/atomic-server
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Knowledge Management Tools
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content, Triage work
- Best for: Self-hosted knowledge management tools workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Rust. Source code: https://github.com/ontola/atomic-server
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Atomic Server is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/ontola/atomic-server
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://atomicserver.eu/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/ontola/atomic-server
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/ontola/atomic-server
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/ontola/atomic-server
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/ontola/atomic-server

### Audiobookshelf

- Slug: audiobookshelf
- URL: https://www.canagentsuse.com/tools/audiobookshelf
- Website: https://www.audiobookshelf.org/
- Docs: https://github.com/advplyr/audiobookshelf
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Media Streaming - Audio Streaming, Document Management - E-books
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted media streaming - audio streaming workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, deb, Nodejs. Source code: https://github.com/advplyr/audiobookshelf
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Audiobookshelf is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/advplyr/audiobookshelf
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.audiobookshelf.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/advplyr/audiobookshelf
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/advplyr/audiobookshelf
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/advplyr/audiobookshelf
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/advplyr/audiobookshelf

### auto-mcs

- Slug: auto-mcs
- URL: https://www.canagentsuse.com/tools/auto-mcs
- Website: https://www.auto-mcs.com
- Docs: https://github.com/macarooni-man/auto-mcs
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Games - Administrative Utilities & Control Panels
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted games - administrative utilities & control panels workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python. Source code: https://github.com/macarooni-man/auto-mcs
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

auto-mcs is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/macarooni-man/auto-mcs
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.auto-mcs.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/macarooni-man/auto-mcs
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/macarooni-man/auto-mcs
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/macarooni-man/auto-mcs
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/macarooni-man/auto-mcs

### autokitteh

- Slug: autokitteh
- URL: https://www.canagentsuse.com/tools/autokitteh
- Website: https://autokitteh.com/
- Docs: https://github.com/autokitteh/autokitteh
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Software Development - Low Code
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted software development - low code workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker. Source code: https://github.com/autokitteh/autokitteh
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

autokitteh is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/autokitteh/autokitteh
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://autokitteh.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/autokitteh/autokitteh
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/autokitteh/autokitteh
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/autokitteh/autokitteh
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/autokitteh/autokitteh

### Automatisch

- Slug: automatisch
- URL: https://www.canagentsuse.com/tools/automatisch
- Website: https://automatisch.io
- Docs: https://github.com/automatisch/automatisch
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Automation
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted automation workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/automatisch/automatisch
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Automatisch is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/automatisch/automatisch
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://automatisch.io
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/automatisch/automatisch
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/automatisch/automatisch
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/automatisch/automatisch
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/automatisch/automatisch

### AWStats

- Slug: awstats
- URL: https://www.canagentsuse.com/tools/awstats
- Website: http://www.awstats.org/
- Docs: https://github.com/eldy/awstats
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Analytics
- Use cases: Self-host a tool, Inspect open source, Analyze product
- Best for: Self-hosted analytics workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Perl. Source code: https://github.com/eldy/awstats
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

AWStats is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/eldy/awstats
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: http://www.awstats.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/eldy/awstats
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/eldy/awstats
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/eldy/awstats
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/eldy/awstats

### Azimutt

- Slug: azimutt
- URL: https://www.canagentsuse.com/tools/azimutt
- Website: https://azimutt.app
- Docs: https://github.com/azimuttapp/azimutt
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Database Management, Software Development - IDE & Tools
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content, Triage work
- Best for: Self-hosted database management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Elixir, Nodejs, Docker. Source code: https://github.com/azimuttapp/azimutt
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Azimutt is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/azimuttapp/azimutt
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://azimutt.app
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/azimuttapp/azimutt
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/azimuttapp/azimutt
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/azimuttapp/azimutt
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/azimuttapp/azimutt

### Baïkal

- Slug: ba-kal
- URL: https://www.canagentsuse.com/tools/ba-kal
- Website: https://sabre.io/baikal/
- Docs: https://github.com/sabre-io/Baikal
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Calendar & Contacts
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted calendar & contacts workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/sabre-io/Baikal
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Baïkal is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/sabre-io/Baikal
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://sabre.io/baikal/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/sabre-io/Baikal
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/sabre-io/Baikal
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/sabre-io/Baikal
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/sabre-io/Baikal

### Baserow

- Slug: baserow
- URL: https://www.canagentsuse.com/tools/baserow
- Website: https://baserow.io/
- Docs: https://gitlab.com/baserow/baserow
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Database Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Triage work
- Best for: Self-hosted database management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://gitlab.com/baserow/baserow
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Baserow is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://gitlab.com/baserow/baserow
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://baserow.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://gitlab.com/baserow/baserow
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://gitlab.com/baserow/baserow
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://gitlab.com/baserow/baserow
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://gitlab.com/baserow/baserow

### Bigcapital

- Slug: bigcapital
- URL: https://www.canagentsuse.com/tools/bigcapital
- Website: https://bigcapital.app/
- Docs: https://github.com/bigcapitalhq/bigcapital
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Money, Budgeting & Management, Inventory Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted money, budgeting & management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/bigcapitalhq/bigcapital
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Bigcapital is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/bigcapitalhq/bigcapital
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://bigcapital.app/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/bigcapitalhq/bigcapital
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/bigcapitalhq/bigcapital
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/bigcapitalhq/bigcapital
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/bigcapitalhq/bigcapital

### bitmagnet

- Slug: bitmagnet
- URL: https://www.canagentsuse.com/tools/bitmagnet
- Website: https://bitmagnet.io
- Docs: https://github.com/bitmagnet-io/bitmagnet
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Archiving and Digital Preservation (DP), File Transfer - Peer-to-peer Filesharing, Search Engines
- Use cases: Self-host a tool, Inspect open source, Publish content, Triage work
- Best for: Self-hosted archiving and digital preservation (dp) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker. Source code: https://github.com/bitmagnet-io/bitmagnet
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

bitmagnet is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/bitmagnet-io/bitmagnet
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://bitmagnet.io
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/bitmagnet-io/bitmagnet
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/bitmagnet-io/bitmagnet
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/bitmagnet-io/bitmagnet
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/bitmagnet-io/bitmagnet

### Bitwarden

- Slug: bitwarden
- URL: https://www.canagentsuse.com/tools/bitwarden
- Website: https://bitwarden.com/
- Docs: https://github.com/bitwarden/server
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Password Managers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted password managers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, C#. Source code: https://github.com/bitwarden/server
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Bitwarden is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/bitwarden/server
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://bitwarden.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/bitwarden/server
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/bitwarden/server
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/bitwarden/server
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/bitwarden/server

### Black Candy

- Slug: black-candy
- URL: https://www.canagentsuse.com/tools/black-candy
- Website: https://github.com/blackcandy-org/blackcandy
- Docs: https://github.com/blackcandy-org/blackcandy
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Media Streaming - Audio Streaming
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted media streaming - audio streaming workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Ruby. Source code: https://github.com/blackcandy-org/blackcandy
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Black Candy is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/blackcandy-org/blackcandy
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/blackcandy-org/blackcandy
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/blackcandy-org/blackcandy
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/blackcandy-org/blackcandy
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/blackcandy-org/blackcandy
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/blackcandy-org/blackcandy

### BookBounty

- Slug: bookbounty
- URL: https://www.canagentsuse.com/tools/bookbounty
- Website: https://github.com/TheWicklowWolf/BookBounty
- Docs: https://github.com/TheWicklowWolf/BookBounty
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Automation
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted automation workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/TheWicklowWolf/BookBounty
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

BookBounty is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/TheWicklowWolf/BookBounty
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/TheWicklowWolf/BookBounty
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/TheWicklowWolf/BookBounty
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/TheWicklowWolf/BookBounty
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/TheWicklowWolf/BookBounty
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/TheWicklowWolf/BookBounty

### BTCPay Server

- Slug: btcpay-server
- URL: https://www.canagentsuse.com/tools/btcpay-server
- Website: https://btcpayserver.org/
- Docs: https://github.com/btcpayserver/btcpayserver
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Money, Budgeting & Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted money, budgeting & management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C#. Source code: https://github.com/btcpayserver/btcpayserver
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

BTCPay Server is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/btcpayserver/btcpayserver
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://btcpayserver.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/btcpayserver/btcpayserver
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/btcpayserver/btcpayserver
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/btcpayserver/btcpayserver
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/btcpayserver/btcpayserver

### BunkerWeb

- Slug: bunkerweb
- URL: https://www.canagentsuse.com/tools/bunkerweb
- Website: https://www.bunkerweb.io
- Docs: https://github.com/bunkerity/bunkerweb
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Web Servers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted web servers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: deb, Docker, K8S, Python. Source code: https://github.com/bunkerity/bunkerweb
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

BunkerWeb is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/bunkerity/bunkerweb
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.bunkerweb.io
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/bunkerity/bunkerweb
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/bunkerity/bunkerweb
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/bunkerity/bunkerweb
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/bunkerity/bunkerweb

### Caddy

- Slug: caddy
- URL: https://www.canagentsuse.com/tools/caddy
- Website: https://caddyserver.com/
- Docs: https://github.com/caddyserver/caddy
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Web Servers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted web servers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, deb, Docker. Source code: https://github.com/caddyserver/caddy
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Caddy is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/caddyserver/caddy
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://caddyserver.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/caddyserver/caddy
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/caddyserver/caddy
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/caddyserver/caddy
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/caddyserver/caddy

### Calagopus

- Slug: calagopus
- URL: https://www.canagentsuse.com/tools/calagopus
- Website: https://calagopus.com
- Docs: https://github.com/calagopus/panel
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Games - Administrative Utilities & Control Panels
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Analyze product
- Best for: Self-hosted games - administrative utilities & control panels workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Rust, Docker, deb. Source code: https://github.com/calagopus/panel
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Calagopus is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/calagopus/panel
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://calagopus.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/calagopus/panel
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/calagopus/panel
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/calagopus/panel
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/calagopus/panel

### Calibre Web

- Slug: calibre-web
- URL: https://www.canagentsuse.com/tools/calibre-web
- Website: https://github.com/janeczku/calibre-web
- Docs: https://github.com/janeczku/calibre-web
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Document Management - E-books
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content, Triage work
- Best for: Self-hosted document management - e-books workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python. Source code: https://github.com/janeczku/calibre-web
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Calibre Web is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/janeczku/calibre-web
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/janeczku/calibre-web
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/janeczku/calibre-web
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/janeczku/calibre-web
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/janeczku/calibre-web
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/janeczku/calibre-web

### Centrifugo

- Slug: centrifugo
- URL: https://www.canagentsuse.com/tools/centrifugo
- Website: https://centrifugal.dev/
- Docs: https://github.com/centrifugal/centrifugo
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Communication - Custom Communication Systems
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - custom communication systems workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker, K8S. Source code: https://github.com/centrifugal/centrifugo
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Centrifugo is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/centrifugal/centrifugo
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://centrifugal.dev/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/centrifugal/centrifugo
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/centrifugal/centrifugo
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/centrifugal/centrifugo
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/centrifugal/centrifugo

### changedetection.io

- Slug: changedetection-io
- URL: https://www.canagentsuse.com/tools/changedetection-io
- Website: https://changedetection.io/
- Docs: https://github.com/dgtlmoon/changedetection.io
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Automation
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted automation workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python, Docker. Source code: https://github.com/dgtlmoon/changedetection.io
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

changedetection.io is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/dgtlmoon/changedetection.io
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://changedetection.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/dgtlmoon/changedetection.io
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/dgtlmoon/changedetection.io
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/dgtlmoon/changedetection.io
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/dgtlmoon/changedetection.io

### Chartbrew

- Slug: chartbrew
- URL: https://www.canagentsuse.com/tools/chartbrew
- Website: https://chartbrew.com
- Docs: https://github.com/chartbrew/chartbrew
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Database Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Triage work
- Best for: Self-hosted database management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/chartbrew/chartbrew
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Chartbrew is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/chartbrew/chartbrew
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://chartbrew.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/chartbrew/chartbrew
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/chartbrew/chartbrew
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/chartbrew/chartbrew
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/chartbrew/chartbrew

### ChartDB

- Slug: chartdb
- URL: https://www.canagentsuse.com/tools/chartdb
- Website: https://chartdb.io/
- Docs: https://github.com/chartdb/chartdb
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Database Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Triage work
- Best for: Self-hosted database management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/chartdb/chartdb
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

ChartDB is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/chartdb/chartdb
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://chartdb.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/chartdb/chartdb
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/chartdb/chartdb
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/chartdb/chartdb
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/chartdb/chartdb

### ChiefOnboarding

- Slug: chiefonboarding
- URL: https://www.canagentsuse.com/tools/chiefonboarding
- Website: https://chiefonboarding.com
- Docs: https://github.com/chiefonboarding/ChiefOnboarding
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Automation
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted automation workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/chiefonboarding/ChiefOnboarding
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

ChiefOnboarding is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/chiefonboarding/ChiefOnboarding
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://chiefonboarding.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/chiefonboarding/ChiefOnboarding
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/chiefonboarding/ChiefOnboarding
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/chiefonboarding/ChiefOnboarding
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/chiefonboarding/ChiefOnboarding

### Chitchatter

- Slug: chitchatter
- URL: https://www.canagentsuse.com/tools/chitchatter
- Website: https://chitchatter.im/
- Docs: https://github.com/jeremyckahn/chitchatter
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Communication - Custom Communication Systems
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - custom communication systems workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs. Source code: https://github.com/jeremyckahn/chitchatter
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Chitchatter is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/jeremyckahn/chitchatter
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://chitchatter.im/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/jeremyckahn/chitchatter
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/jeremyckahn/chitchatter
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/jeremyckahn/chitchatter
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/jeremyckahn/chitchatter

### CloudBeaver

- Slug: cloudbeaver
- URL: https://www.canagentsuse.com/tools/cloudbeaver
- Website: https://dbeaver.com/
- Docs: https://github.com/dbeaver/cloudbeaver
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Database Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Triage work
- Best for: Self-hosted database management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/dbeaver/cloudbeaver
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

CloudBeaver is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/dbeaver/cloudbeaver
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://dbeaver.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/dbeaver/cloudbeaver
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/dbeaver/cloudbeaver
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/dbeaver/cloudbeaver
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/dbeaver/cloudbeaver

### code-server

- Slug: code-server
- URL: https://www.canagentsuse.com/tools/code-server
- Website: https://github.com/coder/code-server
- Docs: https://github.com/coder/code-server
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Software Development - IDE & Tools
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted software development - ide & tools workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/coder/code-server
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

code-server is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/coder/code-server
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/coder/code-server
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/coder/code-server
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/coder/code-server
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/coder/code-server
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/coder/code-server

### Colanode

- Slug: colanode
- URL: https://www.canagentsuse.com/tools/colanode
- Website: https://colanode.com
- Docs: https://github.com/colanode/colanode
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Groupware
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Triage work
- Best for: Self-hosted groupware workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: K8S, Docker. Source code: https://github.com/colanode/colanode
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Colanode is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/colanode/colanode
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://colanode.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/colanode/colanode
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/colanode/colanode
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/colanode/colanode
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/colanode/colanode

### Composio

- Slug: composio
- URL: https://www.canagentsuse.com/tools/composio
- Website: https://composio.dev/
- Docs: https://github.com/ComposioHQ/composio
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Software Development - API Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted software development - api management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Elastic-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python. Source code: https://github.com/ComposioHQ/composio
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Composio is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/ComposioHQ/composio
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://composio.dev/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/ComposioHQ/composio
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/ComposioHQ/composio
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/ComposioHQ/composio
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/ComposioHQ/composio

### Conduit

- Slug: conduit
- URL: https://www.canagentsuse.com/tools/conduit
- Website: https://conduit.rs/
- Docs: https://gitlab.com/famedly/conduit
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Communication - Custom Communication Systems
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - custom communication systems workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Rust. Source code: https://gitlab.com/famedly/conduit
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Conduit is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://gitlab.com/famedly/conduit
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://conduit.rs/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://gitlab.com/famedly/conduit
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://gitlab.com/famedly/conduit
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://gitlab.com/famedly/conduit
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://gitlab.com/famedly/conduit

### copyparty

- Slug: copyparty
- URL: https://www.canagentsuse.com/tools/copyparty
- Website: https://github.com/9001/copyparty
- Docs: https://github.com/9001/copyparty
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, File Transfer - Web-based File Managers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted file transfer - web-based file managers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python. Source code: https://github.com/9001/copyparty
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

copyparty is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/9001/copyparty
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/9001/copyparty
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/9001/copyparty
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/9001/copyparty
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/9001/copyparty
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/9001/copyparty

### Corteza

- Slug: corteza
- URL: https://www.canagentsuse.com/tools/corteza
- Website: https://docs.cortezaproject.org
- Docs: https://github.com/cortezaproject/corteza
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Customer Relationship Management (CRM)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted customer relationship management (crm) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go. Source code: https://github.com/cortezaproject/corteza
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Corteza is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/cortezaproject/corteza
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://docs.cortezaproject.org
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/cortezaproject/corteza
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/cortezaproject/corteza
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/cortezaproject/corteza
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/cortezaproject/corteza

### Cosmos

- Slug: cosmos
- URL: https://www.canagentsuse.com/tools/cosmos
- Website: https://cosmos-cloud.io/
- Docs: https://github.com/azukaar/cosmos-Server
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Self-hosting Solutions
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted self-hosting solutions workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0, Commons-Clause; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Go. Source code: https://github.com/azukaar/cosmos-Server
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Cosmos is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/azukaar/cosmos-Server
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://cosmos-cloud.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/azukaar/cosmos-Server
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/azukaar/cosmos-Server
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/azukaar/cosmos-Server
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/azukaar/cosmos-Server

### Countly Community Edition

- Slug: countly-community-edition
- URL: https://www.canagentsuse.com/tools/countly-community-edition
- Website: https://count.ly
- Docs: https://github.com/Countly/countly-server
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Analytics
- Use cases: Self-host a tool, Inspect open source, Analyze product
- Best for: Self-hosted analytics workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/Countly/countly-server
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Countly Community Edition is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/Countly/countly-server
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://count.ly
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Countly/countly-server
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Countly/countly-server
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Countly/countly-server
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Countly/countly-server

### Crafty Controller

- Slug: crafty-controller
- URL: https://www.canagentsuse.com/tools/crafty-controller
- Website: https://craftycontrol.com/
- Docs: https://gitlab.com/crafty-controller/crafty-4
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Games - Administrative Utilities & Control Panels
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted games - administrative utilities & control panels workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Python. Source code: https://gitlab.com/crafty-controller/crafty-4
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Crafty Controller is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://gitlab.com/crafty-controller/crafty-4
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://craftycontrol.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://gitlab.com/crafty-controller/crafty-4
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://gitlab.com/crafty-controller/crafty-4
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://gitlab.com/crafty-controller/crafty-4
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://gitlab.com/crafty-controller/crafty-4

### Cronicle

- Slug: cronicle
- URL: https://www.canagentsuse.com/tools/cronicle
- Website: https://cronicle.net/
- Docs: https://github.com/jhuckaby/Cronicle
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Automation
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted automation workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs. Source code: https://github.com/jhuckaby/Cronicle
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Cronicle is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/jhuckaby/Cronicle
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://cronicle.net/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/jhuckaby/Cronicle
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/jhuckaby/Cronicle
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/jhuckaby/Cronicle
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/jhuckaby/Cronicle

### Cronmaster

- Slug: cronmaster
- URL: https://www.canagentsuse.com/tools/cronmaster
- Website: https://github.com/fccview/cronmaster
- Docs: https://github.com/fccview/cronmaster
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Automation
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Analyze product
- Best for: Self-hosted automation workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/fccview/cronmaster
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Cronmaster is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/fccview/cronmaster
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/fccview/cronmaster
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/fccview/cronmaster
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/fccview/cronmaster
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/fccview/cronmaster
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/fccview/cronmaster

### Cyrus IMAP

- Slug: cyrus-imap
- URL: https://www.canagentsuse.com/tools/cyrus-imap
- Website: https://www.cyrusimap.org/
- Docs: https://github.com/cyrusimap/cyrus-imapd
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Communication - Email - Mail Delivery Agents
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - email - mail delivery agents workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as BSD-3-Clause-Attribution; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C. Source code: https://github.com/cyrusimap/cyrus-imapd
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Cyrus IMAP is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/cyrusimap/cyrus-imapd
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.cyrusimap.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/cyrusimap/cyrus-imapd
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/cyrusimap/cyrus-imapd
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/cyrusimap/cyrus-imapd
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/cyrusimap/cyrus-imapd

### Daily Stars Explorer

- Slug: daily-stars-explorer
- URL: https://www.canagentsuse.com/tools/daily-stars-explorer
- Website: https://emanuelef.github.io/daily-stars-explorer
- Docs: https://github.com/emanuelef/daily-stars-explorer
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Analytics
- Use cases: Self-host a tool, Inspect open source, Analyze product
- Best for: Self-hosted analytics workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Nodejs, Docker. Source code: https://github.com/emanuelef/daily-stars-explorer
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Daily Stars Explorer is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/emanuelef/daily-stars-explorer
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://emanuelef.github.io/daily-stars-explorer
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/emanuelef/daily-stars-explorer
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/emanuelef/daily-stars-explorer
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/emanuelef/daily-stars-explorer
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/emanuelef/daily-stars-explorer

### Damselfly

- Slug: damselfly
- URL: https://www.canagentsuse.com/tools/damselfly
- Website: https://damselfly.info
- Docs: https://github.com/webreaper/damselfly
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Photo Galleries
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Triage work
- Best for: Self-hosted photo galleries workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, C#, .NET. Source code: https://github.com/webreaper/damselfly
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Damselfly is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/webreaper/damselfly
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://damselfly.info
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/webreaper/damselfly
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/webreaper/damselfly
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/webreaper/damselfly
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/webreaper/damselfly

### Databunker

- Slug: databunker
- URL: https://www.canagentsuse.com/tools/databunker
- Website: https://databunker.org/
- Docs: https://github.com/securitybunker/databunker
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Database Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Triage work
- Best for: Self-hosted database management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/securitybunker/databunker
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Databunker is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/securitybunker/databunker
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://databunker.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/securitybunker/databunker
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/securitybunker/databunker
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/securitybunker/databunker
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/securitybunker/databunker

### Datasette

- Slug: datasette
- URL: https://www.canagentsuse.com/tools/datasette
- Website: https://datasette.io/
- Docs: https://github.com/simonw/datasette
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Database Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Triage work
- Best for: Self-hosted database management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python, Docker. Source code: https://github.com/simonw/datasette
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Datasette is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/simonw/datasette
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://datasette.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/simonw/datasette
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/simonw/datasette
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/simonw/datasette
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/simonw/datasette

### Davis

- Slug: davis
- URL: https://www.canagentsuse.com/tools/davis
- Website: https://github.com/tchapi/davis
- Docs: https://github.com/tchapi/davis
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Calendar & Contacts
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted calendar & contacts workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/tchapi/davis
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Davis is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/tchapi/davis
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/tchapi/davis
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/tchapi/davis
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/tchapi/davis
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/tchapi/davis
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/tchapi/davis

### diaspora*

- Slug: diaspora
- URL: https://www.canagentsuse.com/tools/diaspora
- Website: https://diasporafoundation.org/
- Docs: https://github.com/diaspora/diaspora
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Communication - Social Networks and Forums
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - social networks and forums workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Ruby. Source code: https://github.com/diaspora/diaspora
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

diaspora* is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/diaspora/diaspora
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://diasporafoundation.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/diaspora/diaspora
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/diaspora/diaspora
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/diaspora/diaspora
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/diaspora/diaspora

### Directus

- Slug: directus
- URL: https://www.canagentsuse.com/tools/directus
- Website: https://directus.io/
- Docs: https://github.com/directus/directus
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Database Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Triage work
- Best for: Self-hosted database management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as BUSL-1.1; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/directus/directus
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Directus is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/directus/directus
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://directus.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/directus/directus
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/directus/directus
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/directus/directus
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/directus/directus

### Discount Bandit

- Slug: discount-bandit
- URL: https://www.canagentsuse.com/tools/discount-bandit
- Website: https://discount-bandit.cybrarist.com/
- Docs: https://github.com/Cybrarist/Discount-Bandit
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Automation, E-commerce
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted automation workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP, Docker. Source code: https://github.com/Cybrarist/Discount-Bandit
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Discount Bandit is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/Cybrarist/Discount-Bandit
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://discount-bandit.cybrarist.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Cybrarist/Discount-Bandit
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Cybrarist/Discount-Bandit
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Cybrarist/Discount-Bandit
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Cybrarist/Discount-Bandit

### Dittofeed

- Slug: dittofeed
- URL: https://www.canagentsuse.com/tools/dittofeed
- Website: https://www.dittofeed.com
- Docs: https://github.com/dittofeed/dittofeed
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Automation, Communication - Email - Mailing Lists and Newsletters
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted automation workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/dittofeed/dittofeed
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Dittofeed is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/dittofeed/dittofeed
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.dittofeed.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/dittofeed/dittofeed
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/dittofeed/dittofeed
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/dittofeed/dittofeed
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/dittofeed/dittofeed

### django-wiki

- Slug: django-wiki
- URL: https://www.canagentsuse.com/tools/django-wiki
- Website: https://github.com/django-wiki/django-wiki
- Docs: https://github.com/django-wiki/django-wiki
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Wikis
- Use cases: Self-host a tool, Inspect open source, Publish content
- Best for: Self-hosted wikis workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python. Source code: https://github.com/django-wiki/django-wiki
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

django-wiki is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/django-wiki/django-wiki
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/django-wiki/django-wiki
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/django-wiki/django-wiki
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/django-wiki/django-wiki
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/django-wiki/django-wiki
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/django-wiki/django-wiki

### docker-mailserver

- Slug: docker-mailserver
- URL: https://www.canagentsuse.com/tools/docker-mailserver
- Website: https://docker-mailserver.github.io/docker-mailserver/edge/
- Docs: https://github.com/docker-mailserver/docker-mailserver
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Communication - Email - Complete Solutions
- Use cases: Self-host a tool, Inspect open source, Triage work
- Best for: Self-hosted communication - email - complete solutions workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/docker-mailserver/docker-mailserver
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

docker-mailserver is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/docker-mailserver/docker-mailserver
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://docker-mailserver.github.io/docker-mailserver/edge/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/docker-mailserver/docker-mailserver
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/docker-mailserver/docker-mailserver
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/docker-mailserver/docker-mailserver
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/docker-mailserver/docker-mailserver

### DockSTARTer

- Slug: dockstarter
- URL: https://www.canagentsuse.com/tools/dockstarter
- Website: https://dockstarter.com/
- Docs: https://github.com/GhostWriters/DockSTARTer
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Self-hosting Solutions
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted self-hosting solutions workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Shell. Source code: https://github.com/GhostWriters/DockSTARTer
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

DockSTARTer is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/GhostWriters/DockSTARTer
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://dockstarter.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/GhostWriters/DockSTARTer
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/GhostWriters/DockSTARTer
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/GhostWriters/DockSTARTer
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/GhostWriters/DockSTARTer

### Dokuwiki

- Slug: dokuwiki
- URL: https://www.canagentsuse.com/tools/dokuwiki
- Website: https://www.dokuwiki.org/DokuWiki
- Docs: https://github.com/dokuwiki/dokuwiki
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Wikis
- Use cases: Self-host a tool, Inspect open source, Publish content, Triage work
- Best for: Self-hosted wikis workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/dokuwiki/dokuwiki
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Dokuwiki is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/dokuwiki/dokuwiki
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.dokuwiki.org/DokuWiki
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/dokuwiki/dokuwiki
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/dokuwiki/dokuwiki
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/dokuwiki/dokuwiki
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/dokuwiki/dokuwiki

### Domoticz

- Slug: domoticz
- URL: https://www.canagentsuse.com/tools/domoticz
- Website: https://www.domoticz.com/
- Docs: https://github.com/domoticz/domoticz
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Internet of Things (IoT)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Analyze product
- Best for: Self-hosted internet of things (iot) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C, C++, Docker, Shell. Source code: https://github.com/domoticz/domoticz
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Domoticz is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/domoticz/domoticz
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.domoticz.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/domoticz/domoticz
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/domoticz/domoticz
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/domoticz/domoticz
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/domoticz/domoticz

### Donetick

- Slug: donetick
- URL: https://www.canagentsuse.com/tools/donetick
- Website: https://donetick.com
- Docs: https://github.com/donetick/donetick
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Task Management & To-do Lists
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted task management & to-do lists workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker. Source code: https://github.com/donetick/donetick
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Donetick is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/donetick/donetick
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://donetick.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/donetick/donetick
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/donetick/donetick
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/donetick/donetick
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/donetick/donetick

### Dovecot

- Slug: dovecot
- URL: https://www.canagentsuse.com/tools/dovecot
- Website: https://www.dovecot.org/
- Docs: https://github.com/dovecot/core
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Communication - Email - Mail Delivery Agents
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - email - mail delivery agents workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT, LGPL-2.1; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C, deb. Source code: https://github.com/dovecot/core
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Dovecot is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/dovecot/core
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.dovecot.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/dovecot/core
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/dovecot/core
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/dovecot/core
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/dovecot/core

### DreamFactory

- Slug: dreamfactory
- URL: https://www.canagentsuse.com/tools/dreamfactory
- Website: https://www.dreamfactory.com/
- Docs: https://github.com/dreamfactorysoftware/dreamfactory
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Software Development - API Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Triage work
- Best for: Self-hosted software development - api management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP, Docker, K8S. Source code: https://github.com/dreamfactorysoftware/dreamfactory
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

DreamFactory is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/dreamfactorysoftware/dreamfactory
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.dreamfactory.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/dreamfactorysoftware/dreamfactory
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/dreamfactorysoftware/dreamfactory
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/dreamfactorysoftware/dreamfactory
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/dreamfactorysoftware/dreamfactory

### EasyWI

- Slug: easywi
- URL: https://www.canagentsuse.com/tools/easywi
- Website: https://easy-wi.com
- Docs: https://github.com/easy-wi/developer/
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Games - Administrative Utilities & Control Panels
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted games - administrative utilities & control panels workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP, Shell. Source code: https://github.com/easy-wi/developer/
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

EasyWI is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/easy-wi/developer/
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://easy-wi.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/easy-wi/developer/
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/easy-wi/developer/
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/easy-wi/developer/
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/easy-wi/developer/

### ejabberd

- Slug: ejabberd
- URL: https://www.canagentsuse.com/tools/ejabberd
- Website: https://www.ejabberd.im/
- Docs: https://github.com/processone/ejabberd
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Communication - XMPP - Servers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - xmpp - servers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Erlang, Docker. Source code: https://github.com/processone/ejabberd
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

ejabberd is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/processone/ejabberd
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.ejabberd.im/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/processone/ejabberd
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/processone/ejabberd
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/processone/ejabberd
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/processone/ejabberd

### eLabFTW

- Slug: elabftw
- URL: https://www.canagentsuse.com/tools/elabftw
- Website: https://www.elabftw.net
- Docs: https://github.com/elabftw/elabftw
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Content Management Systems (CMS)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content, Triage work
- Best for: Self-hosted content management systems (cms) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/elabftw/elabftw
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

eLabFTW is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/elabftw/elabftw
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.elabftw.net
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/elabftw/elabftw
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/elabftw/elabftw
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/elabftw/elabftw
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/elabftw/elabftw

### emailwiz

- Slug: emailwiz
- URL: https://www.canagentsuse.com/tools/emailwiz
- Website: https://github.com/LukeSmithxyz/emailwiz
- Docs: https://github.com/LukeSmithxyz/emailwiz
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Communication - Email - Complete Solutions
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - email - complete solutions workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Shell. Source code: https://github.com/LukeSmithxyz/emailwiz
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

emailwiz is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/LukeSmithxyz/emailwiz
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/LukeSmithxyz/emailwiz
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/LukeSmithxyz/emailwiz
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/LukeSmithxyz/emailwiz
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/LukeSmithxyz/emailwiz
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/LukeSmithxyz/emailwiz

### Ergo

- Slug: ergo
- URL: https://www.canagentsuse.com/tools/ergo
- Website: https://ergo.chat/
- Docs: https://github.com/ergochat/ergo
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Communication - IRC
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - irc workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker. Source code: https://github.com/ergochat/ergo
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Ergo is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/ergochat/ergo
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://ergo.chat/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/ergochat/ergo
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/ergochat/ergo
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/ergochat/ergo
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/ergochat/ergo

### Espial

- Slug: espial
- URL: https://www.canagentsuse.com/tools/espial
- Website: https://github.com/jonschoning/espial
- Docs: https://github.com/jonschoning/espial
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Bookmarks and Link Sharing
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted bookmarks and link sharing workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Haskell. Source code: https://github.com/jonschoning/espial
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Espial is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/jonschoning/espial
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/jonschoning/espial
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/jonschoning/espial
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/jonschoning/espial
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/jonschoning/espial
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/jonschoning/espial

### EspoCRM

- Slug: espocrm
- URL: https://www.canagentsuse.com/tools/espocrm
- Website: https://www.espocrm.com/
- Docs: https://github.com/espocrm/espocrm
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Customer Relationship Management (CRM)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted customer relationship management (crm) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/espocrm/espocrm
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

EspoCRM is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/espocrm/espocrm
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.espocrm.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/espocrm/espocrm
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/espocrm/espocrm
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/espocrm/espocrm
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/espocrm/espocrm

### Evidence

- Slug: evidence
- URL: https://www.canagentsuse.com/tools/evidence
- Website: https://evidence.dev
- Docs: https://github.com/evidence-dev/evidence
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Database Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Triage work
- Best for: Self-hosted database management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs. Source code: https://github.com/evidence-dev/evidence
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Evidence is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/evidence-dev/evidence
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://evidence.dev
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/evidence-dev/evidence
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/evidence-dev/evidence
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/evidence-dev/evidence
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/evidence-dev/evidence

### Expressa

- Slug: expressa
- URL: https://www.canagentsuse.com/tools/expressa
- Website: https://github.com/thomas4019/expressa
- Docs: https://github.com/thomas4019/expressa
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Content Management Systems (CMS)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content, Triage work
- Best for: Self-hosted content management systems (cms) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs. Source code: https://github.com/thomas4019/expressa
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Expressa is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/thomas4019/expressa
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/thomas4019/expressa
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/thomas4019/expressa
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/thomas4019/expressa
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/thomas4019/expressa
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/thomas4019/expressa

### F-Droid

- Slug: f-droid
- URL: https://www.canagentsuse.com/tools/f-droid
- Website: https://f-droid.org
- Docs: https://gitlab.com/fdroid/fdroidserver
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Miscellaneous
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted miscellaneous workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python, Docker, deb. Source code: https://gitlab.com/fdroid/fdroidserver
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

F-Droid is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://gitlab.com/fdroid/fdroidserver
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://f-droid.org
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://gitlab.com/fdroid/fdroidserver
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://gitlab.com/fdroid/fdroidserver
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://gitlab.com/fdroid/fdroidserver
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://gitlab.com/fdroid/fdroidserver

### FeedCord

- Slug: feedcord
- URL: https://www.canagentsuse.com/tools/feedcord
- Website: https://github.com/Qolors/FeedCord
- Docs: https://github.com/Qolors/FeedCord
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Feed Readers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted feed readers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/Qolors/FeedCord
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

FeedCord is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/Qolors/FeedCord
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/Qolors/FeedCord
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Qolors/FeedCord
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Qolors/FeedCord
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Qolors/FeedCord
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Qolors/FeedCord

### feedmixer

- Slug: feedmixer
- URL: https://www.canagentsuse.com/tools/feedmixer
- Website: https://github.com/cristoper/feedmixer
- Docs: https://github.com/cristoper/feedmixer
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Automation
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted automation workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as WTFPL; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python. Source code: https://github.com/cristoper/feedmixer
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

feedmixer is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/cristoper/feedmixer
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/cristoper/feedmixer
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/cristoper/feedmixer
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/cristoper/feedmixer
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/cristoper/feedmixer
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/cristoper/feedmixer

### Ferron

- Slug: ferron
- URL: https://www.canagentsuse.com/tools/ferron
- Website: https://ferron.sh/
- Docs: https://github.com/ferronweb/ferron
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Web Servers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted web servers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Rust, Docker, deb. Source code: https://github.com/ferronweb/ferron
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Ferron is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/ferronweb/ferron
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://ferron.sh/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/ferronweb/ferron
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/ferronweb/ferron
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/ferronweb/ferron
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/ferronweb/ferron

### Fess

- Slug: fess
- URL: https://www.canagentsuse.com/tools/fess
- Website: https://fess.codelibs.org/
- Docs: https://github.com/codelibs/fess
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Search Engines
- Use cases: Self-host a tool, Inspect open source, Triage work
- Best for: Self-hosted search engines workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Java, Docker. Source code: https://github.com/codelibs/fess
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Fess is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/codelibs/fess
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://fess.codelibs.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/codelibs/fess
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/codelibs/fess
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/codelibs/fess
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/codelibs/fess

### Firefox Account Server

- Slug: firefox-account-server
- URL: https://www.canagentsuse.com/tools/firefox-account-server
- Website: https://mozilla-services.readthedocs.io/en/latest/howtos/run-fxa.html
- Docs: https://github.com/mozilla/fxa
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Bookmarks and Link Sharing
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted bookmarks and link sharing workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Java. Source code: https://github.com/mozilla/fxa
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Firefox Account Server is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/mozilla/fxa
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://mozilla-services.readthedocs.io/en/latest/howtos/run-fxa.html
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/mozilla/fxa
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/mozilla/fxa
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/mozilla/fxa
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/mozilla/fxa

### Flagsmith

- Slug: flagsmith
- URL: https://www.canagentsuse.com/tools/flagsmith
- Website: https://flagsmith.com
- Docs: https://github.com/flagsmith/flagsmith
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Software Development - Feature Toggle
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted software development - feature toggle workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as BSD-3-Clause; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, K8S. Source code: https://github.com/flagsmith/flagsmith
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Flagsmith is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/flagsmith/flagsmith
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://flagsmith.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/flagsmith/flagsmith
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/flagsmith/flagsmith
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/flagsmith/flagsmith
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/flagsmith/flagsmith

### flatnotes

- Slug: flatnotes
- URL: https://www.canagentsuse.com/tools/flatnotes
- Website: https://github.com/dullage/flatnotes
- Docs: https://github.com/dullage/flatnotes
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Note-taking & Editors
- Use cases: Self-host a tool, Inspect open source, Triage work
- Best for: Self-hosted note-taking & editors workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/dullage/flatnotes
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

flatnotes is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/dullage/flatnotes
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/dullage/flatnotes
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/dullage/flatnotes
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/dullage/flatnotes
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/dullage/flatnotes
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/dullage/flatnotes

### flowctl

- Slug: flowctl
- URL: https://www.canagentsuse.com/tools/flowctl
- Website: https://flowctl.net
- Docs: https://github.com/cvhariharan/flowctl
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Automation
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted automation workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker. Source code: https://github.com/cvhariharan/flowctl
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

flowctl is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/cvhariharan/flowctl
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://flowctl.net
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/cvhariharan/flowctl
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/cvhariharan/flowctl
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/cvhariharan/flowctl
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/cvhariharan/flowctl

### FOSSBilling

- Slug: fossbilling
- URL: https://www.canagentsuse.com/tools/fossbilling
- Website: https://fossbilling.org/
- Docs: https://github.com/FOSSBilling/FOSSBilling
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Money, Budgeting & Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted money, budgeting & management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP, Docker. Source code: https://github.com/FOSSBilling/FOSSBilling
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

FOSSBilling is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/FOSSBilling/FOSSBilling
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://fossbilling.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/FOSSBilling/FOSSBilling
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/FOSSBilling/FOSSBilling
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/FOSSBilling/FOSSBilling
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/FOSSBilling/FOSSBilling

### Frappe Helpdesk

- Slug: frappe-helpdesk
- URL: https://www.canagentsuse.com/tools/frappe-helpdesk
- Website: https://frappe.io/helpdesk
- Docs: https://github.com/frappe/helpdesk
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Ticketing
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted ticketing workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/frappe/helpdesk
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Frappe Helpdesk is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/frappe/helpdesk
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://frappe.io/helpdesk
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/frappe/helpdesk
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/frappe/helpdesk
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/frappe/helpdesk
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/frappe/helpdesk

### Fredy

- Slug: fredy
- URL: https://www.canagentsuse.com/tools/fredy
- Website: https://fredy.orange-coding.net/
- Docs: https://github.com/orangecoding/fredy
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Automation
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Triage work
- Best for: Self-hosted automation workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/orangecoding/fredy
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Fredy is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/orangecoding/fredy
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://fredy.orange-coding.net/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/orangecoding/fredy
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/orangecoding/fredy
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/orangecoding/fredy
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/orangecoding/fredy

### Friendica

- Slug: friendica
- URL: https://www.canagentsuse.com/tools/friendica
- Website: https://friendi.ca/
- Docs: https://github.com/friendica/friendica
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Communication - Social Networks and Forums
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - social networks and forums workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/friendica/friendica
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Friendica is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/friendica/friendica
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://friendi.ca/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/friendica/friendica
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/friendica/friendica
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/friendica/friendica
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/friendica/friendica

### Fusio

- Slug: fusio
- URL: https://www.canagentsuse.com/tools/fusio
- Website: https://www.fusio-project.org/
- Docs: https://github.com/apioo/fusio
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Software Development - API Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted software development - api management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP, Docker. Source code: https://github.com/apioo/fusio
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Fusio is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/apioo/fusio
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.fusio-project.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/apioo/fusio
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/apioo/fusio
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/apioo/fusio
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/apioo/fusio

### Galene

- Slug: galene
- URL: https://www.canagentsuse.com/tools/galene
- Website: https://galene.org/
- Docs: https://github.com/jech/galene
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Communication - Video Conferencing
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - video conferencing workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go. Source code: https://github.com/jech/galene
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Galene is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/jech/galene
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://galene.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/jech/galene
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/jech/galene
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/jech/galene
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/jech/galene

### GameVault

- Slug: gamevault
- URL: https://www.canagentsuse.com/tools/gamevault
- Website: https://gamevau.lt
- Docs: https://github.com/Phalcode/gamevault-backend
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Games - Administrative Utilities & Control Panels
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Triage work
- Best for: Self-hosted games - administrative utilities & control panels workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as CC-BY-NC-SA-4.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/Phalcode/gamevault-backend
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

GameVault is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/Phalcode/gamevault-backend
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://gamevau.lt
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Phalcode/gamevault-backend
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Phalcode/gamevault-backend
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Phalcode/gamevault-backend
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Phalcode/gamevault-backend

### Gaseous Server

- Slug: gaseous-server
- URL: https://www.canagentsuse.com/tools/gaseous-server
- Website: https://github.com/gaseous-project/gaseous-server
- Docs: https://github.com/gaseous-project/gaseous-server
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Games - Administrative Utilities & Control Panels
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Triage work
- Best for: Self-hosted games - administrative utilities & control panels workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, .NET. Source code: https://github.com/gaseous-project/gaseous-server
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Gaseous Server is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/gaseous-project/gaseous-server
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/gaseous-project/gaseous-server
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/gaseous-project/gaseous-server
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/gaseous-project/gaseous-server
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/gaseous-project/gaseous-server
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/gaseous-project/gaseous-server

### Gerbera

- Slug: gerbera
- URL: https://www.canagentsuse.com/tools/gerbera
- Website: https://gerbera.io/
- Docs: https://github.com/gerbera/gerbera
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Media Streaming - Multimedia Streaming
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted media streaming - multimedia streaming workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, deb, C++. Source code: https://github.com/gerbera/gerbera
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Gerbera is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/gerbera/gerbera
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://gerbera.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/gerbera/gerbera
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/gerbera/gerbera
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/gerbera/gerbera
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/gerbera/gerbera

### gitbucket

- Slug: gitbucket
- URL: https://www.canagentsuse.com/tools/gitbucket
- Website: https://gitbucket.github.io/
- Docs: https://github.com/gitbucket/gitbucket
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Software Development - Project Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted software development - project management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Scala, Java. Source code: https://github.com/gitbucket/gitbucket
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

gitbucket is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/gitbucket/gitbucket
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://gitbucket.github.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/gitbucket/gitbucket
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/gitbucket/gitbucket
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/gitbucket/gitbucket
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/gitbucket/gitbucket

### go-doxy

- Slug: go-doxy
- URL: https://www.canagentsuse.com/tools/go-doxy
- Website: https://github.com/yusing/godoxy
- Docs: https://github.com/yusing/godoxy
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Web Servers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted web servers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Go. Source code: https://github.com/yusing/godoxy
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

go-doxy is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/yusing/godoxy
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/yusing/godoxy
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/yusing/godoxy
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/yusing/godoxy
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/yusing/godoxy
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/yusing/godoxy

### gocron

- Slug: gocron
- URL: https://www.canagentsuse.com/tools/gocron
- Website: https://github.com/flohoss/gocron
- Docs: https://github.com/flohoss/gocron
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Automation
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted automation workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/flohoss/gocron
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

gocron is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/flohoss/gocron
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/flohoss/gocron
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/flohoss/gocron
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/flohoss/gocron
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/flohoss/gocron
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/flohoss/gocron

### Gollum

- Slug: gollum
- URL: https://www.canagentsuse.com/tools/gollum
- Website: https://github.com/gollum/gollum
- Docs: https://github.com/gollum/gollum
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Wikis
- Use cases: Self-host a tool, Inspect open source, Publish content
- Best for: Self-hosted wikis workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Ruby. Source code: https://github.com/gollum/gollum
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Gollum is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/gollum/gollum
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/gollum/gollum
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/gollum/gollum
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/gollum/gollum
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/gollum/gollum
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/gollum/gollum

### gonic

- Slug: gonic
- URL: https://www.canagentsuse.com/tools/gonic
- Website: https://github.com/sentriz/gonic
- Docs: https://github.com/sentriz/gonic
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Media Streaming - Audio Streaming
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted media streaming - audio streaming workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker. Source code: https://github.com/sentriz/gonic
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

gonic is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/sentriz/gonic
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/sentriz/gonic
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/sentriz/gonic
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/sentriz/gonic
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/sentriz/gonic
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/sentriz/gonic

### Gossa

- Slug: gossa
- URL: https://www.canagentsuse.com/tools/gossa
- Website: https://github.com/pldubouilh/gossa
- Docs: https://github.com/pldubouilh/gossa
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, File Transfer - Web-based File Managers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted file transfer - web-based file managers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go. Source code: https://github.com/pldubouilh/gossa
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Gossa is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/pldubouilh/gossa
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/pldubouilh/gossa
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/pldubouilh/gossa
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/pldubouilh/gossa
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/pldubouilh/gossa
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/pldubouilh/gossa

### Gotenberg

- Slug: gotenberg
- URL: https://www.canagentsuse.com/tools/gotenberg
- Website: https://gotenberg.dev
- Docs: https://github.com/gotenberg/gotenberg
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Document Management, Automation
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted document management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/gotenberg/gotenberg
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Gotenberg is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/gotenberg/gotenberg
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://gotenberg.dev
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/gotenberg/gotenberg
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/gotenberg/gotenberg
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/gotenberg/gotenberg
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/gotenberg/gotenberg

### GraphHopper

- Slug: graphhopper
- URL: https://www.canagentsuse.com/tools/graphhopper
- Website: https://graphhopper.com/
- Docs: https://github.com/graphhopper/graphhopper
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Maps and Global Positioning System (GPS)
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted maps and global positioning system (gps) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Java. Source code: https://github.com/graphhopper/graphhopper
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

GraphHopper is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/graphhopper/graphhopper
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://graphhopper.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/graphhopper/graphhopper
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/graphhopper/graphhopper
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/graphhopper/graphhopper
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/graphhopper/graphhopper

### Graphweaver

- Slug: graphweaver
- URL: https://www.canagentsuse.com/tools/graphweaver
- Website: https://graphweaver.com/
- Docs: https://github.com/exogee-technology/graphweaver
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Software Development - API Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Triage work
- Best for: Self-hosted software development - api management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs. Source code: https://github.com/exogee-technology/graphweaver
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Graphweaver is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/exogee-technology/graphweaver
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://graphweaver.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/exogee-technology/graphweaver
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/exogee-technology/graphweaver
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/exogee-technology/graphweaver
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/exogee-technology/graphweaver

### Grimoire

- Slug: grimoire
- URL: https://www.canagentsuse.com/tools/grimoire
- Website: https://grimoire.pro
- Docs: https://github.com/goniszewski/grimoire
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Bookmarks and Link Sharing
- Use cases: Self-host a tool, Inspect open source, Publish content, Triage work
- Best for: Self-hosted bookmarks and link sharing workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/goniszewski/grimoire
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Grimoire is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/goniszewski/grimoire
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://grimoire.pro
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/goniszewski/grimoire
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/goniszewski/grimoire
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/goniszewski/grimoire
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/goniszewski/grimoire

### HandBrake Web

- Slug: handbrake-web
- URL: https://www.canagentsuse.com/tools/handbrake-web
- Website: https://github.com/TheNickOfTime/handbrake-web
- Docs: https://github.com/TheNickOfTime/handbrake-web
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Automation
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted automation workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/TheNickOfTime/handbrake-web
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

HandBrake Web is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/TheNickOfTime/handbrake-web
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/TheNickOfTime/handbrake-web
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/TheNickOfTime/handbrake-web
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/TheNickOfTime/handbrake-web
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/TheNickOfTime/handbrake-web
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/TheNickOfTime/handbrake-web

### Haraka

- Slug: haraka
- URL: https://www.canagentsuse.com/tools/haraka
- Website: https://haraka.github.io/
- Docs: https://github.com/haraka/Haraka
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Communication - Email - Mail Transfer Agents
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - email - mail transfer agents workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs. Source code: https://github.com/haraka/Haraka
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Haraka is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/haraka/Haraka
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://haraka.github.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/haraka/Haraka
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/haraka/Haraka
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/haraka/Haraka
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/haraka/Haraka

### Harbor

- Slug: harbor
- URL: https://www.canagentsuse.com/tools/harbor
- Website: https://goharbor.io/
- Docs: https://github.com/goharbor/harbor
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, File Transfer - Object Storage & File Servers
- Use cases: Self-host a tool, Inspect open source, Publish content
- Best for: Self-hosted file transfer - object storage & file servers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, K8S. Source code: https://github.com/goharbor/harbor
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Harbor is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/goharbor/harbor
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://goharbor.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/goharbor/harbor
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/goharbor/harbor
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/goharbor/harbor
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/goharbor/harbor

### Hasura

- Slug: hasura
- URL: https://www.canagentsuse.com/tools/hasura
- Website: https://hasura.io
- Docs: https://github.com/hasura/graphql-engine
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Software Development - API Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Triage work
- Best for: Self-hosted software development - api management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Haskell, Docker, K8S. Source code: https://github.com/hasura/graphql-engine
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Hasura is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 9.4/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/hasura/graphql-engine
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://hasura.io
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/hasura/graphql-engine
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/hasura/graphql-engine
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/hasura/graphql-engine
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/hasura/graphql-engine

### Healthchecks

- Slug: healthchecks
- URL: https://www.canagentsuse.com/tools/healthchecks
- Website: https://healthchecks.io/
- Docs: https://github.com/healthchecks/healthchecks
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Automation
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted automation workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as BSD-3-Clause; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python, Docker. Source code: https://github.com/healthchecks/healthchecks
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Healthchecks is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/healthchecks/healthchecks
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://healthchecks.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/healthchecks/healthchecks
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/healthchecks/healthchecks
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/healthchecks/healthchecks
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/healthchecks/healthchecks

### Heimdall

- Slug: heimdall
- URL: https://www.canagentsuse.com/tools/heimdall
- Website: https://heimdall.site/
- Docs: https://github.com/linuxserver/Heimdall
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Personal Dashboards
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted personal dashboards workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/linuxserver/Heimdall
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Heimdall is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/linuxserver/Heimdall
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://heimdall.site/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/linuxserver/Heimdall
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/linuxserver/Heimdall
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/linuxserver/Heimdall
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/linuxserver/Heimdall

### Homarr

- Slug: homarr
- URL: https://www.canagentsuse.com/tools/homarr
- Website: https://homarr.dev
- Docs: https://github.com/homarr-labs/homarr
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Personal Dashboards
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted personal dashboards workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Nodejs. Source code: https://github.com/homarr-labs/homarr
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Homarr is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/homarr-labs/homarr
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://homarr.dev
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/homarr-labs/homarr
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/homarr-labs/homarr
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/homarr-labs/homarr
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/homarr-labs/homarr

### Home Assistant

- Slug: home-assistant
- URL: https://www.canagentsuse.com/tools/home-assistant
- Website: https://home-assistant.io/
- Docs: https://github.com/home-assistant/core
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Internet of Things (IoT)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted internet of things (iot) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python, Docker. Source code: https://github.com/home-assistant/core
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Home Assistant is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/home-assistant/core
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://home-assistant.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/home-assistant/core
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/home-assistant/core
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/home-assistant/core
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/home-assistant/core

### Homepage by gethomepage

- Slug: homepage-by-gethomepage
- URL: https://www.canagentsuse.com/tools/homepage-by-gethomepage
- Website: https://github.com/gethomepage/homepage
- Docs: https://github.com/gethomepage/homepage
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Personal Dashboards
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted personal dashboards workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Nodejs. Source code: https://github.com/gethomepage/homepage
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Homepage by gethomepage is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/gethomepage/homepage
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/gethomepage/homepage
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/gethomepage/homepage
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/gethomepage/homepage
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/gethomepage/homepage
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/gethomepage/homepage

### Homepage by tomershvueli

- Slug: homepage-by-tomershvueli
- URL: https://www.canagentsuse.com/tools/homepage-by-tomershvueli
- Website: https://github.com/tomershvueli/homepage
- Docs: https://github.com/tomershvueli/homepage
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Personal Dashboards
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted personal dashboards workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/tomershvueli/homepage
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Homepage by tomershvueli is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/tomershvueli/homepage
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/tomershvueli/homepage
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/tomershvueli/homepage
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/tomershvueli/homepage
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/tomershvueli/homepage
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/tomershvueli/homepage

### Homer

- Slug: homer
- URL: https://www.canagentsuse.com/tools/homer
- Website: https://github.com/bastienwirtz/homer
- Docs: https://github.com/bastienwirtz/homer
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Personal Dashboards
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted personal dashboards workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, K8S, Nodejs. Source code: https://github.com/bastienwirtz/homer
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Homer is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/bastienwirtz/homer
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/bastienwirtz/homer
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/bastienwirtz/homer
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/bastienwirtz/homer
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/bastienwirtz/homer
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/bastienwirtz/homer

### Hoppscotch Community Edition

- Slug: hoppscotch-community-edition
- URL: https://www.canagentsuse.com/tools/hoppscotch-community-edition
- Website: https://hoppscotch.io
- Docs: https://github.com/hoppscotch/hoppscotch
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Software Development - API Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted software development - api management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/hoppscotch/hoppscotch
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Hoppscotch Community Edition is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/hoppscotch/hoppscotch
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://hoppscotch.io
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/hoppscotch/hoppscotch
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/hoppscotch/hoppscotch
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/hoppscotch/hoppscotch
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/hoppscotch/hoppscotch

### HTMLy

- Slug: htmly
- URL: https://www.canagentsuse.com/tools/htmly
- Website: https://www.htmly.com/
- Docs: https://github.com/danpros/htmly
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Blogging Platforms, Content Management Systems (CMS)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Analyze product, Publish content, Triage work
- Best for: Self-hosted blogging platforms workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/danpros/htmly
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

HTMLy is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/danpros/htmly
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.htmly.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/danpros/htmly
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/danpros/htmly
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/danpros/htmly
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/danpros/htmly

### Huginn

- Slug: huginn
- URL: https://www.canagentsuse.com/tools/huginn
- Website: https://github.com/huginn/huginn
- Docs: https://github.com/huginn/huginn
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Automation
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Analyze product
- Best for: Self-hosted automation workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Ruby. Source code: https://github.com/huginn/huginn
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Huginn is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/huginn/huginn
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/huginn/huginn
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/huginn/huginn
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/huginn/huginn
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/huginn/huginn
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/huginn/huginn

### HyperSwitch

- Slug: hyperswitch
- URL: https://www.canagentsuse.com/tools/hyperswitch
- Website: https://hyperswitch.io/
- Docs: https://github.com/juspay/hyperswitch
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Money, Budgeting & Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted money, budgeting & management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Rust. Source code: https://github.com/juspay/hyperswitch
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

HyperSwitch is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/juspay/hyperswitch
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://hyperswitch.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/juspay/hyperswitch
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/juspay/hyperswitch
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/juspay/hyperswitch
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/juspay/hyperswitch

### imgproxy

- Slug: imgproxy
- URL: https://www.canagentsuse.com/tools/imgproxy
- Website: https://imgproxy.net/
- Docs: https://github.com/imgproxy/imgproxy
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Proxy
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted proxy workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker, K8S. Source code: https://github.com/imgproxy/imgproxy
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

imgproxy is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/imgproxy/imgproxy
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://imgproxy.net/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/imgproxy/imgproxy
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/imgproxy/imgproxy
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/imgproxy/imgproxy
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/imgproxy/imgproxy

### InspIRCd

- Slug: inspircd
- URL: https://www.canagentsuse.com/tools/inspircd
- Website: https://www.inspircd.org/
- Docs: https://github.com/inspircd/inspircd
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Communication - IRC
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - irc workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C++, Docker. Source code: https://github.com/inspircd/inspircd
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

InspIRCd is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/inspircd/inspircd
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.inspircd.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/inspircd/inspircd
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/inspircd/inspircd
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/inspircd/inspircd
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/inspircd/inspircd

### ioBroker

- Slug: iobroker
- URL: https://www.canagentsuse.com/tools/iobroker
- Website: https://www.iobroker.net/
- Docs: https://github.com/ioBroker/ioBroker
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Internet of Things (IoT)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Analyze product, Triage work
- Best for: Self-hosted internet of things (iot) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs. Source code: https://github.com/ioBroker/ioBroker
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

ioBroker is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/ioBroker/ioBroker
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.iobroker.net/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/ioBroker/ioBroker
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/ioBroker/ioBroker
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/ioBroker/ioBroker
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/ioBroker/ioBroker

### iRedMail

- Slug: iredmail
- URL: https://www.canagentsuse.com/tools/iredmail
- Website: https://www.iredmail.org/
- Docs: https://github.com/iredmail/iRedMail
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Communication - Email - Complete Solutions
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - email - complete solutions workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Shell. Source code: https://github.com/iredmail/iRedMail
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

iRedMail is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/iredmail/iRedMail
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.iredmail.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/iredmail/iRedMail
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/iredmail/iRedMail
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/iredmail/iRedMail
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/iredmail/iRedMail

### Isso

- Slug: isso
- URL: https://www.canagentsuse.com/tools/isso
- Website: https://isso-comments.de/
- Docs: https://github.com/isso-comments/isso
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Communication - Social Networks and Forums
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - social networks and forums workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python, Docker. Source code: https://github.com/isso-comments/isso
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Isso is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/isso-comments/isso
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://isso-comments.de/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/isso-comments/isso
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/isso-comments/isso
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/isso-comments/isso
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/isso-comments/isso

### Janus

- Slug: janus
- URL: https://www.canagentsuse.com/tools/janus
- Website: https://janus.conf.meetecho.com/
- Docs: https://github.com/meetecho/janus-gateway
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Communication - Video Conferencing
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - video conferencing workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C. Source code: https://github.com/meetecho/janus-gateway
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Janus is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/meetecho/janus-gateway
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://janus.conf.meetecho.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/meetecho/janus-gateway
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/meetecho/janus-gateway
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/meetecho/janus-gateway
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/meetecho/janus-gateway

### Judge0 CE

- Slug: judge0-ce
- URL: https://www.canagentsuse.com/tools/judge0-ce
- Website: https://judge0.com
- Docs: https://github.com/judge0/judge0
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Software Development - IDE & Tools
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted software development - ide & tools workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/judge0/judge0
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Judge0 CE is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/judge0/judge0
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://judge0.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/judge0/judge0
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/judge0/judge0
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/judge0/judge0
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/judge0/judge0

### Kamailio

- Slug: kamailio
- URL: https://www.canagentsuse.com/tools/kamailio
- Website: https://www.kamailio.org/w/
- Docs: https://github.com/kamailio/kamailio
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Communication - SIP
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - sip workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C, deb. Source code: https://github.com/kamailio/kamailio
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Kamailio is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/kamailio/kamailio
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.kamailio.org/w/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/kamailio/kamailio
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/kamailio/kamailio
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/kamailio/kamailio
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/kamailio/kamailio

### Kavita

- Slug: kavita
- URL: https://www.canagentsuse.com/tools/kavita
- Website: https://www.kavitareader.com/
- Docs: https://github.com/Kareadita/Kavita
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Document Management - E-books
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content, Triage work
- Best for: Self-hosted document management - e-books workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: .NET, Docker. Source code: https://github.com/Kareadita/Kavita
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Kavita is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/Kareadita/Kavita
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.kavitareader.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Kareadita/Kavita
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Kareadita/Kavita
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Kareadita/Kavita
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Kareadita/Kavita

### Kestra

- Slug: kestra
- URL: https://www.canagentsuse.com/tools/kestra
- Website: https://kestra.io
- Docs: https://github.com/kestra-io/kestra
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Automation
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Analyze product, Triage work
- Best for: Self-hosted automation workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/kestra-io/kestra
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Kestra is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/kestra-io/kestra
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://kestra.io
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/kestra-io/kestra
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/kestra-io/kestra
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/kestra-io/kestra
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/kestra-io/kestra

### Keygen

- Slug: keygen
- URL: https://www.canagentsuse.com/tools/keygen
- Website: https://keygen.sh/
- Docs: https://github.com/keygen-sh/keygen-api
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Miscellaneous
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted miscellaneous workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as ⊘ Proprietary; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Ruby. Source code: https://github.com/keygen-sh/keygen-api
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Keygen is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/keygen-sh/keygen-api
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://keygen.sh/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/keygen-sh/keygen-api
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/keygen-sh/keygen-api
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/keygen-sh/keygen-api
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/keygen-sh/keygen-api

### Khoj

- Slug: khoj
- URL: https://www.canagentsuse.com/tools/khoj
- Website: https://khoj.dev/
- Docs: https://github.com/khoj-ai/khoj
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Generative Artificial Intelligence (GenAI)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Triage work
- Best for: Self-hosted generative artificial intelligence (genai) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python, Docker. Source code: https://github.com/khoj-ai/khoj
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Khoj is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/khoj-ai/khoj
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://khoj.dev/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/khoj-ai/khoj
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/khoj-ai/khoj
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/khoj-ai/khoj
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/khoj-ai/khoj

### Kibitzr

- Slug: kibitzr
- URL: https://www.canagentsuse.com/tools/kibitzr
- Website: https://kibitzr.github.io
- Docs: https://github.com/kibitzr/kibitzr
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Automation
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted automation workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python. Source code: https://github.com/kibitzr/kibitzr
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Kibitzr is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/kibitzr/kibitzr
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://kibitzr.github.io
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/kibitzr/kibitzr
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/kibitzr/kibitzr
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/kibitzr/kibitzr
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/kibitzr/kibitzr

### koel

- Slug: koel
- URL: https://www.canagentsuse.com/tools/koel
- Website: https://koel.dev/
- Docs: https://github.com/koel/koel
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Media Streaming - Audio Streaming
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted media streaming - audio streaming workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/koel/koel
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

koel is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/koel/koel
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://koel.dev/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/koel/koel
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/koel/koel
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/koel/koel
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/koel/koel

### Komga

- Slug: komga
- URL: https://www.canagentsuse.com/tools/komga
- Website: https://komga.org
- Docs: https://github.com/gotson/komga
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Document Management - E-books
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted document management - e-books workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Java, Docker. Source code: https://github.com/gotson/komga
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Komga is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/gotson/komga
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://komga.org
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/gotson/komga
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/gotson/komga
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/gotson/komga
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/gotson/komga

### Kong

- Slug: kong
- URL: https://www.canagentsuse.com/tools/kong
- Website: https://konghq.com/kong/
- Docs: https://github.com/Kong/kong
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Software Development - API Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted software development - api management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Lua, Docker, K8S, deb. Source code: https://github.com/Kong/kong
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Kong is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/Kong/kong
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://konghq.com/kong/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Kong/kong
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Kong/kong
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Kong/kong
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Kong/kong

### Kottster

- Slug: kottster
- URL: https://www.canagentsuse.com/tools/kottster
- Website: https://kottster.app/
- Docs: https://github.com/kottster/kottster
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Database Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Triage work
- Best for: Self-hosted database management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/kottster/kottster
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Kottster is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/kottster/kottster
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://kottster.app/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/kottster/kottster
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/kottster/kottster
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/kottster/kottster
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/kottster/kottster

### LazyLibrarian

- Slug: lazylibrarian
- URL: https://www.canagentsuse.com/tools/lazylibrarian
- Website: https://gitlab.com/LazyLibrarian/LazyLibrarian
- Docs: https://gitlab.com/LazyLibrarian/LazyLibrarian
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Automation
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Triage work
- Best for: Self-hosted automation workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python. Source code: https://gitlab.com/LazyLibrarian/LazyLibrarian
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

LazyLibrarian is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://gitlab.com/LazyLibrarian/LazyLibrarian
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://gitlab.com/LazyLibrarian/LazyLibrarian
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://gitlab.com/LazyLibrarian/LazyLibrarian
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://gitlab.com/LazyLibrarian/LazyLibrarian
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://gitlab.com/LazyLibrarian/LazyLibrarian
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://gitlab.com/LazyLibrarian/LazyLibrarian

### Leon

- Slug: leon
- URL: https://www.canagentsuse.com/tools/leon
- Website: https://getleon.ai
- Docs: https://github.com/leon-ai/leon
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Automation
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted automation workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs. Source code: https://github.com/leon-ai/leon
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Leon is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/leon-ai/leon
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://getleon.ai
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/leon-ai/leon
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/leon-ai/leon
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/leon-ai/leon
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/leon-ai/leon

### Libre Translate

- Slug: libre-translate
- URL: https://www.canagentsuse.com/tools/libre-translate
- Website: https://libretranslate.com/
- Docs: https://github.com/LibreTranslate/LibreTranslate
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Miscellaneous
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted miscellaneous workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Python. Source code: https://github.com/LibreTranslate/LibreTranslate
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Libre Translate is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/LibreTranslate/LibreTranslate
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://libretranslate.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/LibreTranslate/LibreTranslate
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/LibreTranslate/LibreTranslate
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/LibreTranslate/LibreTranslate
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/LibreTranslate/LibreTranslate

### LinkAce

- Slug: linkace
- URL: https://www.canagentsuse.com/tools/linkace
- Website: https://www.linkace.org/
- Docs: https://github.com/Kovah/LinkAce/
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Bookmarks and Link Sharing
- Use cases: Self-host a tool, Inspect open source, Analyze product, Triage work
- Best for: Self-hosted bookmarks and link sharing workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, PHP. Source code: https://github.com/Kovah/LinkAce/
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

LinkAce is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/Kovah/LinkAce/
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.linkace.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Kovah/LinkAce/
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Kovah/LinkAce/
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Kovah/LinkAce/
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Kovah/LinkAce/

### Lowdefy

- Slug: lowdefy
- URL: https://www.canagentsuse.com/tools/lowdefy
- Website: https://www.lowdefy.com/
- Docs: https://github.com/lowdefy/lowdefy
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Software Development - IDE & Tools
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Triage work
- Best for: Self-hosted software development - ide & tools workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/lowdefy/lowdefy
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Lowdefy is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/lowdefy/lowdefy
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.lowdefy.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/lowdefy/lowdefy
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/lowdefy/lowdefy
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/lowdefy/lowdefy
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/lowdefy/lowdefy

### Luanti

- Slug: luanti
- URL: https://www.canagentsuse.com/tools/luanti
- Website: https://www.luanti.org/
- Docs: https://github.com/luanti-org/luanti
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Games
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted games workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as LGPL-2.1, MIT, Zlib; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C++, Lua, deb. Source code: https://github.com/luanti-org/luanti
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Luanti is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/luanti-org/luanti
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.luanti.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/luanti-org/luanti
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/luanti-org/luanti
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/luanti-org/luanti
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/luanti-org/luanti

### Lura

- Slug: lura
- URL: https://www.canagentsuse.com/tools/lura
- Website: https://luraproject.org/
- Docs: https://github.com/luraproject/lura
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Software Development - API Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted software development - api management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go. Source code: https://github.com/luraproject/lura
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Lura is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/luraproject/lura
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://luraproject.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/luraproject/lura
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/luraproject/lura
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/luraproject/lura
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/luraproject/lura

### Lyrion Music Server

- Slug: lyrion-music-server
- URL: https://www.canagentsuse.com/tools/lyrion-music-server
- Website: https://lyrion.org/
- Docs: https://github.com/lms-community/slimserver
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Media Streaming - Audio Streaming
- Use cases: Self-host a tool, Inspect open source, Analyze product
- Best for: Self-hosted media streaming - audio streaming workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: deb, Docker, Perl. Source code: https://github.com/lms-community/slimserver
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Lyrion Music Server is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/lms-community/slimserver
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://lyrion.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/lms-community/slimserver
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/lms-community/slimserver
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/lms-community/slimserver
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/lms-community/slimserver

### Maddy Mail Server

- Slug: maddy-mail-server
- URL: https://www.canagentsuse.com/tools/maddy-mail-server
- Website: https://maddy.email/
- Docs: https://github.com/foxcpp/maddy
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Communication - Email - Complete Solutions
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - email - complete solutions workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go. Source code: https://github.com/foxcpp/maddy
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Maddy Mail Server is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/foxcpp/maddy
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://maddy.email/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/foxcpp/maddy
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/foxcpp/maddy
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/foxcpp/maddy
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/foxcpp/maddy

### Mail-in-a-Box

- Slug: mail-in-a-box
- URL: https://www.canagentsuse.com/tools/mail-in-a-box
- Website: https://mailinabox.email/
- Docs: https://github.com/mail-in-a-box/mailinabox
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Communication - Email - Complete Solutions
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - email - complete solutions workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as CC0-1.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Shell. Source code: https://github.com/mail-in-a-box/mailinabox
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Mail-in-a-Box is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/mail-in-a-box/mailinabox
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://mailinabox.email/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/mail-in-a-box/mailinabox
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/mail-in-a-box/mailinabox
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/mail-in-a-box/mailinabox
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/mail-in-a-box/mailinabox

### Mailcow

- Slug: mailcow
- URL: https://www.canagentsuse.com/tools/mailcow
- Website: https://mailcow.email/
- Docs: https://github.com/mailcow/mailcow-dockerized
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Communication - Email - Complete Solutions
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted communication - email - complete solutions workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, PHP. Source code: https://github.com/mailcow/mailcow-dockerized
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Mailcow is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/mailcow/mailcow-dockerized
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://mailcow.email/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/mailcow/mailcow-dockerized
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/mailcow/mailcow-dockerized
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/mailcow/mailcow-dockerized
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/mailcow/mailcow-dockerized

### Mailu

- Slug: mailu
- URL: https://www.canagentsuse.com/tools/mailu
- Website: https://mailu.io/
- Docs: https://github.com/Mailu/Mailu
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Communication - Email - Complete Solutions
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - email - complete solutions workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Python. Source code: https://github.com/Mailu/Mailu
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Mailu is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/Mailu/Mailu
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://mailu.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Mailu/Mailu
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Mailu/Mailu
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Mailu/Mailu
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Mailu/Mailu

### Maloja

- Slug: maloja
- URL: https://www.canagentsuse.com/tools/maloja
- Website: https://github.com/krateng/maloja
- Docs: https://github.com/krateng/maloja
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Media Streaming - Audio Streaming
- Use cases: Self-host a tool, Inspect open source, Triage work
- Best for: Self-hosted media streaming - audio streaming workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python, Docker. Source code: https://github.com/krateng/maloja
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Maloja is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/krateng/maloja
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/krateng/maloja
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/krateng/maloja
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/krateng/maloja
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/krateng/maloja
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/krateng/maloja

### Mastodon

- Slug: mastodon
- URL: https://www.canagentsuse.com/tools/mastodon
- Website: https://joinmastodon.org/
- Docs: https://github.com/mastodon/mastodon
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Communication - Social Networks and Forums
- Use cases: Self-host a tool, Inspect open source, Analyze product, Publish content
- Best for: Self-hosted communication - social networks and forums workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Ruby. Source code: https://github.com/mastodon/mastodon
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Mastodon is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/mastodon/mastodon
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://joinmastodon.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/mastodon/mastodon
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/mastodon/mastodon
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/mastodon/mastodon
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/mastodon/mastodon

### Matchering

- Slug: matchering
- URL: https://www.canagentsuse.com/tools/matchering
- Website: https://github.com/sergree/matchering
- Docs: https://github.com/sergree/matchering
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Automation
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted automation workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/sergree/matchering
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Matchering is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/sergree/matchering
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/sergree/matchering
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/sergree/matchering
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/sergree/matchering
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/sergree/matchering
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/sergree/matchering

### Mathesar

- Slug: mathesar
- URL: https://www.canagentsuse.com/tools/mathesar
- Website: https://mathesar.org/
- Docs: https://github.com/mathesar-foundation/mathesar
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Database Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Triage work
- Best for: Self-hosted database management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Python. Source code: https://github.com/mathesar-foundation/mathesar
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Mathesar is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/mathesar-foundation/mathesar
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://mathesar.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/mathesar-foundation/mathesar
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/mathesar-foundation/mathesar
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/mathesar-foundation/mathesar
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/mathesar-foundation/mathesar

### Mautic

- Slug: mautic
- URL: https://www.canagentsuse.com/tools/mautic
- Website: https://www.mautic.org/
- Docs: https://github.com/mautic/mautic
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Communication - Email - Mailing Lists and Newsletters
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted communication - email - mailing lists and newsletters workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/mautic/mautic
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Mautic is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/mautic/mautic
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.mautic.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/mautic/mautic
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/mautic/mautic
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/mautic/mautic
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/mautic/mautic

### MediaCMS

- Slug: mediacms
- URL: https://www.canagentsuse.com/tools/mediacms
- Website: https://mediacms.io
- Docs: https://github.com/mediacms-io/mediacms
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Media Streaming - Video Streaming, Content Management Systems (CMS)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted media streaming - video streaming workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python, Docker. Source code: https://github.com/mediacms-io/mediacms
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

MediaCMS is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/mediacms-io/mediacms
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://mediacms.io
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/mediacms-io/mediacms
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/mediacms-io/mediacms
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/mediacms-io/mediacms
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/mediacms-io/mediacms

### MediaMTX

- Slug: mediamtx
- URL: https://www.canagentsuse.com/tools/mediamtx
- Website: https://mediamtx.org
- Docs: https://github.com/bluenviron/mediamtx
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Media Streaming - Multimedia Streaming
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted media streaming - multimedia streaming workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker. Source code: https://github.com/bluenviron/mediamtx
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

MediaMTX is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/bluenviron/mediamtx
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://mediamtx.org
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/bluenviron/mediamtx
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/bluenviron/mediamtx
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/bluenviron/mediamtx
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/bluenviron/mediamtx

### Meelo

- Slug: meelo
- URL: https://www.canagentsuse.com/tools/meelo
- Website: https://github.com/Arthi-chaud/Meelo
- Docs: https://github.com/Arthi-chaud/Meelo
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Media Streaming - Multimedia Streaming
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted media streaming - multimedia streaming workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/Arthi-chaud/Meelo
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Meelo is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/Arthi-chaud/Meelo
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/Arthi-chaud/Meelo
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Arthi-chaud/Meelo
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Arthi-chaud/Meelo
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Arthi-chaud/Meelo
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Arthi-chaud/Meelo

### MeshCentral

- Slug: meshcentral
- URL: https://www.canagentsuse.com/tools/meshcentral
- Website: https://meshcentral.com/
- Docs: https://github.com/Ylianst/MeshCentral
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Remote Access
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted remote access workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs. Source code: https://github.com/Ylianst/MeshCentral
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

MeshCentral is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/Ylianst/MeshCentral
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://meshcentral.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Ylianst/MeshCentral
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Ylianst/MeshCentral
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Ylianst/MeshCentral
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Ylianst/MeshCentral

### MindsDB

- Slug: mindsdb
- URL: https://www.canagentsuse.com/tools/mindsdb
- Website: https://mindsdb.com/
- Docs: https://github.com/mindsdb/minds-platform
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Database Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Triage work
- Best for: Self-hosted database management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Elastic-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Python. Source code: https://github.com/mindsdb/minds-platform
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

MindsDB is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/mindsdb/minds-platform
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://mindsdb.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/mindsdb/minds-platform
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/mindsdb/minds-platform
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/mindsdb/minds-platform
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/mindsdb/minds-platform

### MintHCM

- Slug: minthcm
- URL: https://www.canagentsuse.com/tools/minthcm
- Website: https://minthcm.org/
- Docs: https://github.com/minthcm/minthcm
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Human Resources Management (HRM)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted human resources management (hrm) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/minthcm/minthcm
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

MintHCM is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/minthcm/minthcm
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://minthcm.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/minthcm/minthcm
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/minthcm/minthcm
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/minthcm/minthcm
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/minthcm/minthcm

### Misskey

- Slug: misskey
- URL: https://www.canagentsuse.com/tools/misskey
- Website: https://misskey.io/
- Docs: https://github.com/misskey-dev/misskey
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Communication - Social Networks and Forums
- Use cases: Self-host a tool, Inspect open source, Analyze product, Publish content
- Best for: Self-hosted communication - social networks and forums workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/misskey-dev/misskey
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Misskey is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/misskey-dev/misskey
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://misskey.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/misskey-dev/misskey
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/misskey-dev/misskey
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/misskey-dev/misskey
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/misskey-dev/misskey

### Mistral AI

- Slug: mistral-ai
- URL: https://www.canagentsuse.com/tools/mistral-ai
- Website: https://mistral.ai
- Docs: https://docs.mistral.ai
- Agent score: 64
- Agent tier: Usable
- Categories: AI models
- Use cases: Call models
- Best for: European AI model API usage, OCR, embeddings, and model routing experiments.
- Limitations: Key limitations: Verify model availability, regional requirements, and data policy before production automation. Model behavior, costs, rate limits, data retention, and safety policies can change by model and account tier; use evals, spend caps, and data controls for sensitive workloads. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Public model pricing with token-based rates.
- Auth: API keys through La Plateforme.
- Account creation: Self-serve account creation with billing for paid usage.
- Browser support: Console supports key and usage management.
- CLI: Not listed
- API base: https://api.mistral.ai/v1
- MCP server: Not listed

Agents can call Mistral's REST API for chat, embeddings, OCR, and agent workflows with public model/pricing docs.

Score breakdown:
- Machine operability: 14/25
- Agent safety: 10.4/25
- Agent readability: 17.4/20
- Auth and setup: 12/15
- Production reliability: 10/15

Capabilities:
- API: native. API docs cover chat, embeddings, agents, OCR, files, and fine-tuning. Evidence: https://docs.mistral.ai/api/
- Browser: strong. Console supports key and usage management. Evidence: https://mistral.ai
- Account creation: strong. Self-serve account creation with billing for paid usage. Evidence: https://mistral.ai
- Pricing clarity: strong. Mistral publishes model pricing. Evidence: https://mistral.ai/pricing
- Docs quality: strong. Docs are API-focused with examples and SDK references. Evidence: https://docs.mistral.ai

### MistServer

- Slug: mistserver
- URL: https://www.canagentsuse.com/tools/mistserver
- Website: https://mistserver.org/
- Docs: https://github.com/DDVTECH/mistserver
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Media Streaming - Multimedia Streaming
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted media streaming - multimedia streaming workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Unlicense; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C++. Source code: https://github.com/DDVTECH/mistserver
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

MistServer is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/DDVTECH/mistserver
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://mistserver.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/DDVTECH/mistserver
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/DDVTECH/mistserver
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/DDVTECH/mistserver
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/DDVTECH/mistserver

### MongooseIM

- Slug: mongooseim
- URL: https://www.canagentsuse.com/tools/mongooseim
- Website: https://www.erlang-solutions.com/products/mongooseim.html
- Docs: https://github.com/esl/MongooseIM
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Communication - XMPP - Servers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - xmpp - servers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Erlang, Docker, K8S. Source code: https://github.com/esl/MongooseIM
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

MongooseIM is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/esl/MongooseIM
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.erlang-solutions.com/products/mongooseim.html
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/esl/MongooseIM
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/esl/MongooseIM
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/esl/MongooseIM
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/esl/MongooseIM

### Mopidy

- Slug: mopidy
- URL: https://www.canagentsuse.com/tools/mopidy
- Website: https://docs.mopidy.com/
- Docs: https://github.com/mopidy/mopidy
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Media Streaming - Audio Streaming
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted media streaming - audio streaming workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python, deb. Source code: https://github.com/mopidy/mopidy
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Mopidy is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/mopidy/mopidy
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://docs.mopidy.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/mopidy/mopidy
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/mopidy/mopidy
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/mopidy/mopidy
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/mopidy/mopidy

### mStream

- Slug: mstream
- URL: https://www.canagentsuse.com/tools/mstream
- Website: https://mstream.io/
- Docs: https://github.com/IrosTheBeggar/mStream
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Media Streaming - Audio Streaming
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted media streaming - audio streaming workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs. Source code: https://github.com/IrosTheBeggar/mStream
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

mStream is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/IrosTheBeggar/mStream
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://mstream.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/IrosTheBeggar/mStream
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/IrosTheBeggar/mStream
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/IrosTheBeggar/mStream
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/IrosTheBeggar/mStream

### MyFin Budget

- Slug: myfin-budget
- URL: https://www.canagentsuse.com/tools/myfin-budget
- Website: https://myfinbudget.com
- Docs: https://github.com/afaneca/myfin
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Money, Budgeting & Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted money, budgeting & management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/afaneca/myfin
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

MyFin Budget is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/afaneca/myfin
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://myfinbudget.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/afaneca/myfin
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/afaneca/myfin
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/afaneca/myfin
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/afaneca/myfin

### Mylar3

- Slug: mylar3
- URL: https://www.canagentsuse.com/tools/mylar3
- Website: https://mylarcomics.com/
- Docs: https://github.com/mylar3/mylar3
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Automation
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted automation workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python, Docker. Source code: https://github.com/mylar3/mylar3
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Mylar3 is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/mylar3/mylar3
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://mylarcomics.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/mylar3/mylar3
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/mylar3/mylar3
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/mylar3/mylar3
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/mylar3/mylar3

### n8n

- Slug: n8n
- URL: https://www.canagentsuse.com/tools/n8n
- Website: https://n8n.io/
- Docs: https://github.com/n8n-io/n8n
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Automation
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted automation workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0, Commons-Clause; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs. Source code: https://github.com/n8n-io/n8n
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

n8n is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/n8n-io/n8n
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://n8n.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/n8n-io/n8n
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/n8n-io/n8n
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/n8n-io/n8n
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/n8n-io/n8n

### Navidrome Music Server

- Slug: navidrome-music-server
- URL: https://www.canagentsuse.com/tools/navidrome-music-server
- Website: https://www.navidrome.org
- Docs: https://github.com/navidrome/navidrome
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Media Streaming - Audio Streaming
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted media streaming - audio streaming workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Go. Source code: https://github.com/navidrome/navidrome
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Navidrome Music Server is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/navidrome/navidrome
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.navidrome.org
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/navidrome/navidrome
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/navidrome/navidrome
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/navidrome/navidrome
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/navidrome/navidrome

### Nextcloud

- Slug: nextcloud
- URL: https://www.canagentsuse.com/tools/nextcloud
- Website: https://nextcloud.com/
- Docs: https://github.com/nextcloud/server
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, File Transfer & Synchronization, Groupware
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted file transfer & synchronization workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP, deb. Source code: https://github.com/nextcloud/server
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Nextcloud is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/nextcloud/server
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://nextcloud.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/nextcloud/server
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/nextcloud/server
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/nextcloud/server
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/nextcloud/server

### NGINX

- Slug: nginx
- URL: https://www.canagentsuse.com/tools/nginx
- Website: https://nginx.org/en/
- Docs: https://github.com/nginx/nginx
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Web Servers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted web servers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as BSD-2-Clause; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C, deb, Docker. Source code: https://github.com/nginx/nginx
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

NGINX is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/nginx/nginx
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://nginx.org/en/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/nginx/nginx
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/nginx/nginx
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/nginx/nginx
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/nginx/nginx

### Nginx Proxy Manager

- Slug: nginx-proxy-manager
- URL: https://www.canagentsuse.com/tools/nginx-proxy-manager
- Website: https://nginxproxymanager.com/
- Docs: https://github.com/NginxProxyManager/nginx-proxy-manager
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Web Servers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted web servers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/NginxProxyManager/nginx-proxy-manager
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Nginx Proxy Manager is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/NginxProxyManager/nginx-proxy-manager
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://nginxproxymanager.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/NginxProxyManager/nginx-proxy-manager
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/NginxProxyManager/nginx-proxy-manager
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/NginxProxyManager/nginx-proxy-manager
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/NginxProxyManager/nginx-proxy-manager

### ngircd

- Slug: ngircd
- URL: https://www.canagentsuse.com/tools/ngircd
- Website: https://ngircd.barton.de/
- Docs: https://github.com/ngircd/ngircd
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Communication - IRC
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - irc workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C, deb. Source code: https://github.com/ngircd/ngircd
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

ngircd is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/ngircd/ngircd
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://ngircd.barton.de/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/ngircd/ngircd
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/ngircd/ngircd
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/ngircd/ngircd
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/ngircd/ngircd

### NocoDB

- Slug: nocodb
- URL: https://www.canagentsuse.com/tools/nocodb
- Website: https://www.nocodb.com/
- Docs: https://github.com/nocodb/nocodb
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Database Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Triage work
- Best for: Self-hosted database management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as SUL-1.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/nocodb/nocodb
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

NocoDB is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/nocodb/nocodb
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.nocodb.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/nocodb/nocodb
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/nocodb/nocodb
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/nocodb/nocodb
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/nocodb/nocodb

### Node RED

- Slug: node-red
- URL: https://www.canagentsuse.com/tools/node-red
- Website: https://nodered.org/
- Docs: https://github.com/node-red/node-red
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Internet of Things (IoT)
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted internet of things (iot) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/node-red/node-red
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Node RED is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/node-red/node-red
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://nodered.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/node-red/node-red
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/node-red/node-red
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/node-red/node-red
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/node-red/node-red

### Nominatim

- Slug: nominatim
- URL: https://www.canagentsuse.com/tools/nominatim
- Website: https://nominatim.org/
- Docs: https://github.com/osm-search/Nominatim
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Maps and Global Positioning System (GPS)
- Use cases: Self-host a tool, Inspect open source, Triage work
- Best for: Self-hosted maps and global positioning system (gps) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C. Source code: https://github.com/osm-search/Nominatim
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Nominatim is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/osm-search/Nominatim
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://nominatim.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/osm-search/Nominatim
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/osm-search/Nominatim
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/osm-search/Nominatim
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/osm-search/Nominatim

### Notifo

- Slug: notifo
- URL: https://www.canagentsuse.com/tools/notifo
- Website: https://github.com/notifo-io/notifo
- Docs: https://github.com/notifo-io/notifo
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Communication - Custom Communication Systems
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - custom communication systems workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C#. Source code: https://github.com/notifo-io/notifo
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Notifo is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/notifo-io/notifo
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/notifo-io/notifo
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/notifo-io/notifo
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/notifo-io/notifo
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/notifo-io/notifo
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/notifo-io/notifo

### OliveTin

- Slug: olivetin
- URL: https://www.canagentsuse.com/tools/olivetin
- Website: https://www.olivetin.app/
- Docs: https://github.com/OliveTin/OliveTin
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Automation
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted automation workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go. Source code: https://github.com/OliveTin/OliveTin
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

OliveTin is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/OliveTin/OliveTin
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.olivetin.app/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/OliveTin/OliveTin
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/OliveTin/OliveTin
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/OliveTin/OliveTin
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/OliveTin/OliveTin

### Omeka

- Slug: omeka
- URL: https://www.canagentsuse.com/tools/omeka
- Website: https://omeka.org
- Docs: https://github.com/omeka/Omeka
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Content Management Systems (CMS)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content, Triage work
- Best for: Self-hosted content management systems (cms) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/omeka/Omeka
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Omeka is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/omeka/Omeka
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://omeka.org
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/omeka/Omeka
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/omeka/Omeka
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/omeka/Omeka
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/omeka/Omeka

### Omeka S

- Slug: omeka-s
- URL: https://www.canagentsuse.com/tools/omeka-s
- Website: https://omeka.org/s/
- Docs: https://github.com/omeka/omeka-s
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Archiving and Digital Preservation (DP)
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted archiving and digital preservation (dp) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs. Source code: https://github.com/omeka/omeka-s
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Omeka S is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/omeka/omeka-s
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://omeka.org/s/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/omeka/omeka-s
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/omeka/omeka-s
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/omeka/omeka-s
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/omeka/omeka-s

### ONLYOFFICE

- Slug: onlyoffice
- URL: https://www.canagentsuse.com/tools/onlyoffice
- Website: https://helpcenter.onlyoffice.com/faq/server-opensource.aspx
- Docs: https://github.com/ONLYOFFICE/DocumentServer
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Office Suites
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted office suites workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/ONLYOFFICE/DocumentServer
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

ONLYOFFICE is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/ONLYOFFICE/DocumentServer
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://helpcenter.onlyoffice.com/faq/server-opensource.aspx
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/ONLYOFFICE/DocumentServer
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/ONLYOFFICE/DocumentServer
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/ONLYOFFICE/DocumentServer
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/ONLYOFFICE/DocumentServer

### Open Source Routing Machine (OSRM)

- Slug: open-source-routing-machine-osrm
- URL: https://www.canagentsuse.com/tools/open-source-routing-machine-osrm
- Website: http://project-osrm.org/
- Docs: https://github.com/Project-OSRM/osrm-backend
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Maps and Global Positioning System (GPS)
- Use cases: Self-host a tool, Inspect open source, Triage work
- Best for: Self-hosted maps and global positioning system (gps) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as BSD-2-Clause; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C++. Source code: https://github.com/Project-OSRM/osrm-backend
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Open Source Routing Machine (OSRM) is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/Project-OSRM/osrm-backend
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: http://project-osrm.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Project-OSRM/osrm-backend
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Project-OSRM/osrm-backend
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Project-OSRM/osrm-backend
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Project-OSRM/osrm-backend

### Open-WebUI

- Slug: open-webui
- URL: https://www.canagentsuse.com/tools/open-webui
- Website: https://openwebui.com
- Docs: https://github.com/open-webui/open-webui
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Generative Artificial Intelligence (GenAI)
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted generative artificial intelligence (genai) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as BSD-3-Clause; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Python. Source code: https://github.com/open-webui/open-webui
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Open-WebUI is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/open-webui/open-webui
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://openwebui.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/open-webui/open-webui
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/open-webui/open-webui
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/open-webui/open-webui
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/open-webui/open-webui

### Openfire

- Slug: openfire
- URL: https://www.canagentsuse.com/tools/openfire
- Website: https://www.igniterealtime.org/projects/openfire/
- Docs: https://github.com/igniterealtime/Openfire
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Communication - XMPP - Servers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - xmpp - servers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Java. Source code: https://github.com/igniterealtime/Openfire
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Openfire is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/igniterealtime/Openfire
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.igniterealtime.org/projects/openfire/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/igniterealtime/Openfire
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/igniterealtime/Openfire
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/igniterealtime/Openfire
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/igniterealtime/Openfire

### openHAB

- Slug: openhab
- URL: https://www.canagentsuse.com/tools/openhab
- Website: https://www.openhab.org
- Docs: https://github.com/openhab/openhab-core
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Internet of Things (IoT)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Analyze product
- Best for: Self-hosted internet of things (iot) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as EPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Java. Source code: https://github.com/openhab/openhab-core
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

openHAB is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/openhab/openhab-core
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.openhab.org
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/openhab/openhab-core
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/openhab/openhab-core
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/openhab/openhab-core
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/openhab/openhab-core

### Openmeetings

- Slug: openmeetings
- URL: https://www.canagentsuse.com/tools/openmeetings
- Website: https://openmeetings.apache.org/index.html
- Docs: https://github.com/apache/openmeetings
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Groupware
- Use cases: Self-host a tool, Inspect open source, Publish content
- Best for: Self-hosted groupware workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Java. Source code: https://github.com/apache/openmeetings
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Openmeetings is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/apache/openmeetings
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://openmeetings.apache.org/index.html
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/apache/openmeetings
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/apache/openmeetings
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/apache/openmeetings
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/apache/openmeetings

### OpenSearch

- Slug: opensearch
- URL: https://www.canagentsuse.com/tools/opensearch
- Website: https://opensearch.org
- Docs: https://github.com/opensearch-project/OpenSearch
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Search Engines
- Use cases: Self-host a tool, Inspect open source, Triage work
- Best for: Self-hosted search engines workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Java, Docker, K8S, deb. Source code: https://github.com/opensearch-project/OpenSearch
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

OpenSearch is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/opensearch-project/OpenSearch
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://opensearch.org
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/opensearch-project/OpenSearch
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/opensearch-project/OpenSearch
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/opensearch-project/OpenSearch
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/opensearch-project/OpenSearch

### openSIPS

- Slug: opensips
- URL: https://www.canagentsuse.com/tools/opensips
- Website: https://opensips.org/
- Docs: https://github.com/OpenSIPS/opensips
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Communication - SIP
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - sip workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C. Source code: https://github.com/OpenSIPS/opensips
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

openSIPS is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/OpenSIPS/opensips
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://opensips.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/OpenSIPS/opensips
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/OpenSIPS/opensips
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/OpenSIPS/opensips
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/OpenSIPS/opensips

### OpenSMTPD

- Slug: opensmtpd
- URL: https://www.canagentsuse.com/tools/opensmtpd
- Website: https://opensmtpd.org/
- Docs: https://github.com/OpenSMTPD/OpenSMTPD/
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Communication - Email - Mail Transfer Agents
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted communication - email - mail transfer agents workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as ISC; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C, deb. Source code: https://github.com/OpenSMTPD/OpenSMTPD/
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

OpenSMTPD is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/OpenSMTPD/OpenSMTPD/
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://opensmtpd.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/OpenSMTPD/OpenSMTPD/
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/OpenSMTPD/OpenSMTPD/
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/OpenSMTPD/OpenSMTPD/
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/OpenSMTPD/OpenSMTPD/

### OpenTrashmail

- Slug: opentrashmail
- URL: https://www.canagentsuse.com/tools/opentrashmail
- Website: https://github.com/HaschekSolutions/opentrashmail
- Docs: https://github.com/HaschekSolutions/opentrashmail
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Communication - Email - Mail Transfer Agents
- Use cases: Self-host a tool, Inspect open source, Triage work
- Best for: Self-hosted communication - email - mail transfer agents workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python, PHP, Docker. Source code: https://github.com/HaschekSolutions/opentrashmail
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

OpenTrashmail is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/HaschekSolutions/opentrashmail
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/HaschekSolutions/opentrashmail
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/HaschekSolutions/opentrashmail
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/HaschekSolutions/opentrashmail
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/HaschekSolutions/opentrashmail
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/HaschekSolutions/opentrashmail

### Opik

- Slug: opik
- URL: https://www.canagentsuse.com/tools/opik
- Website: https://www.comet.com/site/products/opik/
- Docs: https://github.com/comet-ml/opik
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Software Development - API Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted software development - api management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Python. Source code: https://github.com/comet-ml/opik
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Opik is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/comet-ml/opik
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.comet.com/site/products/opik/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/comet-ml/opik
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/comet-ml/opik
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/comet-ml/opik
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/comet-ml/opik

### OSSN

- Slug: ossn
- URL: https://www.canagentsuse.com/tools/ossn
- Website: https://www.opensource-socialnetwork.org/
- Docs: https://github.com/opensource-socialnetwork/opensource-socialnetwork
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Communication - Social Networks and Forums
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - social networks and forums workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as CAL-1.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/opensource-socialnetwork/opensource-socialnetwork
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

OSSN is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/opensource-socialnetwork/opensource-socialnetwork
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.opensource-socialnetwork.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/opensource-socialnetwork/opensource-socialnetwork
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/opensource-socialnetwork/opensource-socialnetwork
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/opensource-socialnetwork/opensource-socialnetwork
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/opensource-socialnetwork/opensource-socialnetwork

### Outline Server

- Slug: outline-server
- URL: https://www.canagentsuse.com/tools/outline-server
- Website: https://getoutline.org/
- Docs: https://github.com/OutlineFoundation/outline-server
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Proxy
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted proxy workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Nodejs. Source code: https://github.com/OutlineFoundation/outline-server
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Outline Server is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/OutlineFoundation/outline-server
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://getoutline.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/OutlineFoundation/outline-server
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/OutlineFoundation/outline-server
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/OutlineFoundation/outline-server
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/OutlineFoundation/outline-server

### OvenMediaEngine

- Slug: ovenmediaengine
- URL: https://www.canagentsuse.com/tools/ovenmediaengine
- Website: https://github.com/OvenMediaLabs/OvenMediaEngine
- Docs: https://github.com/OvenMediaLabs/OvenMediaEngine
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Media Streaming - Video Streaming
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted media streaming - video streaming workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C++, Docker. Source code: https://github.com/OvenMediaLabs/OvenMediaEngine
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

OvenMediaEngine is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/OvenMediaLabs/OvenMediaEngine
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/OvenMediaLabs/OvenMediaEngine
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/OvenMediaLabs/OvenMediaEngine
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/OvenMediaLabs/OvenMediaEngine
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/OvenMediaLabs/OvenMediaEngine
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/OvenMediaLabs/OvenMediaEngine

### Owncast

- Slug: owncast
- URL: https://www.canagentsuse.com/tools/owncast
- Website: https://owncast.online/
- Docs: https://github.com/owncast/owncast
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Media Streaming - Video Streaming
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted media streaming - video streaming workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go. Source code: https://github.com/owncast/owncast
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Owncast is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/owncast/owncast
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://owncast.online/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/owncast/owncast
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/owncast/owncast
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/owncast/owncast
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/owncast/owncast

### Pangolin

- Slug: pangolin
- URL: https://www.canagentsuse.com/tools/pangolin
- Website: https://digpangolin.com/
- Docs: https://github.com/fosrl/pangolin
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Web Servers, Remote Access
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted web servers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/fosrl/pangolin
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Pangolin is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/fosrl/pangolin
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://digpangolin.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/fosrl/pangolin
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/fosrl/pangolin
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/fosrl/pangolin
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/fosrl/pangolin

### Para

- Slug: para
- URL: https://www.canagentsuse.com/tools/para
- Website: https://paraio.org
- Docs: https://github.com/erudika/para
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Software Development - API Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted software development - api management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Java, Docker. Source code: https://github.com/erudika/para
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Para is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/erudika/para
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://paraio.org
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/erudika/para
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/erudika/para
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/erudika/para
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/erudika/para

### Part-DB

- Slug: part-db
- URL: https://www.canagentsuse.com/tools/part-db
- Website: https://docs.part-db.de/
- Docs: https://github.com/Part-DB/Part-DB-server
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Inventory Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted inventory management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, PHP, Nodejs. Source code: https://github.com/Part-DB/Part-DB-server
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Part-DB is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/Part-DB/Part-DB-server
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://docs.part-db.de/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Part-DB/Part-DB-server
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Part-DB/Part-DB-server
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Part-DB/Part-DB-server
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Part-DB/Part-DB-server

### Passbolt

- Slug: passbolt
- URL: https://www.canagentsuse.com/tools/passbolt
- Website: https://www.passbolt.com/
- Docs: https://github.com/passbolt/passbolt_api
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Password Managers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted password managers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP, deb, K8S, Docker. Source code: https://github.com/passbolt/passbolt_api
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Passbolt is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/passbolt/passbolt_api
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.passbolt.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/passbolt/passbolt_api
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/passbolt/passbolt_api
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/passbolt/passbolt_api
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/passbolt/passbolt_api

### Pelican Panel

- Slug: pelican-panel
- URL: https://www.canagentsuse.com/tools/pelican-panel
- Website: https://pelican.dev/
- Docs: https://github.com/pelican-dev/panel
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Games - Administrative Utilities & Control Panels
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Analyze product
- Best for: Self-hosted games - administrative utilities & control panels workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP, Docker. Source code: https://github.com/pelican-dev/panel
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Pelican Panel is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/pelican-dev/panel
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://pelican.dev/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/pelican-dev/panel
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/pelican-dev/panel
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/pelican-dev/panel
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/pelican-dev/panel

### Photoview

- Slug: photoview
- URL: https://www.canagentsuse.com/tools/photoview
- Website: https://photoview.github.io/
- Docs: https://github.com/photoview/photoview
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Photo Galleries
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted photo galleries workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker. Source code: https://github.com/photoview/photoview
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Photoview is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/photoview/photoview
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://photoview.github.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/photoview/photoview
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/photoview/photoview
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/photoview/photoview
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/photoview/photoview

### PiGallery 2

- Slug: pigallery-2
- URL: https://www.canagentsuse.com/tools/pigallery-2
- Website: https://bpatrik.github.io/pigallery2/
- Docs: https://github.com/bpatrik/pigallery2
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Photo Galleries
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted photo galleries workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Nodejs. Source code: https://github.com/bpatrik/pigallery2
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

PiGallery 2 is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/bpatrik/pigallery2
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://bpatrik.github.io/pigallery2/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/bpatrik/pigallery2
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/bpatrik/pigallery2
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/bpatrik/pigallery2
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/bpatrik/pigallery2

### Pinepods

- Slug: pinepods
- URL: https://www.canagentsuse.com/tools/pinepods
- Website: https://www.pinepods.online/
- Docs: https://github.com/madeofpendletonwool/PinePods
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Media Streaming - Audio Streaming
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Triage work
- Best for: Self-hosted media streaming - audio streaming workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/madeofpendletonwool/PinePods
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Pinepods is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/madeofpendletonwool/PinePods
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.pinepods.online/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/madeofpendletonwool/PinePods
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/madeofpendletonwool/PinePods
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/madeofpendletonwool/PinePods
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/madeofpendletonwool/PinePods

### piqueserver

- Slug: piqueserver
- URL: https://www.canagentsuse.com/tools/piqueserver
- Website: https://github.com/piqueserver/piqueserver
- Docs: https://github.com/piqueserver/piqueserver
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Games
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted games workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python, C++. Source code: https://github.com/piqueserver/piqueserver
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

piqueserver is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/piqueserver/piqueserver
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/piqueserver/piqueserver
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/piqueserver/piqueserver
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/piqueserver/piqueserver
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/piqueserver/piqueserver
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/piqueserver/piqueserver

### plugNmeet

- Slug: plugnmeet
- URL: https://www.canagentsuse.com/tools/plugnmeet
- Website: https://www.plugnmeet.org/
- Docs: https://github.com/mynaparrot/plugNmeet-server
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Communication - Video Conferencing
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - video conferencing workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Go. Source code: https://github.com/mynaparrot/plugNmeet-server
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

plugNmeet is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/mynaparrot/plugNmeet-server
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.plugnmeet.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/mynaparrot/plugNmeet-server
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/mynaparrot/plugNmeet-server
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/mynaparrot/plugNmeet-server
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/mynaparrot/plugNmeet-server

### Pomerium

- Slug: pomerium
- URL: https://www.canagentsuse.com/tools/pomerium
- Website: https://www.pomerium.io
- Docs: https://github.com/pomerium/pomerium
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Web Servers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted web servers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker. Source code: https://github.com/pomerium/pomerium
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Pomerium is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/pomerium/pomerium
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.pomerium.io
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/pomerium/pomerium
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/pomerium/pomerium
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/pomerium/pomerium
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/pomerium/pomerium

### Postal

- Slug: postal
- URL: https://www.canagentsuse.com/tools/postal
- Website: https://docs.postalserver.io/
- Docs: https://github.com/postalserver/postal
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Communication - Email - Complete Solutions
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - email - complete solutions workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Ruby. Source code: https://github.com/postalserver/postal
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Postal is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/postalserver/postal
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://docs.postalserver.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/postalserver/postal
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/postalserver/postal
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/postalserver/postal
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/postalserver/postal

### PrestaShop

- Slug: prestashop
- URL: https://www.canagentsuse.com/tools/prestashop
- Website: https://www.prestashop.com/
- Docs: https://github.com/PrestaShop/PrestaShop
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, E-commerce
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted e-commerce workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as OSL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/PrestaShop/PrestaShop
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

PrestaShop is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/PrestaShop/PrestaShop
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.prestashop.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/PrestaShop/PrestaShop
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/PrestaShop/PrestaShop
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/PrestaShop/PrestaShop
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/PrestaShop/PrestaShop

### PrivateBin

- Slug: privatebin
- URL: https://www.canagentsuse.com/tools/privatebin
- Website: https://privatebin.info/
- Docs: https://github.com/PrivateBin/PrivateBin
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Pastebins
- Use cases: Self-host a tool, Inspect open source, Triage work
- Best for: Self-hosted pastebins workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Zlib; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/PrivateBin/PrivateBin
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

PrivateBin is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/PrivateBin/PrivateBin
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://privatebin.info/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/PrivateBin/PrivateBin
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/PrivateBin/PrivateBin
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/PrivateBin/PrivateBin
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/PrivateBin/PrivateBin

### Pterodactyl

- Slug: pterodactyl
- URL: https://www.canagentsuse.com/tools/pterodactyl
- Website: https://pterodactyl.io/
- Docs: https://github.com/pterodactyl/panel
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Games - Administrative Utilities & Control Panels
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted games - administrative utilities & control panels workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/pterodactyl/panel
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Pterodactyl is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/pterodactyl/panel
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://pterodactyl.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/pterodactyl/panel
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/pterodactyl/panel
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/pterodactyl/panel
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/pterodactyl/panel

### PufferPanel

- Slug: pufferpanel
- URL: https://www.canagentsuse.com/tools/pufferpanel
- Website: https://www.pufferpanel.com/
- Docs: https://github.com/pufferpanel/pufferpanel
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Games - Administrative Utilities & Control Panels
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted games - administrative utilities & control panels workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go. Source code: https://github.com/pufferpanel/pufferpanel
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

PufferPanel is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/pufferpanel/pufferpanel
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.pufferpanel.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/pufferpanel/pufferpanel
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/pufferpanel/pufferpanel
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/pufferpanel/pufferpanel
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/pufferpanel/pufferpanel

### PushBits

- Slug: pushbits
- URL: https://www.canagentsuse.com/tools/pushbits
- Website: https://github.com/pushbits/server
- Docs: https://github.com/pushbits/server
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Communication - Custom Communication Systems
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - custom communication systems workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as ISC; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go. Source code: https://github.com/pushbits/server
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

PushBits is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/pushbits/server
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/pushbits/server
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/pushbits/server
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/pushbits/server
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/pushbits/server
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/pushbits/server

### Pydio

- Slug: pydio
- URL: https://www.canagentsuse.com/tools/pydio
- Website: https://pydio.com/
- Docs: https://github.com/pydio/cells
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, File Transfer & Synchronization
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted file transfer & synchronization workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go. Source code: https://github.com/pydio/cells
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Pydio is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/pydio/cells
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://pydio.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/pydio/cells
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/pydio/cells
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/pydio/cells
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/pydio/cells

### Radicale

- Slug: radicale
- URL: https://www.canagentsuse.com/tools/radicale
- Website: https://radicale.org/
- Docs: https://github.com/Kozea/Radicale
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Calendar & Contacts
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted calendar & contacts workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python, deb. Source code: https://github.com/Kozea/Radicale
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Radicale is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/Kozea/Radicale
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://radicale.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Kozea/Radicale
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Kozea/Radicale
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Kozea/Radicale
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Kozea/Radicale

### Reaparr

- Slug: reaparr
- URL: https://www.canagentsuse.com/tools/reaparr
- Website: https://www.reaparr.rocks/
- Docs: https://github.com/Reaparr/Reaparr
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Media Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted media management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/Reaparr/Reaparr
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Reaparr is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/Reaparr/Reaparr
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.reaparr.rocks/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Reaparr/Reaparr
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Reaparr/Reaparr
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Reaparr/Reaparr
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Reaparr/Reaparr

### Restreamer

- Slug: restreamer
- URL: https://www.canagentsuse.com/tools/restreamer
- Website: https://datarhei.github.io/restreamer/
- Docs: https://github.com/datarhei/restreamer
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Media Streaming - Video Streaming
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted media streaming - video streaming workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/datarhei/restreamer
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Restreamer is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/datarhei/restreamer
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://datarhei.github.io/restreamer/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/datarhei/restreamer
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/datarhei/restreamer
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/datarhei/restreamer
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/datarhei/restreamer

### Retrom

- Slug: retrom
- URL: https://www.canagentsuse.com/tools/retrom
- Website: https://github.com/JMBeresford/retrom
- Docs: https://github.com/JMBeresford/retrom
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Games - Administrative Utilities & Control Panels
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted games - administrative utilities & control panels workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Rust. Source code: https://github.com/JMBeresford/retrom
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Retrom is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/JMBeresford/retrom
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/JMBeresford/retrom
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/JMBeresford/retrom
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/JMBeresford/retrom
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/JMBeresford/retrom
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/JMBeresford/retrom

### Revive Adserver

- Slug: revive-adserver
- URL: https://www.canagentsuse.com/tools/revive-adserver
- Website: https://www.revive-adserver.com/
- Docs: https://github.com/revive-adserver/revive-adserver
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Miscellaneous
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted miscellaneous workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/revive-adserver/revive-adserver
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Revive Adserver is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/revive-adserver/revive-adserver
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.revive-adserver.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/revive-adserver/revive-adserver
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/revive-adserver/revive-adserver
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/revive-adserver/revive-adserver
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/revive-adserver/revive-adserver

### Routr

- Slug: routr
- URL: https://www.canagentsuse.com/tools/routr
- Website: https://routr.io
- Docs: https://github.com/fonoster/routr
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Communication - SIP
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - sip workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, K8S. Source code: https://github.com/fonoster/routr
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Routr is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/fonoster/routr
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://routr.io
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/fonoster/routr
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/fonoster/routr
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/fonoster/routr
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/fonoster/routr

### RSS Monster

- Slug: rss-monster
- URL: https://www.canagentsuse.com/tools/rss-monster
- Website: https://github.com/pietheinstrengholt/rssmonster
- Docs: https://github.com/pietheinstrengholt/rssmonster
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Feed Readers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted feed readers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/pietheinstrengholt/rssmonster
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

RSS Monster is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/pietheinstrengholt/rssmonster
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/pietheinstrengholt/rssmonster
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/pietheinstrengholt/rssmonster
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/pietheinstrengholt/rssmonster
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/pietheinstrengholt/rssmonster
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/pietheinstrengholt/rssmonster

### RStudio Server

- Slug: rstudio-server
- URL: https://www.canagentsuse.com/tools/rstudio-server
- Website: https://www.rstudio.com/products/rstudio/#Server
- Docs: https://github.com/rstudio/rstudio
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Software Development - IDE & Tools
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted software development - ide & tools workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Java, C++. Source code: https://github.com/rstudio/rstudio
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

RStudio Server is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/rstudio/rstudio
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.rstudio.com/products/rstudio/#Server
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/rstudio/rstudio
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/rstudio/rstudio
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/rstudio/rstudio
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/rstudio/rstudio

### RudderStack

- Slug: rudderstack
- URL: https://www.canagentsuse.com/tools/rudderstack
- Website: https://rudderstack.com/
- Docs: https://github.com/rudderlabs/rudder-server/
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Analytics
- Use cases: Self-host a tool, Inspect open source, Analyze product, Triage work
- Best for: Self-hosted analytics workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Elastic-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, K8S, Go, Nodejs. Source code: https://github.com/rudderlabs/rudder-server/
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

RudderStack is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/rudderlabs/rudder-server/
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://rudderstack.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/rudderlabs/rudder-server/
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/rudderlabs/rudder-server/
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/rudderlabs/rudder-server/
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/rudderlabs/rudder-server/

### SabreDAV

- Slug: sabredav
- URL: https://www.canagentsuse.com/tools/sabredav
- Website: https://sabre.io/
- Docs: https://github.com/sabre-io/dav
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Calendar & Contacts
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted calendar & contacts workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/sabre-io/dav
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

SabreDAV is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/sabre-io/dav
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://sabre.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/sabre-io/dav
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/sabre-io/dav
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/sabre-io/dav
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/sabre-io/dav

### SafeLine

- Slug: safeline
- URL: https://www.canagentsuse.com/tools/safeline
- Website: https://waf.chaitin.com/
- Docs: https://github.com/chaitin/SafeLine
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Web Servers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted web servers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/chaitin/SafeLine
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

SafeLine is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/chaitin/SafeLine
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://waf.chaitin.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/chaitin/SafeLine
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/chaitin/SafeLine
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/chaitin/SafeLine
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/chaitin/SafeLine

### Saltcorn

- Slug: saltcorn
- URL: https://www.canagentsuse.com/tools/saltcorn
- Website: https://saltcorn.com/
- Docs: https://github.com/saltcorn/saltcorn
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Software Development - Low Code
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Triage work
- Best for: Self-hosted software development - low code workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Nodejs. Source code: https://github.com/saltcorn/saltcorn
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Saltcorn is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/saltcorn/saltcorn
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://saltcorn.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/saltcorn/saltcorn
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/saltcorn/saltcorn
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/saltcorn/saltcorn
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/saltcorn/saltcorn

### Sandstorm

- Slug: sandstorm
- URL: https://www.canagentsuse.com/tools/sandstorm
- Website: https://sandstorm.io/
- Docs: https://github.com/sandstorm-io/sandstorm
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Self-hosting Solutions
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted self-hosting solutions workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C++, Shell. Source code: https://github.com/sandstorm-io/sandstorm
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Sandstorm is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/sandstorm-io/sandstorm
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://sandstorm.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/sandstorm-io/sandstorm
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/sandstorm-io/sandstorm
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/sandstorm-io/sandstorm
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/sandstorm-io/sandstorm

### Scoold

- Slug: scoold
- URL: https://www.canagentsuse.com/tools/scoold
- Website: https://scoold.com
- Docs: https://github.com/Erudika/scoold
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Communication - Social Networks and Forums
- Use cases: Self-host a tool, Inspect open source, Analyze product, Triage work
- Best for: Self-hosted communication - social networks and forums workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Java, Docker, K8S. Source code: https://github.com/Erudika/scoold
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Scoold is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/Erudika/scoold
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://scoold.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Erudika/scoold
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Erudika/scoold
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Erudika/scoold
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Erudika/scoold

### Screego

- Slug: screego
- URL: https://www.canagentsuse.com/tools/screego
- Website: https://screego.net
- Docs: https://github.com/screego/server
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Communication - Custom Communication Systems
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - custom communication systems workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Go. Source code: https://github.com/screego/server
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Screego is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/screego/server
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://screego.net
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/screego/server
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/screego/server
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/screego/server
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/screego/server

### SearXNG

- Slug: searxng
- URL: https://www.canagentsuse.com/tools/searxng
- Website: https://docs.searxng.org/
- Docs: https://github.com/searxng/searxng/
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Search Engines
- Use cases: Self-host a tool, Inspect open source, Triage work
- Best for: Self-hosted search engines workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python, Docker. Source code: https://github.com/searxng/searxng/
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

SearXNG is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/searxng/searxng/
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://docs.searxng.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/searxng/searxng/
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/searxng/searxng/
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/searxng/searxng/
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/searxng/searxng/

### SeaweedFS

- Slug: seaweedfs
- URL: https://www.canagentsuse.com/tools/seaweedfs
- Website: https://github.com/seaweedfs/seaweedfs
- Docs: https://github.com/seaweedfs/seaweedfs
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, File Transfer - Object Storage & File Servers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted file transfer - object storage & file servers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go. Source code: https://github.com/seaweedfs/seaweedfs
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

SeaweedFS is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/seaweedfs/seaweedfs
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/seaweedfs/seaweedfs
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/seaweedfs/seaweedfs
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/seaweedfs/seaweedfs
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/seaweedfs/seaweedfs
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/seaweedfs/seaweedfs

### Seerr

- Slug: seerr
- URL: https://www.canagentsuse.com/tools/seerr
- Website: https://github.com/seerr-team/seerr
- Docs: https://github.com/seerr-team/seerr
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Media Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted media management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Nodejs. Source code: https://github.com/seerr-team/seerr
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Seerr is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/seerr-team/seerr
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/seerr-team/seerr
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/seerr-team/seerr
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/seerr-team/seerr
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/seerr-team/seerr
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/seerr-team/seerr

### Self Host Blocks

- Slug: self-host-blocks
- URL: https://www.canagentsuse.com/tools/self-host-blocks
- Website: https://github.com/ibizaman/selfhostblocks
- Docs: https://github.com/ibizaman/selfhostblocks
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Self-hosting Solutions
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted self-hosting solutions workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nix. Source code: https://github.com/ibizaman/selfhostblocks
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Self Host Blocks is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/ibizaman/selfhostblocks
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/ibizaman/selfhostblocks
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/ibizaman/selfhostblocks
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/ibizaman/selfhostblocks
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/ibizaman/selfhostblocks
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/ibizaman/selfhostblocks

### Sentry Self-Hosted

- Slug: sentry-self-hosted
- URL: https://www.canagentsuse.com/tools/sentry-self-hosted
- Website: https://github.com/getsentry/self-hosted
- Docs: https://github.com/getsentry/sentry
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Software Development - Testing
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted software development - testing workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as BUSL-1.1; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python. Source code: https://github.com/getsentry/sentry
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Sentry Self-Hosted is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/getsentry/sentry
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/getsentry/self-hosted
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/getsentry/sentry
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/getsentry/sentry
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/getsentry/sentry
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/getsentry/sentry

### sftpgo Community Edition

- Slug: sftpgo-community-edition
- URL: https://www.canagentsuse.com/tools/sftpgo-community-edition
- Website: https://github.com/drakkan/sftpgo
- Docs: https://github.com/drakkan/sftpgo
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, File Transfer - Object Storage & File Servers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted file transfer - object storage & file servers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0, ⊘ Proprietary; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, deb, Docker. Source code: https://github.com/drakkan/sftpgo
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

sftpgo Community Edition is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/drakkan/sftpgo
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/drakkan/sftpgo
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/drakkan/sftpgo
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/drakkan/sftpgo
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/drakkan/sftpgo
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/drakkan/sftpgo

### Shaarli

- Slug: shaarli
- URL: https://www.canagentsuse.com/tools/shaarli
- Website: https://github.com/shaarli/Shaarli
- Docs: https://github.com/shaarli/Shaarli
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Bookmarks and Link Sharing
- Use cases: Self-host a tool, Inspect open source, Triage work
- Best for: Self-hosted bookmarks and link sharing workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Zlib; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP, deb. Source code: https://github.com/shaarli/Shaarli
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Shaarli is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/shaarli/Shaarli
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/shaarli/Shaarli
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/shaarli/Shaarli
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/shaarli/Shaarli
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/shaarli/Shaarli
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/shaarli/Shaarli

### Shelf

- Slug: shelf
- URL: https://www.canagentsuse.com/tools/shelf
- Website: https://www.shelf.nu
- Docs: https://github.com/Shelf-nu/shelf.nu
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Inventory Management, Maps and Global Positioning System (GPS)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Triage work
- Best for: Self-hosted inventory management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs. Source code: https://github.com/Shelf-nu/shelf.nu
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Shelf is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/Shelf-nu/shelf.nu
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.shelf.nu
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Shelf-nu/shelf.nu
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Shelf-nu/shelf.nu
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Shelf-nu/shelf.nu
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Shelf-nu/shelf.nu

### Simple NixOS Mailserver

- Slug: simple-nixos-mailserver
- URL: https://www.canagentsuse.com/tools/simple-nixos-mailserver
- Website: https://gitlab.com/simple-nixos-mailserver/nixos-mailserver
- Docs: https://gitlab.com/simple-nixos-mailserver/nixos-mailserver
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Communication - Email - Complete Solutions
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - email - complete solutions workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nix. Source code: https://gitlab.com/simple-nixos-mailserver/nixos-mailserver
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Simple NixOS Mailserver is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://gitlab.com/simple-nixos-mailserver/nixos-mailserver
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://gitlab.com/simple-nixos-mailserver/nixos-mailserver
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://gitlab.com/simple-nixos-mailserver/nixos-mailserver
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://gitlab.com/simple-nixos-mailserver/nixos-mailserver
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://gitlab.com/simple-nixos-mailserver/nixos-mailserver
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://gitlab.com/simple-nixos-mailserver/nixos-mailserver

### Snapcast

- Slug: snapcast
- URL: https://www.canagentsuse.com/tools/snapcast
- Website: https://github.com/snapcast/snapcast
- Docs: https://github.com/snapcast/snapcast
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Media Streaming - Audio Streaming
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted media streaming - audio streaming workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C++, deb. Source code: https://github.com/snapcast/snapcast
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Snapcast is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/snapcast/snapcast
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/snapcast/snapcast
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/snapcast/snapcast
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/snapcast/snapcast
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/snapcast/snapcast
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/snapcast/snapcast

### Specifically Clementines

- Slug: specifically-clementines
- URL: https://www.canagentsuse.com/tools/specifically-clementines
- Website: https://davideshay.github.io/groceries/
- Docs: https://github.com/davideshay/groceries
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Recipe Management, Inventory Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted recipe management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/davideshay/groceries
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Specifically Clementines is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/davideshay/groceries
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://davideshay.github.io/groceries/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/davideshay/groceries
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/davideshay/groceries
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/davideshay/groceries
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/davideshay/groceries

### Spree Commerce

- Slug: spree-commerce
- URL: https://www.canagentsuse.com/tools/spree-commerce
- Website: https://spreecommerce.org
- Docs: https://github.com/spree/spree
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, E-commerce
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted e-commerce workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as BSD-3-Clause; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Ruby. Source code: https://github.com/spree/spree
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Spree Commerce is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/spree/spree
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://spreecommerce.org
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/spree/spree
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/spree/spree
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/spree/spree
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/spree/spree

### SRS

- Slug: srs
- URL: https://www.canagentsuse.com/tools/srs
- Website: https://ossrs.io/
- Docs: https://github.com/ossrs/srs
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Media Streaming - Video Streaming
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted media streaming - video streaming workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, C++. Source code: https://github.com/ossrs/srs
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

SRS is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/ossrs/srs
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://ossrs.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/ossrs/srs
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/ossrs/srs
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/ossrs/srs
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/ossrs/srs

### StackStorm

- Slug: stackstorm
- URL: https://www.canagentsuse.com/tools/stackstorm
- Website: https://stackstorm.com
- Docs: https://github.com/StackStorm/st2
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Automation
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted automation workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python. Source code: https://github.com/StackStorm/st2
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

StackStorm is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/StackStorm/st2
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://stackstorm.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/StackStorm/st2
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/StackStorm/st2
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/StackStorm/st2
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/StackStorm/st2

### Stalwart Mail Server

- Slug: stalwart-mail-server
- URL: https://www.canagentsuse.com/tools/stalwart-mail-server
- Website: https://stalw.art
- Docs: https://github.com/stalwartlabs/stalwart
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Communication - Email - Complete Solutions
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - email - complete solutions workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Rust, Docker. Source code: https://github.com/stalwartlabs/stalwart
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Stalwart Mail Server is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/stalwartlabs/stalwart
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://stalw.art
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/stalwartlabs/stalwart
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/stalwartlabs/stalwart
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/stalwartlabs/stalwart
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/stalwartlabs/stalwart

### StartOS

- Slug: startos
- URL: https://www.canagentsuse.com/tools/startos
- Website: https://start9.com
- Docs: https://github.com/Start9Labs/start-os
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Self-hosting Solutions
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted self-hosting solutions workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Rust. Source code: https://github.com/Start9Labs/start-os
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

StartOS is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/Start9Labs/start-os
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://start9.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Start9Labs/start-os
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Start9Labs/start-os
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Start9Labs/start-os
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Start9Labs/start-os

### Stash

- Slug: stash
- URL: https://www.canagentsuse.com/tools/stash
- Website: https://stashapp.cc
- Docs: https://github.com/stashapp/stash
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Media Streaming - Multimedia Streaming
- Use cases: Self-host a tool, Inspect open source, Triage work
- Best for: Self-hosted media streaming - multimedia streaming workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Go. Source code: https://github.com/stashapp/stash
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Stash is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/stashapp/stash
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://stashapp.cc
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/stashapp/stash
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/stashapp/stash
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/stashapp/stash
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/stashapp/stash

### Static Web Server

- Slug: static-web-server
- URL: https://www.canagentsuse.com/tools/static-web-server
- Website: https://static-web-server.net/
- Docs: https://github.com/static-web-server/static-web-server
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Web Servers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted web servers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0, MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Rust, Docker. Source code: https://github.com/static-web-server/static-web-server
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Static Web Server is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/static-web-server/static-web-server
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://static-web-server.net/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/static-web-server/static-web-server
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/static-web-server/static-web-server
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/static-web-server/static-web-server
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/static-web-server/static-web-server

### Strapi

- Slug: strapi
- URL: https://www.canagentsuse.com/tools/strapi
- Website: https://strapi.io/
- Docs: https://github.com/strapi/strapi
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Content Management Systems (CMS)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted content management systems (cms) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs. Source code: https://github.com/strapi/strapi
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Strapi is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/strapi/strapi
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://strapi.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/strapi/strapi
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/strapi/strapi
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/strapi/strapi
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/strapi/strapi

### Stump

- Slug: stump
- URL: https://www.canagentsuse.com/tools/stump
- Website: https://www.stumpapp.dev
- Docs: https://github.com/stumpapp/stump
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Document Management - E-books
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted document management - e-books workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Rust. Source code: https://github.com/stumpapp/stump
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Stump is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/stumpapp/stump
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.stumpapp.dev
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/stumpapp/stump
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/stumpapp/stump
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/stumpapp/stump
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/stumpapp/stump

### Supysonic

- Slug: supysonic
- URL: https://www.canagentsuse.com/tools/supysonic
- Website: https://github.com/spl0k/supysonic
- Docs: https://github.com/spl0k/supysonic
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Media Streaming - Audio Streaming
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted media streaming - audio streaming workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python, deb. Source code: https://github.com/spl0k/supysonic
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Supysonic is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/spl0k/supysonic
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/spl0k/supysonic
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/spl0k/supysonic
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/spl0k/supysonic
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/spl0k/supysonic
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/spl0k/supysonic

### SwingMusic

- Slug: swingmusic
- URL: https://www.canagentsuse.com/tools/swingmusic
- Website: https://swingmusic.vercel.app/
- Docs: https://github.com/swingmx/swingmusic
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Media Streaming - Audio Streaming
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted media streaming - audio streaming workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python, Docker. Source code: https://github.com/swingmx/swingmusic
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

SwingMusic is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/swingmx/swingmusic
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://swingmusic.vercel.app/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/swingmx/swingmusic
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/swingmx/swingmusic
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/swingmx/swingmusic
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/swingmx/swingmusic

### Synapse

- Slug: synapse
- URL: https://www.canagentsuse.com/tools/synapse
- Website: https://element-hq.github.io/synapse/latest/index.html
- Docs: https://github.com/element-hq/synapse
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Communication - Custom Communication Systems
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - custom communication systems workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python, deb. Source code: https://github.com/element-hq/synapse
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Synapse is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/element-hq/synapse
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://element-hq.github.io/synapse/latest/index.html
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/element-hq/synapse
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/element-hq/synapse
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/element-hq/synapse
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/element-hq/synapse

### Syncloud

- Slug: syncloud
- URL: https://www.canagentsuse.com/tools/syncloud
- Website: https://syncloud.org/
- Docs: https://github.com/syncloud/platform
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Self-hosting Solutions
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted self-hosting solutions workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Shell. Source code: https://github.com/syncloud/platform
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Syncloud is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/syncloud/platform
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://syncloud.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/syncloud/platform
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/syncloud/platform
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/syncloud/platform
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/syncloud/platform

### TagSpaces

- Slug: tagspaces
- URL: https://www.canagentsuse.com/tools/tagspaces
- Website: https://www.tagspaces.org/
- Docs: https://github.com/tagspaces/tagspaces
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, File Transfer - Web-based File Managers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted file transfer - web-based file managers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs. Source code: https://github.com/tagspaces/tagspaces
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

TagSpaces is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/tagspaces/tagspaces
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.tagspaces.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/tagspaces/tagspaces
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/tagspaces/tagspaces
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/tagspaces/tagspaces
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/tagspaces/tagspaces

### Tasmota

- Slug: tasmota
- URL: https://www.canagentsuse.com/tools/tasmota
- Website: https://tasmota.com
- Docs: https://github.com/arendst/Tasmota
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Internet of Things (IoT)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted internet of things (iot) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C, C++. Source code: https://github.com/arendst/Tasmota
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Tasmota is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/arendst/Tasmota
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://tasmota.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/arendst/Tasmota
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/arendst/Tasmota
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/arendst/Tasmota
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/arendst/Tasmota

### Teampass

- Slug: teampass
- URL: https://www.canagentsuse.com/tools/teampass
- Website: https://teampass.net/
- Docs: https://github.com/nilsteampassnet/TeamPass
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Password Managers
- Use cases: Self-host a tool, Inspect open source, Triage work
- Best for: Self-hosted password managers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/nilsteampassnet/TeamPass
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Teampass is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/nilsteampassnet/TeamPass
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://teampass.net/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/nilsteampassnet/TeamPass
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/nilsteampassnet/TeamPass
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/nilsteampassnet/TeamPass
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/nilsteampassnet/TeamPass

### Technitium DNS Server

- Slug: technitium-dns-server
- URL: https://www.canagentsuse.com/tools/technitium-dns-server
- Website: https://technitium.com/dns/
- Docs: https://github.com/TechnitiumSoftware/DnsServer
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, DNS
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted dns workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, C#. Source code: https://github.com/TechnitiumSoftware/DnsServer
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Technitium DNS Server is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/TechnitiumSoftware/DnsServer
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://technitium.com/dns/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/TechnitiumSoftware/DnsServer
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/TechnitiumSoftware/DnsServer
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/TechnitiumSoftware/DnsServer
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/TechnitiumSoftware/DnsServer

### Teleport

- Slug: teleport
- URL: https://www.canagentsuse.com/tools/teleport
- Website: https://goteleport.com/
- Docs: https://github.com/gravitational/teleport
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Miscellaneous
- Use cases: Self-host a tool, Inspect open source, Triage work
- Best for: Self-hosted miscellaneous workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker, K8S. Source code: https://github.com/gravitational/teleport
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Teleport is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/gravitational/teleport
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://goteleport.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/gravitational/teleport
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/gravitational/teleport
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/gravitational/teleport
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/gravitational/teleport

### Tigase

- Slug: tigase
- URL: https://www.canagentsuse.com/tools/tigase
- Website: https://tigase.net/xmpp-server
- Docs: https://github.com/tigase/tigase-server
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Communication - XMPP - Servers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - xmpp - servers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Java. Source code: https://github.com/tigase/tigase-server
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Tigase is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/tigase/tigase-server
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://tigase.net/xmpp-server
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/tigase/tigase-server
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/tigase/tigase-server
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/tigase/tigase-server
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/tigase/tigase-server

### TileServer GL

- Slug: tileserver-gl
- URL: https://www.canagentsuse.com/tools/tileserver-gl
- Website: https://tileserver.readthedocs.io/
- Docs: https://github.com/maptiler/tileserver-gl
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Maps and Global Positioning System (GPS)
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted maps and global positioning system (gps) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as BSD-2-Clause; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/maptiler/tileserver-gl
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

TileServer GL is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/maptiler/tileserver-gl
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://tileserver.readthedocs.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/maptiler/tileserver-gl
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/maptiler/tileserver-gl
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/maptiler/tileserver-gl
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/maptiler/tileserver-gl

### Traefik

- Slug: traefik
- URL: https://www.canagentsuse.com/tools/traefik
- Website: https://traefik.io/
- Docs: https://github.com/traefik/traefik
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Web Servers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted web servers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker. Source code: https://github.com/traefik/traefik
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Traefik is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/traefik/traefik
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://traefik.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/traefik/traefik
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/traefik/traefik
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/traefik/traefik
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/traefik/traefik

### Traggo

- Slug: traggo
- URL: https://www.canagentsuse.com/tools/traggo
- Website: https://traggo.net/
- Docs: https://github.com/traggo/server
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Time Tracking
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted time tracking workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Go. Source code: https://github.com/traggo/server
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Traggo is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/traggo/server
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://traggo.net/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/traggo/server
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/traggo/server
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/traggo/server
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/traggo/server

### TrailBase

- Slug: trailbase
- URL: https://www.canagentsuse.com/tools/trailbase
- Website: https://trailbase.io/
- Docs: https://github.com/trailbaseio/trailbase
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Software Development - Low Code
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted software development - low code workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as OSL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Rust, Docker. Source code: https://github.com/trailbaseio/trailbase
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

TrailBase is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/trailbaseio/trailbase
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://trailbase.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/trailbaseio/trailbase
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/trailbaseio/trailbase
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/trailbaseio/trailbase
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/trailbaseio/trailbase

### tubesync

- Slug: tubesync
- URL: https://www.canagentsuse.com/tools/tubesync
- Website: https://github.com/meeb/tubesync
- Docs: https://github.com/meeb/tubesync
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Media Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted media management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Python. Source code: https://github.com/meeb/tubesync
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

tubesync is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/meeb/tubesync
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/meeb/tubesync
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/meeb/tubesync
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/meeb/tubesync
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/meeb/tubesync
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/meeb/tubesync

### tududi

- Slug: tududi
- URL: https://www.canagentsuse.com/tools/tududi
- Website: https://tududi.com/
- Docs: https://github.com/chrisvel/tududi
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Task Management & To-do Lists
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted task management & to-do lists workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/chrisvel/tududi
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

tududi is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/chrisvel/tududi
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://tududi.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/chrisvel/tududi
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/chrisvel/tududi
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/chrisvel/tududi
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/chrisvel/tududi

### Tuwunel

- Slug: tuwunel
- URL: https://www.canagentsuse.com/tools/tuwunel
- Website: https://tuwunel.chat
- Docs: https://github.com/matrix-construct/tuwunel
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Communication - Custom Communication Systems
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - custom communication systems workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: deb, Docker, Nix, Rust. Source code: https://github.com/matrix-construct/tuwunel
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Tuwunel is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/matrix-construct/tuwunel
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://tuwunel.chat
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/matrix-construct/tuwunel
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/matrix-construct/tuwunel
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/matrix-construct/tuwunel
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/matrix-construct/tuwunel

### Tyk

- Slug: tyk
- URL: https://www.canagentsuse.com/tools/tyk
- Website: https://tyk.io
- Docs: https://github.com/TykTechnologies/tyk
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Software Development - API Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Analyze product
- Best for: Self-hosted software development - api management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker, K8S. Source code: https://github.com/TykTechnologies/tyk
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Tyk is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/TykTechnologies/tyk
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://tyk.io
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/TykTechnologies/tyk
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/TykTechnologies/tyk
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/TykTechnologies/tyk
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/TykTechnologies/tyk

### UI Bakery

- Slug: ui-bakery
- URL: https://www.canagentsuse.com/tools/ui-bakery
- Website: https://uibakery.io
- Docs: https://github.com/uibakery/self-hosted
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Software Development - Low Code
- Use cases: Self-host a tool, Inspect open source, Triage work
- Best for: Self-hosted software development - low code workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as ⊘ Proprietary; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, K8S. Source code: https://github.com/uibakery/self-hosted
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

UI Bakery is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/uibakery/self-hosted
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://uibakery.io
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/uibakery/self-hosted
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/uibakery/self-hosted
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/uibakery/self-hosted
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/uibakery/self-hosted

### Umbrel

- Slug: umbrel
- URL: https://www.canagentsuse.com/tools/umbrel
- Website: https://umbrel.com/
- Docs: https://github.com/getumbrel/umbrel
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Self-hosting Solutions
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted self-hosting solutions workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as ⊘ Proprietary; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/getumbrel/umbrel
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Umbrel is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/getumbrel/umbrel
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://umbrel.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/getumbrel/umbrel
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/getumbrel/umbrel
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/getumbrel/umbrel
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/getumbrel/umbrel

### UnrealIRCd

- Slug: unrealircd
- URL: https://www.canagentsuse.com/tools/unrealircd
- Website: https://www.unrealircd.org/
- Docs: https://github.com/unrealircd/unrealircd
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Communication - IRC
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - irc workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C. Source code: https://github.com/unrealircd/unrealircd
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

UnrealIRCd is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/unrealircd/unrealircd
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.unrealircd.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/unrealircd/unrealircd
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/unrealircd/unrealircd
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/unrealircd/unrealircd
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/unrealircd/unrealircd

### UUSEC WAF

- Slug: uusec-waf
- URL: https://www.canagentsuse.com/tools/uusec-waf
- Website: https://waf.uusec.com/
- Docs: https://github.com/Safe3/uusec-waf
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Web Servers
- Use cases: Self-host a tool, Inspect open source, Analyze product
- Best for: Self-hosted web servers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C, Lua, Docker. Source code: https://github.com/Safe3/uusec-waf
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

UUSEC WAF is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/Safe3/uusec-waf
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://waf.uusec.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Safe3/uusec-waf
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Safe3/uusec-waf
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Safe3/uusec-waf
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Safe3/uusec-waf

### Vaultwarden

- Slug: vaultwarden
- URL: https://www.canagentsuse.com/tools/vaultwarden
- Website: https://github.com/dani-garcia/vaultwarden
- Docs: https://github.com/dani-garcia/vaultwarden
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Password Managers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted password managers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Rust, Docker. Source code: https://github.com/dani-garcia/vaultwarden
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Vaultwarden is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/dani-garcia/vaultwarden
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/dani-garcia/vaultwarden
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/dani-garcia/vaultwarden
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/dani-garcia/vaultwarden
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/dani-garcia/vaultwarden
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/dani-garcia/vaultwarden

### Wakapi

- Slug: wakapi
- URL: https://www.canagentsuse.com/tools/wakapi
- Website: https://wakapi.dev/
- Docs: https://github.com/muety/wakapi
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Time Tracking
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted time tracking workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker. Source code: https://github.com/muety/wakapi
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Wakapi is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/muety/wakapi
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://wakapi.dev/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/muety/wakapi
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/muety/wakapi
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/muety/wakapi
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/muety/wakapi

### wanderer

- Slug: wanderer
- URL: https://www.canagentsuse.com/tools/wanderer
- Website: https://github.com/open-wanderer/wanderer
- Docs: https://github.com/open-wanderer/wanderer
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Maps and Global Positioning System (GPS)
- Use cases: Self-host a tool, Inspect open source, Analyze product, Triage work
- Best for: Self-hosted maps and global positioning system (gps) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Go, Nodejs. Source code: https://github.com/open-wanderer/wanderer
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

wanderer is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/open-wanderer/wanderer
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/open-wanderer/wanderer
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/open-wanderer/wanderer
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/open-wanderer/wanderer
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/open-wanderer/wanderer
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/open-wanderer/wanderer

### Weblate

- Slug: weblate
- URL: https://www.canagentsuse.com/tools/weblate
- Website: https://weblate.org
- Docs: https://github.com/WeblateOrg/weblate
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Software Development - Localization
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted software development - localization workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python, Docker, K8S. Source code: https://github.com/WeblateOrg/weblate
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Weblate is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/WeblateOrg/weblate
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://weblate.org
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/WeblateOrg/weblate
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/WeblateOrg/weblate
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/WeblateOrg/weblate
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/WeblateOrg/weblate

### wger

- Slug: wger
- URL: https://www.canagentsuse.com/tools/wger
- Website: https://wger.de/
- Docs: https://github.com/wger-project/wger
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Health and Fitness
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Analyze product
- Best for: Self-hosted health and fitness workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python, Docker. Source code: https://github.com/wger-project/wger
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

wger is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/wger-project/wger
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://wger.de/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/wger-project/wger
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/wger-project/wger
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/wger-project/wger
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/wger-project/wger

### Wiki-Go

- Slug: wiki-go
- URL: https://www.canagentsuse.com/tools/wiki-go
- Website: https://leomoon.com/downloads/web-apps/wiki-go/
- Docs: https://github.com/leomoon-studios/wiki-go
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Wikis
- Use cases: Self-host a tool, Inspect open source, Publish content, Triage work
- Best for: Self-hosted wikis workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker. Source code: https://github.com/leomoon-studios/wiki-go
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Wiki-Go is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/leomoon-studios/wiki-go
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://leomoon.com/downloads/web-apps/wiki-go/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/leomoon-studios/wiki-go
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/leomoon-studios/wiki-go
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/leomoon-studios/wiki-go
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/leomoon-studios/wiki-go

### WikiDocs

- Slug: wikidocs
- URL: https://www.canagentsuse.com/tools/wikidocs
- Website: https://www.wikidocs.app/
- Docs: https://github.com/Zavy86/WikiDocs
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Wikis
- Use cases: Self-host a tool, Inspect open source, Publish content, Triage work
- Best for: Self-hosted wikis workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP, Docker. Source code: https://github.com/Zavy86/WikiDocs
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

WikiDocs is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/Zavy86/WikiDocs
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.wikidocs.app/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Zavy86/WikiDocs
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Zavy86/WikiDocs
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Zavy86/WikiDocs
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Zavy86/WikiDocs

### wildduck

- Slug: wildduck
- URL: https://www.canagentsuse.com/tools/wildduck
- Website: https://wildduck.email/
- Docs: https://github.com/zone-eu/wildduck
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Communication - Email - Complete Solutions
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - email - complete solutions workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as EUPL-1.2; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/zone-eu/wildduck
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

wildduck is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/zone-eu/wildduck
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://wildduck.email/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/zone-eu/wildduck
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/zone-eu/wildduck
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/zone-eu/wildduck
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/zone-eu/wildduck

### Xandikos

- Slug: xandikos
- URL: https://www.canagentsuse.com/tools/xandikos
- Website: https://github.com/jelmer/xandikos
- Docs: https://github.com/jelmer/xandikos
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Calendar & Contacts
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted calendar & contacts workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python, deb. Source code: https://github.com/jelmer/xandikos
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Xandikos is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/jelmer/xandikos
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/jelmer/xandikos
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/jelmer/xandikos
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/jelmer/xandikos
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/jelmer/xandikos
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/jelmer/xandikos

### xsrv

- Slug: xsrv
- URL: https://www.canagentsuse.com/tools/xsrv
- Website: https://xsrv.readthedocs.io/
- Docs: https://github.com/nodiscc/xsrv
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Self-hosting Solutions
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted self-hosting solutions workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Ansible, Shell. Source code: https://github.com/nodiscc/xsrv
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

xsrv is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/nodiscc/xsrv
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://xsrv.readthedocs.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/nodiscc/xsrv
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/nodiscc/xsrv
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/nodiscc/xsrv
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/nodiscc/xsrv

### Yacy

- Slug: yacy
- URL: https://www.canagentsuse.com/tools/yacy
- Website: https://yacy.net/en/index.html
- Docs: https://github.com/yacy/yacy_search_server
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Search Engines
- Use cases: Self-host a tool, Inspect open source, Triage work
- Best for: Self-hosted search engines workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Java, Docker, K8S. Source code: https://github.com/yacy/yacy_search_server
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Yacy is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/yacy/yacy_search_server
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://yacy.net/en/index.html
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/yacy/yacy_search_server
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/yacy/yacy_search_server
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/yacy/yacy_search_server
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/yacy/yacy_search_server

### Yarr

- Slug: yarr
- URL: https://www.canagentsuse.com/tools/yarr
- Website: https://github.com/nkanaev/yarr
- Docs: https://github.com/nkanaev/yarr
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Feed Readers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted feed readers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go. Source code: https://github.com/nkanaev/yarr
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Yarr is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/nkanaev/yarr
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/nkanaev/yarr
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/nkanaev/yarr
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/nkanaev/yarr
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/nkanaev/yarr
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/nkanaev/yarr

### ydl_api_ng

- Slug: ydl-api-ng
- URL: https://www.canagentsuse.com/tools/ydl-api-ng
- Website: https://github.com/Totonyus/ydl_api_ng
- Docs: https://github.com/Totonyus/ydl_api_ng
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Media Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted media management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python. Source code: https://github.com/Totonyus/ydl_api_ng
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

ydl_api_ng is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/Totonyus/ydl_api_ng
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/Totonyus/ydl_api_ng
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Totonyus/ydl_api_ng
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Totonyus/ydl_api_ng
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Totonyus/ydl_api_ng
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Totonyus/ydl_api_ng

### YOURLS

- Slug: yourls
- URL: https://www.canagentsuse.com/tools/yourls
- Website: https://yourls.org/
- Docs: https://github.com/YOURLS/YOURLS
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, URL Shorteners
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted url shorteners workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/YOURLS/YOURLS
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

YOURLS is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/YOURLS/YOURLS
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://yourls.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/YOURLS/YOURLS
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/YOURLS/YOURLS
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/YOURLS/YOURLS
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/YOURLS/YOURLS

### Youtarr

- Slug: youtarr
- URL: https://www.canagentsuse.com/tools/youtarr
- Website: https://github.com/DialmasterOrg/Youtarr
- Docs: https://github.com/DialmasterOrg/Youtarr
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Media Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Triage work
- Best for: Self-hosted media management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as ISC; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/DialmasterOrg/Youtarr
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Youtarr is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/DialmasterOrg/Youtarr
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/DialmasterOrg/Youtarr
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/DialmasterOrg/Youtarr
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/DialmasterOrg/Youtarr
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/DialmasterOrg/Youtarr
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/DialmasterOrg/Youtarr

### YoutubeDL-Server

- Slug: youtubedl-server
- URL: https://www.canagentsuse.com/tools/youtubedl-server
- Website: https://github.com/nbr23/youtube-dl-server
- Docs: https://github.com/nbr23/youtube-dl-server
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Media Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted media management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python, Docker. Source code: https://github.com/nbr23/youtube-dl-server
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

YoutubeDL-Server is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/nbr23/youtube-dl-server
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/nbr23/youtube-dl-server
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/nbr23/youtube-dl-server
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/nbr23/youtube-dl-server
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/nbr23/youtube-dl-server
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/nbr23/youtube-dl-server

### Zenko CloudServer

- Slug: zenko-cloudserver
- URL: https://www.canagentsuse.com/tools/zenko-cloudserver
- Website: https://www.zenko.io/cloudserver
- Docs: https://github.com/scality/cloudserver
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, File Transfer - Object Storage & File Servers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted file transfer - object storage & file servers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Nodejs. Source code: https://github.com/scality/cloudserver
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Zenko CloudServer is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/scality/cloudserver
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.zenko.io/cloudserver
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/scality/cloudserver
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/scality/cloudserver
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/scality/cloudserver
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/scality/cloudserver

### Zoraxy

- Slug: zoraxy
- URL: https://www.canagentsuse.com/tools/zoraxy
- Website: https://zoraxy.aroz.org/
- Docs: https://github.com/tobychui/zoraxy
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Web Servers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted web servers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker. Source code: https://github.com/tobychui/zoraxy
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Zoraxy is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/tobychui/zoraxy
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://zoraxy.aroz.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/tobychui/zoraxy
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/tobychui/zoraxy
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/tobychui/zoraxy
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/tobychui/zoraxy

### ZOT OCI Registry

- Slug: zot-oci-registry
- URL: https://www.canagentsuse.com/tools/zot-oci-registry
- Website: https://zotregistry.dev
- Docs: https://github.com/project-zot/zot
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, File Transfer - Object Storage & File Servers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted file transfer - object storage & file servers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker. Source code: https://github.com/project-zot/zot
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

ZOT OCI Registry is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/project-zot/zot
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://zotregistry.dev
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/project-zot/zot
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/project-zot/zot
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/project-zot/zot
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/project-zot/zot

### µStreamer

- Slug: streamer
- URL: https://www.canagentsuse.com/tools/streamer
- Website: https://github.com/pikvm/ustreamer
- Docs: https://github.com/pikvm/ustreamer
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Media Streaming - Multimedia Streaming
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted media streaming - multimedia streaming workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C, deb. Source code: https://github.com/pikvm/ustreamer
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

µStreamer is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/pikvm/ustreamer
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/pikvm/ustreamer
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/pikvm/ustreamer
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/pikvm/ustreamer
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/pikvm/ustreamer
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/pikvm/ustreamer

### µTask

- Slug: task
- URL: https://www.canagentsuse.com/tools/task
- Website: https://github.com/ovh/utask
- Docs: https://github.com/ovh/utask
- Agent score: 64
- Agent tier: Usable
- Categories: Self-hosted, Automation
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted automation workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as BSD-3-Clause; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker. Source code: https://github.com/ovh/utask
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

µTask is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 9/25
- Agent safety: 20.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 8.8/15

Capabilities:
- API: partial. Metadata suggests an API, server, integration, or automation surface; verify exact endpoints in project docs. Evidence: https://github.com/ovh/utask
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/ovh/utask
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/ovh/utask
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/ovh/utask
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/ovh/utask
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/ovh/utask

### Cloudinary

- Slug: cloudinary
- URL: https://www.canagentsuse.com/tools/cloudinary
- Website: https://cloudinary.com
- Docs: https://cloudinary.com/documentation
- Agent score: 63
- Agent tier: Usable
- Categories: Design & media, Databases & storage
- Use cases: Manage media, Publish content
- Best for: Image uploads, transformations, optimization, DAM operations, and generated media pipelines.
- Limitations: Key limitations: Bulk deletes, asset overwrites, and signed transformations need review. Schema changes, migrations, deletes, backups, row-level security, and retention policies need explicit review before agents touch production data. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Public pricing based on credits, transformations, bandwidth, and storage.
- Auth: API key/secret, signed upload presets, unsigned presets, and restricted transformations.
- Account creation: Self-serve signup with free tier.
- Browser support: Console helps inspect assets, transformations, usage, and presets.
- CLI: Not listed
- API base: https://api.cloudinary.com/v1_1
- MCP server: Not listed

Agents can upload, transform, tag, search, organize, and deliver media assets with well-documented APIs.

Score breakdown:
- Machine operability: 14/25
- Agent safety: 10.4/25
- Agent readability: 17.4/20
- Auth and setup: 12/15
- Production reliability: 9.4/15

Capabilities:
- API: native. Upload and Admin APIs support file upload, tagging, search, updates, transformations, and bulk deletion. Evidence: https://cloudinary.com/documentation/image_upload_api_reference
- Browser: strong. Console helps inspect assets, transformations, usage, and presets. Evidence: https://cloudinary.com
- Account creation: strong. Self-serve signup with free tier. Evidence: https://cloudinary.com
- Pricing clarity: strong. Pricing is public by plan and credit usage. Evidence: https://cloudinary.com/pricing
- Docs quality: strong. Docs include API references, SDKs, transformation guides, and upload security. Evidence: https://cloudinary.com/documentation

### Cohere

- Slug: cohere
- URL: https://www.canagentsuse.com/tools/cohere
- Website: https://cohere.com
- Docs: https://docs.cohere.com
- Agent score: 63
- Agent tier: Usable
- Categories: AI models, Search & RAG
- Use cases: Call models, Build RAG
- Best for: Embeddings, reranking, enterprise search, and retrieval-augmented generation.
- Limitations: Key limitations: RAG agents should monitor source grounding, latency, and per-model pricing. Model behavior, costs, rate limits, data retention, and safety policies can change by model and account tier; use evals, spend caps, and data controls for sensitive workloads. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Public model pricing and trial information.
- Auth: API keys with dashboard management.
- Account creation: Self-serve signup for API keys.
- Browser support: Dashboard supports keys, playground, and usage checks.
- CLI: Not listed
- API base: https://api.cohere.com
- MCP server: Not listed

Good for agents that need strong RAG primitives like embeddings and reranking with clear API references.

Score breakdown:
- Machine operability: 14/25
- Agent safety: 10.4/25
- Agent readability: 17.4/20
- Auth and setup: 12/15
- Production reliability: 9.4/15

Capabilities:
- API: native. Reference docs cover chat, embed, rerank, classify, and datasets. Evidence: https://docs.cohere.com/reference/about
- Browser: strong. Dashboard supports keys, playground, and usage checks. Evidence: https://cohere.com
- Account creation: strong. Self-serve signup for API keys. Evidence: https://cohere.com
- Pricing clarity: strong. Pricing is public by model family and operation. Evidence: https://cohere.com/pricing
- Docs quality: strong. Docs are structured around common RAG and model workflows. Evidence: https://docs.cohere.com

### Google Gemini API

- Slug: google-gemini
- URL: https://www.canagentsuse.com/tools/google-gemini
- Website: https://ai.google.dev
- Docs: https://ai.google.dev/gemini-api/docs
- Agent score: 63
- Agent tier: Usable
- Categories: AI models
- Use cases: Call models, Build RAG
- Best for: Multimodal model calls, embeddings, structured output, and Google AI Studio prototypes.
- Limitations: Key limitations: Production use needs model/version pinning, quota checks, and privacy review. Model behavior, costs, rate limits, data retention, and safety policies can change by model and account tier; use evals, spend caps, and data controls for sensitive workloads. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Public Gemini API pricing and free-tier/paid-tier concepts.
- Auth: API keys and Google Cloud project-based auth depending on surface.
- Account creation: Self-serve Google AI Studio or Google Cloud setup.
- Browser support: AI Studio is helpful for prompt prototyping and key management.
- CLI: Not listed
- API base: https://generativelanguage.googleapis.com
- MCP server: Not listed

Useful for agents that need a Google-backed model API with SDKs, structured outputs, and multimodal capabilities.

Score breakdown:
- Machine operability: 14/25
- Agent safety: 10.4/25
- Agent readability: 17.4/20
- Auth and setup: 12/15
- Production reliability: 9.4/15

Capabilities:
- API: native. Gemini API docs cover models, embeddings, files, structured output, and context caching. Evidence: https://ai.google.dev/gemini-api/docs
- Browser: strong. AI Studio is helpful for prompt prototyping and key management. Evidence: https://ai.google.dev
- Account creation: strong. Self-serve Google AI Studio or Google Cloud setup. Evidence: https://ai.google.dev
- Pricing clarity: strong. Gemini API pricing is public. Evidence: https://ai.google.dev/gemini-api/docs/pricing
- Docs quality: strong. Docs include SDK examples and API concepts for agent integration. Evidence: https://ai.google.dev/gemini-api/docs/api-key

### Notion

- Slug: notion
- URL: https://www.canagentsuse.com/tools/notion
- Website: https://www.notion.so
- Docs: https://developers.notion.com
- Agent score: 63
- Agent tier: Usable
- Categories: Project workflows
- Use cases: Publish content, Triage work
- Best for: Knowledge bases, content operations, lightweight CRMs, and docs automation.
- Limitations: Key limitations: Permission setup and page sharing rules are easy to get wrong. Project, CRM, document, and spreadsheet writes depend on team context and privacy rules; require least-privilege scopes and review for workflow-changing actions. MCP servers inherit the connected account's scopes and may send prompts or data to third-party services; configure read-only or narrow scopes when available. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging.
- Pricing: Public seat-based pricing with free and team plans.
- Auth: Internal integrations, OAuth, page/database sharing, and hosted Notion MCP OAuth.
- Account creation: Self-serve workspace signup.
- Browser support: Browser UI is central for database design and permissions.
- CLI: Not listed
- API base: https://api.notion.com
- MCP server: https://mcp.notion.com/mcp

Agents can update structured docs and databases through the API, and use Notion MCP for OAuth-based read/write workspace access in supported clients.

Score breakdown:
- Machine operability: 18/25
- Agent safety: 9.2/25
- Agent readability: 17.4/20
- Auth and setup: 12/15
- Production reliability: 6.4/15

Capabilities:
- API: native. API supports pages, databases, blocks, users, and comments. Evidence: https://developers.notion.com
- MCP: native. Notion's hosted MCP server supports OAuth-based read and write access to Notion pages and workspaces for compatible agents. Evidence: https://developers.notion.com/guides/mcp/get-started-with-mcp
- Browser: strong. Workspace permissions and content layout are easier in browser. Evidence: https://developers.notion.com
- Account creation: strong. Self-serve workspace signup. Evidence: https://www.notion.so
- Pricing clarity: strong. Public seat-based pricing with free and team plans. Evidence: https://www.notion.so/pricing
- Docs quality: strong. API docs are readable and example-oriented. Evidence: https://developers.notion.com

### Pinecone

- Slug: pinecone
- URL: https://www.canagentsuse.com/tools/pinecone
- Website: https://www.pinecone.io
- Docs: https://docs.pinecone.io
- Agent score: 63
- Agent tier: Usable
- Categories: Search & RAG, Databases & storage
- Use cases: Build RAG, Extract web data
- Best for: Hosted vector search, RAG indexes, embeddings, and semantic retrieval.
- Limitations: Key limitations: Agents should manage namespace isolation, deletion safety, and embedding model compatibility. Schema changes, migrations, deletes, backups, row-level security, and retention policies need explicit review before agents touch production data. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Public pricing for serverless, pod-based, storage, and inference usage.
- Auth: API keys and project/environment scoping.
- Account creation: Self-serve signup with free starter concepts.
- Browser support: Console supports index management and usage review.
- CLI: Not listed
- API base: https://api.pinecone.io
- MCP server: Not listed

Agents can create indexes, upsert vectors or text, query semantic search, and inspect usage through documented APIs.

Score breakdown:
- Machine operability: 14/25
- Agent safety: 10.4/25
- Agent readability: 17.4/20
- Auth and setup: 12/15
- Production reliability: 8.8/15

Capabilities:
- API: native. API reference covers indexes, vectors, search, backups, and inference. Evidence: https://docs.pinecone.io/docs/api-reference
- Browser: strong. Console supports index management and usage review. Evidence: https://www.pinecone.io
- Account creation: strong. Self-serve signup with free starter concepts. Evidence: https://www.pinecone.io
- Pricing clarity: strong. Pricing is public with usage and plan dimensions. Evidence: https://www.pinecone.io/pricing/
- Docs quality: strong. Docs are organized around RAG, search, and index operations. Evidence: https://docs.pinecone.io

### Twilio Segment

- Slug: segment
- URL: https://www.canagentsuse.com/tools/segment
- Website: https://segment.com
- Docs: https://segment.com/docs
- Agent score: 63
- Agent tier: Usable
- Categories: Analytics & product, Automation & integrations
- Use cases: Analyze product, Sync CRM
- Best for: Event pipelines, CDP workflows, analytics routing, and customer profile data.
- Limitations: Key limitations: Customer data, PII, and destination fanout require governance and approval. Verify official docs, pricing, rate limits, permissions, and production side effects before delegating account-changing actions to an agent. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Account setup or elevated access may require vendor, admin, or compliance approval before an agent can operate independently.
- Pricing: Public plan pricing, often MTU/event-volume based.
- Auth: Write keys, OAuth/API tokens, workspace permissions, source/destination credentials.
- Account creation: Self-serve signup or sales-assisted plans.
- Browser support: Workspace UI is central for schema, destination, and debugger review.
- CLI: Not listed
- API base: https://api.segmentapis.com
- MCP server: Not listed

Agents can send events, inspect schemas, and manage customer data pipelines when PII and governance controls are clear.

Score breakdown:
- Machine operability: 15/25
- Agent safety: 9.2/25
- Agent readability: 15.9/20
- Auth and setup: 12/15
- Production reliability: 11/15

Capabilities:
- API: native. Segment APIs cover tracking, workspace config, sources, destinations, and profiles. Evidence: https://segment.com/docs/api/
- Browser: native. Workspace UI is central for schema, destination, and debugger review. Evidence: https://segment.com
- Account creation: strong. Self-serve signup or sales-assisted plans. Evidence: https://segment.com
- Pricing clarity: partial. Pricing is public at high level, with usage and plan details varying. Evidence: https://segment.com/pricing/
- Docs quality: strong. Docs include tracking APIs, destination docs, Protocols, and Personas/Profiles concepts. Evidence: https://segment.com/docs/

### Amplitude

- Slug: amplitude
- URL: https://www.canagentsuse.com/tools/amplitude
- Website: https://amplitude.com
- Docs: https://amplitude.com/docs
- Agent score: 62
- Agent tier: Usable
- Categories: Analytics & product
- Use cases: Analyze product
- Best for: Product analytics, cohorts, event pipelines, experiments, and usage reporting.
- Limitations: Key limitations: Analytics data can include PII; data governance and read/write scopes need review. Verify official docs, pricing, rate limits, permissions, and production side effects before delegating account-changing actions to an agent. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Account setup or elevated access may require vendor, admin, or compliance approval before an agent can operate independently.
- Pricing: Public plan pricing with usage and feature limits.
- Auth: API keys, secret keys, management API keys, OAuth for some integrations.
- Account creation: Self-serve signup and sales-assisted plans.
- Browser support: Dashboard is essential for chart and cohort review.
- CLI: Not listed
- API base: https://amplitude.com/api
- MCP server: Not listed

Agents can upload events, export cohorts, and inspect product analytics with scoped keys and privacy controls.

Score breakdown:
- Machine operability: 14/25
- Agent safety: 9.2/25
- Agent readability: 15.9/20
- Auth and setup: 12/15
- Production reliability: 11/15

Capabilities:
- API: native. Analytics APIs include event upload, cohorts, annotations, exports, dashboards, and management APIs. Evidence: https://amplitude.com/docs/apis
- Browser: strong. Dashboard is essential for chart and cohort review. Evidence: https://amplitude.com
- Account creation: strong. Self-serve signup and sales-assisted plans. Evidence: https://amplitude.com
- Pricing clarity: partial. Pricing is public by plan but enterprise usage can vary. Evidence: https://amplitude.com/pricing
- Docs quality: strong. Docs cover analytics, APIs, SDKs, experiments, and data governance. Evidence: https://amplitude.com/docs

### Exa

- Slug: exa
- URL: https://www.canagentsuse.com/tools/exa
- Website: https://exa.ai
- Docs: https://docs.exa.ai
- Agent score: 62
- Agent tier: Usable
- Categories: Scraping & content
- Use cases: Extract web data, Triage work
- Best for: Research, web retrieval, content discovery, and RAG pipelines.
- Limitations: Key limitations: Search results still need source evaluation and citation hygiene. Respect robots.txt, site terms, rate limits, copyright, authentication boundaries, and anti-bot controls before asking an agent to crawl or extract content. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Public API pricing with free trial and usage-based tiers.
- Auth: API key.
- Account creation: Self-serve signup.
- Browser support: Dashboard mainly supports API keys and usage.
- CLI: Not listed
- API base: https://api.exa.ai
- MCP server: Not listed

Useful when agents need semantically relevant web results and page contents without generic scraping setup.

Score breakdown:
- Machine operability: 14/25
- Agent safety: 10.4/25
- Agent readability: 17.4/20
- Auth and setup: 10.5/15
- Production reliability: 9.4/15

Capabilities:
- API: native. Search, find similar, and content endpoints support agent research. Evidence: https://docs.exa.ai
- Browser: strong. Dashboard mainly supports API keys and usage. Evidence: https://exa.ai
- Account creation: strong. Self-serve signup. Evidence: https://exa.ai
- Pricing clarity: strong. Usage tiers are visible before integration. Evidence: https://docs.exa.ai
- Docs quality: strong. Docs are compact and API-focused. Evidence: https://docs.exa.ai

### Groq

- Slug: groq
- URL: https://www.canagentsuse.com/tools/groq
- Website: https://groq.com
- Docs: https://console.groq.com/docs
- Agent score: 62
- Agent tier: Usable
- Categories: AI models
- Use cases: Call models
- Best for: Low-latency inference, chat completions, transcription, and model experiments.
- Limitations: Key limitations: Agents should monitor model availability, rate limits, and non-deterministic outputs. Model behavior, costs, rate limits, data retention, and safety policies can change by model and account tier; use evals, spend caps, and data controls for sensitive workloads. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Public model pricing and free developer limits.
- Auth: API keys.
- Account creation: Self-serve console signup.
- Browser support: Console supports keys, docs, and usage.
- CLI: Not listed
- API base: https://api.groq.com/openai/v1
- MCP server: Not listed

Useful for agents that need very low-latency model calls with a simple API surface.

Score breakdown:
- Machine operability: 14/25
- Agent safety: 10.4/25
- Agent readability: 17.4/20
- Auth and setup: 10.5/15
- Production reliability: 10/15

Capabilities:
- API: native. OpenAI-compatible API reference covers chat and audio endpoints. Evidence: https://console.groq.com/docs/api-reference
- Browser: strong. Console supports keys, docs, and usage. Evidence: https://groq.com
- Account creation: strong. Self-serve console signup. Evidence: https://groq.com
- Pricing clarity: strong. Pricing is public by model. Evidence: https://groq.com/pricing/
- Docs quality: strong. Docs include quickstarts, rate limits, and model pages. Evidence: https://console.groq.com/docs

### Together AI

- Slug: together-ai
- URL: https://www.canagentsuse.com/tools/together-ai
- Website: https://www.together.ai
- Docs: https://docs.together.ai
- Agent score: 62
- Agent tier: Usable
- Categories: AI models
- Use cases: Call models
- Best for: Open model inference, model comparison, embeddings, and fine-tuning workflows.
- Limitations: Key limitations: Agents should pin model IDs and handle model-specific rate limits and output variance. Model behavior, costs, rate limits, data retention, and safety policies can change by model and account tier; use evals, spend caps, and data controls for sensitive workloads. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Public per-model serverless pricing and dedicated endpoint pricing.
- Auth: API keys.
- Account creation: Self-serve signup with free credits and paid usage.
- Browser support: Dashboard supports keys, model catalog, and usage.
- CLI: Not listed
- API base: https://api.together.xyz/v1
- MCP server: Not listed

Useful when agents need access to many open models through a single API with clear serverless pricing.

Score breakdown:
- Machine operability: 14/25
- Agent safety: 10.4/25
- Agent readability: 17.4/20
- Auth and setup: 10.5/15
- Production reliability: 10/15

Capabilities:
- API: native. REST inference docs include OpenAI-compatible chat and completions. Evidence: https://docs.together.ai/docs/inference-rest
- Browser: strong. Dashboard supports keys, model catalog, and usage. Evidence: https://www.together.ai
- Account creation: strong. Self-serve signup with free credits and paid usage. Evidence: https://www.together.ai
- Pricing clarity: strong. Serverless model pricing is public. Evidence: https://docs.together.ai/docs/serverless/models
- Docs quality: strong. Docs include API, SDK, and model catalog guidance. Evidence: https://docs.together.ai

### UploadThing

- Slug: uploadthing
- URL: https://www.canagentsuse.com/tools/uploadthing
- Website: https://uploadthing.com
- Docs: https://docs.uploadthing.com
- Agent score: 61
- Agent tier: Usable
- Categories: Design & media, Databases & storage
- Use cases: Manage media, Ship an app
- Best for: App file uploads, image attachment flows, and developer-friendly media ingestion.
- Limitations: Key limitations: File access rules, malware scanning needs, and deletion policies need product review. Schema changes, migrations, deletes, backups, row-level security, and retention policies need explicit review before agents touch production data. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Public storage/bandwidth pricing with free tier.
- Auth: API keys, app IDs, server-side route auth, and callback validation.
- Account creation: Self-serve signup.
- Browser support: Dashboard supports apps, files, keys, and usage.
- CLI: Not listed
- API base: https://api.uploadthing.com
- MCP server: Not listed

Agents can wire app uploads quickly in supported frameworks and inspect upload routes and file metadata.

Score breakdown:
- Machine operability: 12/25
- Agent safety: 10.4/25
- Agent readability: 17.4/20
- Auth and setup: 12/15
- Production reliability: 8.8/15

Capabilities:
- API: strong. Docs cover server SDKs, file routes, callbacks, ACLs, and upload APIs. Evidence: https://docs.uploadthing.com
- Browser: strong. Dashboard supports apps, files, keys, and usage. Evidence: https://uploadthing.com
- Account creation: strong. Self-serve signup. Evidence: https://uploadthing.com
- Pricing clarity: strong. Pricing is public by storage and bandwidth. Evidence: https://uploadthing.com/pricing
- Docs quality: strong. Docs are compact and framework-oriented. Evidence: https://docs.uploadthing.com

### Zapier

- Slug: zapier
- URL: https://www.canagentsuse.com/tools/zapier
- Website: https://zapier.com
- Docs: https://docs.zapier.com
- Agent score: 61
- Agent tier: Usable
- Categories: Automation & integrations
- Use cases: Triage work, Publish content, Sync CRM
- Best for: Cross-app automations, long-tail SaaS integrations, and workflow prototyping.
- Limitations: Key limitations: Zapier can mutate many external systems; use allowlists, approval gates, and least-privilege connections. Verify official docs, pricing, rate limits, permissions, and production side effects before delegating account-changing actions to an agent. MCP servers inherit the connected account's scopes and may send prompts or data to third-party services; configure read-only or narrow scopes when available. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials.
- Pricing: Public task-based pricing with free and paid plans.
- Auth: Zapier account auth, connected app OAuth, per-server tool configuration, and MCP client auth.
- Account creation: Self-serve signup.
- Browser support: Editor UI is important for reviewing actions and connections.
- CLI: zapier
- API base: Not listed
- MCP server: https://mcp.zapier.com

Agents can trigger broad SaaS actions through curated Zapier connectors, which is powerful but needs strict action review.

Score breakdown:
- Machine operability: 12.8/25
- Agent safety: 16.2/25
- Agent readability: 17.4/20
- Auth and setup: 12/15
- Production reliability: 3/15

Capabilities:
- CLI: strong. Zapier SDK CLI supports custom integrations and API requests. Evidence: https://docs.zapier.com/sdk/cli-reference
- MCP: native. Zapier MCP connects agents to thousands of app integrations and user-configured actions through Zapier-managed authentication. Evidence: https://docs.zapier.com/mcp/home
- Browser: strong. Editor UI is important for reviewing actions and connections. Evidence: https://zapier.com
- Account creation: strong. Self-serve signup. Evidence: https://zapier.com
- Pricing clarity: strong. Task and plan pricing are public. Evidence: https://zapier.com/pricing
- Docs quality: strong. Docs include SDK, CLI, app building, and AI/MCP guidance. Evidence: https://docs.zapier.com/
- Sandbox: partial. The tool has documented test, local, preview, self-hosted, or staging paths that let agents validate changes away from production. Evidence: https://docs.zapier.com

### Resend

- Slug: resend
- URL: https://www.canagentsuse.com/tools/resend
- Website: https://resend.com
- Docs: https://resend.com/docs
- Agent score: 60
- Agent tier: Usable
- Categories: Email & messaging
- Use cases: Publish content, Ship an app
- Best for: Transactional email, onboarding emails, and product notifications.
- Limitations: Key limitations: Domain verification and deliverability settings are human-sensitive. Outbound messages, SMS, email deliverability, consent, unsubscribe behavior, private chats, and customer-facing replies need approval, throttling, and audit logs. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Account setup or elevated access may require vendor, admin, or compliance approval before an agent can operate independently.
- Pricing: Public pricing with free and paid email volume tiers.
- Auth: API keys and domain verification.
- Account creation: Self-serve signup.
- Browser support: Dashboard helps with API keys, domains, logs, and broadcasts.
- CLI: Not listed
- API base: https://api.resend.com
- MCP server: Not listed

Good for agents that need to wire transactional email and inspect delivery paths quickly.

Score breakdown:
- Machine operability: 14/25
- Agent safety: 4.4/25
- Agent readability: 19/20
- Auth and setup: 12/15
- Production reliability: 10.4/15

Capabilities:
- API: native. Email send, audiences, contacts, domains, and API keys are documented. Evidence: https://resend.com/docs
- Browser: strong. Dashboard is useful for logs and domain setup. Evidence: https://resend.com/docs
- Account creation: strong. Self-serve signup. Evidence: https://resend.com
- Pricing clarity: strong. Volume pricing is easy to inspect. Evidence: https://resend.com/docs
- Docs quality: native. Official docs are listed for API behavior, authentication, limits, examples, and setup review. Evidence: https://resend.com/docs

### Clerk

- Slug: clerk
- URL: https://www.canagentsuse.com/tools/clerk
- Website: https://clerk.com
- Docs: https://clerk.com/docs
- Agent score: 59
- Agent tier: Usable
- Categories: Auth & accounts
- Use cases: Manage users, Ship an app
- Best for: User signup, login, organizations, and app auth surfaces.
- Limitations: Key limitations: Security, redirect URLs, and provider credentials should be human-reviewed. Identity configuration, redirect URLs, provider credentials, user lifecycle actions, and permission scopes can lock users out or expose accounts if automated without review. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Public MAU-based pricing with free and paid tiers.
- Auth: Secret keys, publishable keys, JWT/session auth, OAuth providers.
- Account creation: Self-serve signup.
- Browser support: Dashboard is important for instance configuration.
- CLI: Not listed
- API base: https://api.clerk.com
- MCP server: Not listed

Agents can wire auth into frameworks quickly, but provider setup and production auth settings need review.

Score breakdown:
- Machine operability: 14/25
- Agent safety: 9.2/25
- Agent readability: 17.4/20
- Auth and setup: 12/15
- Production reliability: 6.4/15

Capabilities:
- API: native. Backend API and SDKs support users, organizations, sessions, and invitations. Evidence: https://clerk.com/docs
- Browser: strong. Dashboard configuration is often required. Evidence: https://clerk.com/docs
- Account creation: strong. Self-serve signup. Evidence: https://clerk.com
- Pricing clarity: strong. Public MAU-based pricing with free and paid tiers. Evidence: https://clerk.com/pricing
- Docs quality: strong. Framework guides are practical for agents wiring apps. Evidence: https://clerk.com/docs

### Mailgun

- Slug: mailgun
- URL: https://www.canagentsuse.com/tools/mailgun
- Website: https://www.mailgun.com
- Docs: https://documentation.mailgun.com
- Agent score: 57
- Agent tier: Usable
- Categories: Email & messaging
- Use cases: Publish content
- Best for: Transactional email, inbound routes, email validation, and delivery analytics.
- Limitations: Key limitations: Sender reputation, compliance, and bulk sends need approval and throttling. Outbound messages, SMS, email deliverability, consent, unsubscribe behavior, private chats, and customer-facing replies need approval, throttling, and audit logs. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Account setup or elevated access may require vendor, admin, or compliance approval before an agent can operate independently.
- Pricing: Public monthly and usage-based email pricing.
- Auth: API keys, domain credentials, webhooks, and signatures.
- Account creation: Self-serve signup with domain verification.
- Browser support: Control panel is useful for domain setup, logs, and deliverability review.
- CLI: Not listed
- API base: https://api.mailgun.net/v3
- MCP server: Not listed

Agents can send and inspect email delivery flows through API endpoints with clear domain and event concepts.

Score breakdown:
- Machine operability: 12.5/25
- Agent safety: 4.4/25
- Agent readability: 17.4/20
- Auth and setup: 12/15
- Production reliability: 10.4/15

Capabilities:
- API: native. Mailgun API is documented with OpenAPI and covers messages, domains, events, routes, and keys. Evidence: https://documentation.mailgun.com/docs/mailgun/api-reference/send/mailgun/messages
- Browser: partial. Control panel is useful for domain setup, logs, and deliverability review. Evidence: https://www.mailgun.com
- Account creation: strong. Self-serve signup with domain verification. Evidence: https://www.mailgun.com
- Pricing clarity: strong. Pricing is public by monthly volume and features. Evidence: https://www.mailgun.com/pricing/
- Docs quality: strong. Docs include API reference, SDKs, webhooks, and deliverability guidance. Evidence: https://documentation.mailgun.com

### Alf.io

- Slug: alf-io
- URL: https://www.canagentsuse.com/tools/alf-io
- Website: https://alf.io/
- Docs: https://github.com/alfio-event/alf.io
- Agent score: 56
- Agent tier: Usable
- Categories: Self-hosted, Booking and Scheduling
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted booking and scheduling workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Java. Source code: https://github.com/alfio-event/alf.io
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Alf.io is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 6.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://alf.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/alfio-event/alf.io
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/alfio-event/alf.io
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/alfio-event/alf.io
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/alfio-event/alf.io

### Bitpoll

- Slug: bitpoll
- URL: https://www.canagentsuse.com/tools/bitpoll
- Website: https://github.com/fsinfuhh/Bitpoll
- Docs: https://github.com/fsinfuhh/Bitpoll
- Agent score: 56
- Agent tier: Usable
- Categories: Self-hosted, Polls and Events
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted polls and events workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Python. Source code: https://github.com/fsinfuhh/Bitpoll
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Bitpoll is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 6.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/fsinfuhh/Bitpoll
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/fsinfuhh/Bitpoll
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/fsinfuhh/Bitpoll
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/fsinfuhh/Bitpoll
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/fsinfuhh/Bitpoll

### Bracket

- Slug: bracket
- URL: https://www.canagentsuse.com/tools/bracket
- Website: https://docs.bracketapp.nl/
- Docs: https://github.com/evroon/bracket
- Agent score: 56
- Agent tier: Usable
- Categories: Self-hosted, Polls and Events
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted polls and events workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Nodejs. Source code: https://github.com/evroon/bracket
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Bracket is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 6.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://docs.bracketapp.nl/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/evroon/bracket
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/evroon/bracket
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/evroon/bracket
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/evroon/bracket

### Christmas Community

- Slug: christmas-community
- URL: https://www.canagentsuse.com/tools/christmas-community
- Website: https://github.com/Wingysam/Christmas-Community
- Docs: https://github.com/Wingysam/Christmas-Community
- Agent score: 56
- Agent tier: Usable
- Categories: Self-hosted, Polls and Events
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted polls and events workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Nodejs. Source code: https://github.com/Wingysam/Christmas-Community
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Christmas Community is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 6.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/Wingysam/Christmas-Community
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Wingysam/Christmas-Community
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Wingysam/Christmas-Community
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Wingysam/Christmas-Community
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Wingysam/Christmas-Community

### Claper

- Slug: claper
- URL: https://www.canagentsuse.com/tools/claper
- Website: https://claper.co/
- Docs: https://github.com/ClaperCo/Claper
- Agent score: 56
- Agent tier: Usable
- Categories: Self-hosted, Polls and Events
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted polls and events workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Elixir, Docker. Source code: https://github.com/ClaperCo/Claper
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Claper is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 6.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://claper.co/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/ClaperCo/Claper
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/ClaperCo/Claper
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/ClaperCo/Claper
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/ClaperCo/Claper

### ClearFlask

- Slug: clearflask
- URL: https://www.canagentsuse.com/tools/clearflask
- Website: https://clearflask.com
- Docs: https://github.com/clearflask/clearflask
- Agent score: 56
- Agent tier: Usable
- Categories: Self-hosted, Polls and Events
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted polls and events workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/clearflask/clearflask
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

ClearFlask is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 6.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://clearflask.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/clearflask/clearflask
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/clearflask/clearflask
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/clearflask/clearflask
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/clearflask/clearflask

### docassemble

- Slug: docassemble
- URL: https://www.canagentsuse.com/tools/docassemble
- Website: https://docassemble.org/
- Docs: https://github.com/jhpyle/docassemble
- Agent score: 56
- Agent tier: Usable
- Categories: Self-hosted, Polls and Events
- Use cases: Self-host a tool, Inspect open source, Publish content
- Best for: Self-hosted polls and events workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Python. Source code: https://github.com/jhpyle/docassemble
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

docassemble is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 6.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://docassemble.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/jhpyle/docassemble
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/jhpyle/docassemble
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/jhpyle/docassemble
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/jhpyle/docassemble

### Fider

- Slug: fider
- URL: https://www.canagentsuse.com/tools/fider
- Website: https://fider.io
- Docs: https://github.com/getfider/fider
- Agent score: 56
- Agent tier: Usable
- Categories: Self-hosted, Polls and Events
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted polls and events workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/getfider/fider
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Fider is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 6.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://fider.io
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/getfider/fider
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/getfider/fider
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/getfider/fider
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/getfider/fider

### Formbricks

- Slug: formbricks
- URL: https://www.canagentsuse.com/tools/formbricks
- Website: https://formbricks.com
- Docs: https://github.com/formbricks/formbricks
- Agent score: 56
- Agent tier: Usable
- Categories: Self-hosted, Polls and Events
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted polls and events workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/formbricks/formbricks
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Formbricks is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 6.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://formbricks.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/formbricks/formbricks
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/formbricks/formbricks
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/formbricks/formbricks
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/formbricks/formbricks

### gathio

- Slug: gathio
- URL: https://www.canagentsuse.com/tools/gathio
- Website: https://docs.gath.io/
- Docs: https://github.com/lowercasename/gathio
- Agent score: 56
- Agent tier: Usable
- Categories: Self-hosted, Polls and Events
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted polls and events workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/lowercasename/gathio
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

gathio is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 6.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://docs.gath.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/lowercasename/gathio
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/lowercasename/gathio
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/lowercasename/gathio
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/lowercasename/gathio

### HeyForm

- Slug: heyform
- URL: https://www.canagentsuse.com/tools/heyform
- Website: https://heyform.net
- Docs: https://github.com/heyform/heyform
- Agent score: 56
- Agent tier: Usable
- Categories: Self-hosted, Polls and Events
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted polls and events workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/heyform/heyform
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

HeyForm is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 6.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://heyform.net
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/heyform/heyform
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/heyform/heyform
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/heyform/heyform
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/heyform/heyform

### Hi.Events

- Slug: hi-events
- URL: https://www.canagentsuse.com/tools/hi-events
- Website: https://hi.events
- Docs: https://github.com/HiEventsDev/hi.events
- Agent score: 56
- Agent tier: Usable
- Categories: Self-hosted, Booking and Scheduling, E-commerce
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted booking and scheduling workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/HiEventsDev/hi.events
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Hi.Events is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 6.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://hi.events
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/HiEventsDev/hi.events
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/HiEventsDev/hi.events
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/HiEventsDev/hi.events
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/HiEventsDev/hi.events

### hitobito

- Slug: hitobito
- URL: https://www.canagentsuse.com/tools/hitobito
- Website: https://hitobito.com
- Docs: https://github.com/hitobito/hitobito
- Agent score: 56
- Agent tier: Usable
- Categories: Self-hosted, Polls and Events
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted polls and events workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Ruby. Source code: https://github.com/hitobito/hitobito
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

hitobito is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 6.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://hitobito.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/hitobito/hitobito
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/hitobito/hitobito
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/hitobito/hitobito
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/hitobito/hitobito

### LimeSurvey

- Slug: limesurvey
- URL: https://www.canagentsuse.com/tools/limesurvey
- Website: https://www.limesurvey.org
- Docs: https://github.com/LimeSurvey/LimeSurvey
- Agent score: 56
- Agent tier: Usable
- Categories: Self-hosted, Polls and Events
- Use cases: Self-host a tool, Inspect open source, Analyze product
- Best for: Self-hosted polls and events workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/LimeSurvey/LimeSurvey
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

LimeSurvey is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 6.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.limesurvey.org
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/LimeSurvey/LimeSurvey
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/LimeSurvey/LimeSurvey
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/LimeSurvey/LimeSurvey
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/LimeSurvey/LimeSurvey

### OpnForm

- Slug: opnform
- URL: https://www.canagentsuse.com/tools/opnform
- Website: https://opnform.com
- Docs: https://github.com/OpnForm/OpnForm
- Agent score: 56
- Agent tier: Usable
- Categories: Self-hosted, Polls and Events
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted polls and events workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP, Nodejs, Docker. Source code: https://github.com/OpnForm/OpnForm
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

OpnForm is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 6.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://opnform.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/OpnForm/OpnForm
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/OpnForm/OpnForm
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/OpnForm/OpnForm
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/OpnForm/OpnForm

### AdventureLog

- Slug: adventurelog
- URL: https://www.canagentsuse.com/tools/adventurelog
- Website: https://adventurelog.app
- Docs: https://github.com/seanmorley15/AdventureLog
- Agent score: 55
- Agent tier: Usable
- Categories: Self-hosted, Maps and Global Positioning System (GPS)
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted maps and global positioning system (gps) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/seanmorley15/AdventureLog
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

AdventureLog is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 5.6/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://adventurelog.app
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/seanmorley15/AdventureLog
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/seanmorley15/AdventureLog
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/seanmorley15/AdventureLog
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/seanmorley15/AdventureLog

### BookLogr

- Slug: booklogr
- URL: https://www.canagentsuse.com/tools/booklogr
- Website: https://github.com/Mozzo1000/booklogr
- Docs: https://github.com/Mozzo1000/booklogr
- Agent score: 55
- Agent tier: Usable
- Categories: Self-hosted, Document Management - E-books
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted document management - e-books workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/Mozzo1000/booklogr
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

BookLogr is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 5.6/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/Mozzo1000/booklogr
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Mozzo1000/booklogr
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Mozzo1000/booklogr
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Mozzo1000/booklogr
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Mozzo1000/booklogr

### Chyrp Lite

- Slug: chyrp-lite
- URL: https://www.canagentsuse.com/tools/chyrp-lite
- Website: https://chyrplite.net
- Docs: https://github.com/xenocrat/chyrp-lite
- Agent score: 55
- Agent tier: Usable
- Categories: Self-hosted, Blogging Platforms
- Use cases: Self-host a tool, Inspect open source, Analyze product, Publish content
- Best for: Self-hosted blogging platforms workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as BSD-3-Clause; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/xenocrat/chyrp-lite
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Chyrp Lite is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 5.6/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://chyrplite.net
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/xenocrat/chyrp-lite
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/xenocrat/chyrp-lite
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/xenocrat/chyrp-lite
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/xenocrat/chyrp-lite

### Cloudlog

- Slug: cloudlog
- URL: https://www.canagentsuse.com/tools/cloudlog
- Website: https://magicbug.co.uk/cloudlog/
- Docs: https://github.com/magicbug/cloudlog
- Agent score: 55
- Agent tier: Usable
- Categories: Self-hosted, Miscellaneous
- Use cases: Self-host a tool, Inspect open source, Analyze product
- Best for: Self-hosted miscellaneous workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP, Docker. Source code: https://github.com/magicbug/cloudlog
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Cloudlog is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 5.6/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://magicbug.co.uk/cloudlog/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/magicbug/cloudlog
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/magicbug/cloudlog
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/magicbug/cloudlog
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/magicbug/cloudlog

### Ech0

- Slug: ech0
- URL: https://www.canagentsuse.com/tools/ech0
- Website: https://echo.soopy.cn/
- Docs: https://github.com/lin-snow/Ech0
- Agent score: 55
- Agent tier: Usable
- Categories: Self-hosted, Blogging Platforms, Content Management Systems (CMS)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Analyze product, Publish content
- Best for: Self-hosted blogging platforms workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, K8S. Source code: https://github.com/lin-snow/Ech0
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Ech0 is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 5.6/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://echo.soopy.cn/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/lin-snow/Ech0
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/lin-snow/Ech0
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/lin-snow/Ech0
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/lin-snow/Ech0

### fx

- Slug: fx
- URL: https://www.canagentsuse.com/tools/fx
- Website: https://github.com/rikhuijzer/fx
- Docs: https://github.com/rikhuijzer/fx
- Agent score: 55
- Agent tier: Usable
- Categories: Self-hosted, Blogging Platforms
- Use cases: Self-host a tool, Inspect open source, Analyze product, Publish content
- Best for: Self-hosted blogging platforms workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/rikhuijzer/fx
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

fx is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 5.6/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/rikhuijzer/fx
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/rikhuijzer/fx
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/rikhuijzer/fx
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/rikhuijzer/fx
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/rikhuijzer/fx

### Genea.app

- Slug: genea-app
- URL: https://www.canagentsuse.com/tools/genea-app
- Website: https://www.genea.app/
- Docs: https://github.com/genea-app/genea-app
- Agent score: 55
- Agent tier: Usable
- Categories: Self-hosted, Genealogy
- Use cases: Self-host a tool, Inspect open source, Analyze product, Triage work
- Best for: Self-hosted genealogy workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Javascript. Source code: https://github.com/genea-app/genea-app
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Genea.app is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 5.6/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.genea.app/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/genea-app/genea-app
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/genea-app/genea-app
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/genea-app/genea-app
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/genea-app/genea-app

### Genealogy

- Slug: genealogy
- URL: https://www.canagentsuse.com/tools/genealogy
- Website: https://genealogy.kreaweb.be/
- Docs: https://github.com/MGeurts/genealogy
- Agent score: 55
- Agent tier: Usable
- Categories: Self-hosted, Genealogy
- Use cases: Self-host a tool, Inspect open source, Analyze product
- Best for: Self-hosted genealogy workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/MGeurts/genealogy
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Genealogy is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 5.6/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://genealogy.kreaweb.be/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/MGeurts/genealogy
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/MGeurts/genealogy
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/MGeurts/genealogy
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/MGeurts/genealogy

### GeneWeb

- Slug: geneweb
- URL: https://www.canagentsuse.com/tools/geneweb
- Website: https://geneweb.tuxfamily.org/wiki/GeneWeb
- Docs: https://github.com/geneweb/geneweb
- Agent score: 55
- Agent tier: Usable
- Categories: Self-hosted, Genealogy
- Use cases: Self-host a tool, Inspect open source, Analyze product
- Best for: Self-hosted genealogy workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: OCaml. Source code: https://github.com/geneweb/geneweb
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

GeneWeb is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 5.6/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://geneweb.tuxfamily.org/wiki/GeneWeb
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/geneweb/geneweb
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/geneweb/geneweb
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/geneweb/geneweb
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/geneweb/geneweb

### Ghost

- Slug: ghost
- URL: https://www.canagentsuse.com/tools/ghost
- Website: https://ghost.org/
- Docs: https://github.com/TryGhost/Ghost
- Agent score: 55
- Agent tier: Usable
- Categories: Self-hosted, Blogging Platforms
- Use cases: Self-host a tool, Inspect open source, Analyze product, Publish content
- Best for: Self-hosted blogging platforms workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs. Source code: https://github.com/TryGhost/Ghost
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Ghost is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 5.6/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://ghost.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/TryGhost/Ghost
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/TryGhost/Ghost
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/TryGhost/Ghost
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/TryGhost/Ghost

### Haven

- Slug: haven
- URL: https://www.canagentsuse.com/tools/haven
- Website: https://havenweb.org/
- Docs: https://github.com/havenweb/haven
- Agent score: 55
- Agent tier: Usable
- Categories: Self-hosted, Blogging Platforms
- Use cases: Self-host a tool, Inspect open source, Analyze product, Publish content
- Best for: Self-hosted blogging platforms workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Ruby. Source code: https://github.com/havenweb/haven
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Haven is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 5.6/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://havenweb.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/havenweb/haven
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/havenweb/haven
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/havenweb/haven
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/havenweb/haven

### jetlog

- Slug: jetlog
- URL: https://www.canagentsuse.com/tools/jetlog
- Website: https://github.com/pbogre/jetlog
- Docs: https://github.com/pbogre/jetlog
- Agent score: 55
- Agent tier: Usable
- Categories: Self-hosted, Miscellaneous
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted miscellaneous workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/pbogre/jetlog
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

jetlog is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 5.6/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/pbogre/jetlog
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/pbogre/jetlog
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/pbogre/jetlog
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/pbogre/jetlog
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/pbogre/jetlog

### Known

- Slug: known
- URL: https://www.canagentsuse.com/tools/known
- Website: https://withknown.com/
- Docs: https://github.com/idno/idno
- Agent score: 55
- Agent tier: Usable
- Categories: Self-hosted, Blogging Platforms
- Use cases: Self-host a tool, Inspect open source, Analyze product, Publish content
- Best for: Self-hosted blogging platforms workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/idno/idno
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Known is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 5.6/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://withknown.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/idno/idno
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/idno/idno
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/idno/idno
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/idno/idno

### LubeLogger

- Slug: lubelogger
- URL: https://www.canagentsuse.com/tools/lubelogger
- Website: https://lubelogger.com
- Docs: https://github.com/hargata/lubelog
- Agent score: 55
- Agent tier: Usable
- Categories: Self-hosted, Miscellaneous
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted miscellaneous workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, K8S, C#. Source code: https://github.com/hargata/lubelog
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

LubeLogger is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 5.6/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://lubelogger.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/hargata/lubelog
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/hargata/lubelog
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/hargata/lubelog
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/hargata/lubelog

### Mataroa

- Slug: mataroa
- URL: https://www.canagentsuse.com/tools/mataroa
- Website: https://mataroa.blog/
- Docs: https://github.com/mataroablog/mataroa
- Agent score: 55
- Agent tier: Usable
- Categories: Self-hosted, Blogging Platforms
- Use cases: Self-host a tool, Inspect open source, Analyze product, Publish content
- Best for: Self-hosted blogging platforms workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python. Source code: https://github.com/mataroablog/mataroa
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Mataroa is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 5.6/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://mataroa.blog/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/mataroablog/mataroa
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/mataroablog/mataroa
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/mataroablog/mataroa
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/mataroablog/mataroa

### Open Archiver

- Slug: open-archiver
- URL: https://www.canagentsuse.com/tools/open-archiver
- Website: https://openarchiver.com/
- Docs: https://github.com/LogicLabs-OU/OpenArchiver
- Agent score: 55
- Agent tier: Usable
- Categories: Self-hosted, Archiving and Digital Preservation (DP)
- Use cases: Self-host a tool, Inspect open source, Triage work
- Best for: Self-hosted archiving and digital preservation (dp) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/LogicLabs-OU/OpenArchiver
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Open Archiver is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 5.6/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://openarchiver.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/LogicLabs-OU/OpenArchiver
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/LogicLabs-OU/OpenArchiver
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/LogicLabs-OU/OpenArchiver
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/LogicLabs-OU/OpenArchiver

### PluXml

- Slug: pluxml
- URL: https://www.canagentsuse.com/tools/pluxml
- Website: https://pluxml.org
- Docs: https://github.com/pluxml/PluXml
- Agent score: 55
- Agent tier: Usable
- Categories: Self-hosted, Blogging Platforms
- Use cases: Self-host a tool, Inspect open source, Analyze product, Publish content
- Best for: Self-hosted blogging platforms workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/pluxml/PluXml
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

PluXml is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 5.6/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://pluxml.org
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/pluxml/PluXml
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/pluxml/PluXml
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/pluxml/PluXml
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/pluxml/PluXml

### Serendipity

- Slug: serendipity
- URL: https://www.canagentsuse.com/tools/serendipity
- Website: https://docs.s9y.org/
- Docs: https://github.com/s9y/serendipity
- Agent score: 55
- Agent tier: Usable
- Categories: Self-hosted, Blogging Platforms
- Use cases: Self-host a tool, Inspect open source, Analyze product, Publish content
- Best for: Self-hosted blogging platforms workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as BSD-3-Clause; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/s9y/serendipity
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Serendipity is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 5.6/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://docs.s9y.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/s9y/serendipity
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/s9y/serendipity
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/s9y/serendipity
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/s9y/serendipity

### SimpleLogin

- Slug: simplelogin
- URL: https://www.canagentsuse.com/tools/simplelogin
- Website: https://simplelogin.io
- Docs: https://github.com/simple-login/app
- Agent score: 55
- Agent tier: Usable
- Categories: Self-hosted, Communication - Email - Complete Solutions
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - email - complete solutions workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Python. Source code: https://github.com/simple-login/app
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

SimpleLogin is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 5.6/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://simplelogin.io
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/simple-login/app
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/simple-login/app
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/simple-login/app
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/simple-login/app

### SiYuan

- Slug: siyuan
- URL: https://www.canagentsuse.com/tools/siyuan
- Website: https://b3log.org/siyuan/
- Docs: https://github.com/siyuan-note/siyuan
- Agent score: 55
- Agent tier: Usable
- Categories: Self-hosted, Knowledge Management Tools
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted knowledge management tools workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Go. Source code: https://github.com/siyuan-note/siyuan
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

SiYuan is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 5.6/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://b3log.org/siyuan/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/siyuan-note/siyuan
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/siyuan-note/siyuan
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/siyuan-note/siyuan
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/siyuan-note/siyuan

### Wavelog

- Slug: wavelog
- URL: https://www.canagentsuse.com/tools/wavelog
- Website: https://www.wavelog.org
- Docs: https://github.com/wavelog/wavelog
- Agent score: 55
- Agent tier: Usable
- Categories: Self-hosted, Miscellaneous
- Use cases: Self-host a tool, Inspect open source, Analyze product
- Best for: Self-hosted miscellaneous workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP, Docker. Source code: https://github.com/wavelog/wavelog
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Wavelog is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 5.6/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.wavelog.org
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/wavelog/wavelog
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/wavelog/wavelog
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/wavelog/wavelog
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/wavelog/wavelog

### webtrees

- Slug: webtrees
- URL: https://www.canagentsuse.com/tools/webtrees
- Website: https://www.webtrees.net
- Docs: https://github.com/fisharebest/webtrees
- Agent score: 55
- Agent tier: Usable
- Categories: Self-hosted, Genealogy
- Use cases: Self-host a tool, Inspect open source, Analyze product
- Best for: Self-hosted genealogy workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/fisharebest/webtrees
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

webtrees is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 5.6/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.webtrees.net
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/fisharebest/webtrees
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/fisharebest/webtrees
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/fisharebest/webtrees
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/fisharebest/webtrees

### WriteFreely

- Slug: writefreely
- URL: https://www.canagentsuse.com/tools/writefreely
- Website: https://writefreely.org
- Docs: https://github.com/writefreely/writefreely
- Agent score: 55
- Agent tier: Usable
- Categories: Self-hosted, Blogging Platforms
- Use cases: Self-host a tool, Inspect open source, Analyze product, Publish content
- Best for: Self-hosted blogging platforms workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go. Source code: https://github.com/writefreely/writefreely
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

WriteFreely is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 5.6/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://writefreely.org
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/writefreely/writefreely
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/writefreely/writefreely
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/writefreely/writefreely
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/writefreely/writefreely

### 015

- Slug: 015
- URL: https://www.canagentsuse.com/tools/015
- Website: https://send.fudaoyuan.icu
- Docs: https://github.com/keven1024/015
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, File Transfer - Single-click & Drag-n-drop Upload, Pastebins
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted file transfer - single-click & drag-n-drop upload workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/keven1024/015
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

015 is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/keven1024/015
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://send.fudaoyuan.icu
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/keven1024/015
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/keven1024/015
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/keven1024/015
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/keven1024/015

### BentoPDF

- Slug: bentopdf
- URL: https://www.canagentsuse.com/tools/bentopdf
- Website: https://bentopdf.com
- Docs: https://github.com/alam00000/bentopdf
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, Document Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted document management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/alam00000/bentopdf
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

BentoPDF is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/alam00000/bentopdf
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://bentopdf.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/alam00000/bentopdf
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/alam00000/bentopdf
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/alam00000/bentopdf
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/alam00000/bentopdf

### Chibisafe

- Slug: chibisafe
- URL: https://www.canagentsuse.com/tools/chibisafe
- Website: https://chibisafe.app
- Docs: https://github.com/chibisafe/chibisafe
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, File Transfer - Single-click & Drag-n-drop Upload
- Use cases: Self-host a tool, Inspect open source, Publish content
- Best for: Self-hosted file transfer - single-click & drag-n-drop upload workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Nodejs. Source code: https://github.com/chibisafe/chibisafe
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Chibisafe is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/chibisafe/chibisafe
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://chibisafe.app
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/chibisafe/chibisafe
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/chibisafe/chibisafe
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/chibisafe/chibisafe
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/chibisafe/chibisafe

### ClipCascade

- Slug: clipcascade
- URL: https://www.canagentsuse.com/tools/clipcascade
- Website: https://github.com/Sathvik-Rao/ClipCascade
- Docs: https://github.com/Sathvik-Rao/ClipCascade
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, Miscellaneous
- Use cases: Self-host a tool, Inspect open source, Triage work
- Best for: Self-hosted miscellaneous workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Java, Docker. Source code: https://github.com/Sathvik-Rao/ClipCascade
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

ClipCascade is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/Sathvik-Rao/ClipCascade
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/Sathvik-Rao/ClipCascade
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Sathvik-Rao/ClipCascade
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Sathvik-Rao/ClipCascade
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Sathvik-Rao/ClipCascade
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Sathvik-Rao/ClipCascade

### Converse.js

- Slug: converse-js
- URL: https://www.canagentsuse.com/tools/converse-js
- Website: https://conversejs.org/
- Docs: https://github.com/conversejs/converse.js
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - XMPP - Web Clients
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - xmpp - web clients workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Javascript. Source code: https://github.com/conversejs/converse.js
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Converse.js is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/conversejs/converse.js
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://conversejs.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/conversejs/converse.js
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/conversejs/converse.js
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/conversejs/converse.js
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/conversejs/converse.js

### Cypht

- Slug: cypht
- URL: https://www.canagentsuse.com/tools/cypht
- Website: https://cypht.org
- Docs: https://github.com/cypht-org/cypht
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Email - Webmail Clients
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - email - webmail clients workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as LGPL-2.1; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/cypht-org/cypht
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Cypht is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/cypht-org/cypht
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://cypht.org
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/cypht-org/cypht
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/cypht-org/cypht
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/cypht-org/cypht
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/cypht-org/cypht

### egroupware

- Slug: egroupware
- URL: https://www.canagentsuse.com/tools/egroupware
- Website: https://www.egroupware.org/
- Docs: https://github.com/EGroupware/egroupware
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, Groupware
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted groupware workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/EGroupware/egroupware
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

egroupware is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/EGroupware/egroupware
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.egroupware.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/EGroupware/egroupware
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/EGroupware/egroupware
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/EGroupware/egroupware
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/EGroupware/egroupware

### Element

- Slug: element
- URL: https://www.canagentsuse.com/tools/element
- Website: https://element.io
- Docs: https://github.com/element-hq/element-web
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Custom Communication Systems
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - custom communication systems workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs. Source code: https://github.com/element-hq/element-web
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Element is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/element-hq/element-web
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://element.io
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/element-hq/element-web
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/element-hq/element-web
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/element-hq/element-web
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/element-hq/element-web

### Enclosed

- Slug: enclosed
- URL: https://www.canagentsuse.com/tools/enclosed
- Website: https://enclosed.cc/
- Docs: https://github.com/CorentinTh/enclosed
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, File Transfer - Single-click & Drag-n-drop Upload, Pastebins
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted file transfer - single-click & drag-n-drop upload workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Nodejs. Source code: https://github.com/CorentinTh/enclosed
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Enclosed is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/CorentinTh/enclosed
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://enclosed.cc/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/CorentinTh/enclosed
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/CorentinTh/enclosed
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/CorentinTh/enclosed
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/CorentinTh/enclosed

### Fasten Health

- Slug: fasten-health
- URL: https://www.canagentsuse.com/tools/fasten-health
- Website: https://github.com/fastenhealth/fasten-onprem/
- Docs: https://github.com/fastenhealth/fasten-onprem/
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, Health and Fitness
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted health and fitness workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker. Source code: https://github.com/fastenhealth/fasten-onprem/
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Fasten Health is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/fastenhealth/fasten-onprem/
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/fastenhealth/fasten-onprem/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/fastenhealth/fasten-onprem/
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/fastenhealth/fasten-onprem/
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/fastenhealth/fasten-onprem/
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/fastenhealth/fasten-onprem/

### Files Sharing

- Slug: files-sharing
- URL: https://www.canagentsuse.com/tools/files-sharing
- Website: https://github.com/axeloz/filesharing
- Docs: https://github.com/axeloz/filesharing
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, File Transfer - Single-click & Drag-n-drop Upload
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted file transfer - single-click & drag-n-drop upload workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP, Docker. Source code: https://github.com/axeloz/filesharing
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Files Sharing is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/axeloz/filesharing
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/axeloz/filesharing
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/axeloz/filesharing
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/axeloz/filesharing
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/axeloz/filesharing
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/axeloz/filesharing

### Gitit

- Slug: gitit
- URL: https://www.canagentsuse.com/tools/gitit
- Website: https://github.com/jgm/gitit
- Docs: https://github.com/jgm/gitit
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, Wikis
- Use cases: Self-host a tool, Inspect open source, Publish content
- Best for: Self-hosted wikis workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Haskell. Source code: https://github.com/jgm/gitit
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Gitit is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/jgm/gitit
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/jgm/gitit
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/jgm/gitit
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/jgm/gitit
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/jgm/gitit
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/jgm/gitit

### GoAccess

- Slug: goaccess
- URL: https://www.canagentsuse.com/tools/goaccess
- Website: http://goaccess.io/
- Docs: https://github.com/allinurl/goaccess
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, Analytics
- Use cases: Self-host a tool, Inspect open source, Analyze product
- Best for: Self-hosted analytics workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C. Source code: https://github.com/allinurl/goaccess
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

GoAccess is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/allinurl/goaccess
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: http://goaccess.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/allinurl/goaccess
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/allinurl/goaccess
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/allinurl/goaccess
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/allinurl/goaccess

### Group Office

- Slug: group-office
- URL: https://www.canagentsuse.com/tools/group-office
- Website: https://www.group-office.com
- Docs: https://github.com/Intermesh/groupoffice/
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, Groupware, Customer Relationship Management (CRM)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted groupware workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/Intermesh/groupoffice/
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Group Office is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/Intermesh/groupoffice/
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.group-office.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Intermesh/groupoffice/
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Intermesh/groupoffice/
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Intermesh/groupoffice/
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Intermesh/groupoffice/

### Hatsu

- Slug: hatsu
- URL: https://www.canagentsuse.com/tools/hatsu
- Website: https://hatsu.cli.rs/
- Docs: https://github.com/importantimport/hatsu
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Social Networks and Forums
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - social networks and forums workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Rust. Source code: https://github.com/importantimport/hatsu
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Hatsu is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/importantimport/hatsu
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://hatsu.cli.rs/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/importantimport/hatsu
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/importantimport/hatsu
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/importantimport/hatsu
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/importantimport/hatsu

### Invoice Ninja

- Slug: invoice-ninja
- URL: https://www.canagentsuse.com/tools/invoice-ninja
- Website: https://www.invoiceninja.org/
- Docs: https://github.com/invoiceninja/invoiceninja
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, Money, Budgeting & Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted money, budgeting & management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Elastic-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP, Docker, K8S. Source code: https://github.com/invoiceninja/invoiceninja
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Invoice Ninja is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/invoiceninja/invoiceninja
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.invoiceninja.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/invoiceninja/invoiceninja
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/invoiceninja/invoiceninja
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/invoiceninja/invoiceninja
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/invoiceninja/invoiceninja

### ITFlow

- Slug: itflow
- URL: https://www.canagentsuse.com/tools/itflow
- Website: https://itflow.org
- Docs: https://github.com/itflow-org/itflow
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, Ticketing
- Use cases: Self-host a tool, Inspect open source, Publish content
- Best for: Self-hosted ticketing workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/itflow-org/itflow
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

ITFlow is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/itflow-org/itflow
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://itflow.org
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/itflow-org/itflow
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/itflow-org/itflow
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/itflow-org/itflow
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/itflow-org/itflow

### Joplin

- Slug: joplin
- URL: https://www.canagentsuse.com/tools/joplin
- Website: https://joplinapp.org/
- Docs: https://github.com/laurent22/joplin
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, Note-taking & Editors
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted note-taking & editors workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs. Source code: https://github.com/laurent22/joplin
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Joplin is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/laurent22/joplin
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://joplinapp.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/laurent22/joplin
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/laurent22/joplin
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/laurent22/joplin
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/laurent22/joplin

### Kiwi IRC

- Slug: kiwi-irc
- URL: https://www.canagentsuse.com/tools/kiwi-irc
- Website: https://kiwiirc.com/
- Docs: https://github.com/kiwiirc/kiwiirc
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - IRC
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - irc workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs. Source code: https://github.com/kiwiirc/kiwiirc
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Kiwi IRC is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/kiwiirc/kiwiirc
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://kiwiirc.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/kiwiirc/kiwiirc
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/kiwiirc/kiwiirc
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/kiwiirc/kiwiirc
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/kiwiirc/kiwiirc

### LiveCodes

- Slug: livecodes
- URL: https://www.canagentsuse.com/tools/livecodes
- Website: https://livecodes.io/docs/features/self-hosting
- Docs: https://github.com/live-codes/livecodes
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, Software Development - IDE & Tools
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted software development - ide & tools workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs. Source code: https://github.com/live-codes/livecodes
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

LiveCodes is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/live-codes/livecodes
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://livecodes.io/docs/features/self-hosting
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/live-codes/livecodes
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/live-codes/livecodes
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/live-codes/livecodes
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/live-codes/livecodes

### LobeHub

- Slug: lobehub
- URL: https://www.canagentsuse.com/tools/lobehub
- Website: https://www.lobehub.com
- Docs: https://github.com/lobehub/lobehub
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, Generative Artificial Intelligence (GenAI)
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted generative artificial intelligence (genai) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as ⊘ Proprietary; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/lobehub/lobehub
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

LobeHub is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/lobehub/lobehub
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.lobehub.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/lobehub/lobehub
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/lobehub/lobehub
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/lobehub/lobehub
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/lobehub/lobehub

### Local Content Share

- Slug: local-content-share
- URL: https://www.canagentsuse.com/tools/local-content-share
- Website: https://github.com/Tanq16/local-content-share
- Docs: https://github.com/Tanq16/local-content-share
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, Pastebins, File Transfer - Single-click & Drag-n-drop Upload
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted pastebins workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Go. Source code: https://github.com/Tanq16/local-content-share
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Local Content Share is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/Tanq16/local-content-share
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/Tanq16/local-content-share
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Tanq16/local-content-share
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Tanq16/local-content-share
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Tanq16/local-content-share
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Tanq16/local-content-share

### miniserve

- Slug: miniserve
- URL: https://www.canagentsuse.com/tools/miniserve
- Website: https://github.com/svenstaro/miniserve
- Docs: https://github.com/svenstaro/miniserve
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, File Transfer - Web-based File Managers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted file transfer - web-based file managers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Rust. Source code: https://github.com/svenstaro/miniserve
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

miniserve is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/svenstaro/miniserve
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/svenstaro/miniserve
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/svenstaro/miniserve
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/svenstaro/miniserve
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/svenstaro/miniserve
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/svenstaro/miniserve

### mpd

- Slug: mpd
- URL: https://www.canagentsuse.com/tools/mpd
- Website: https://www.musicpd.org/
- Docs: https://github.com/MusicPlayerDaemon/MPD
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, Media Streaming - Audio Streaming
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted media streaming - audio streaming workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C++. Source code: https://github.com/MusicPlayerDaemon/MPD
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

mpd is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/MusicPlayerDaemon/MPD
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.musicpd.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/MusicPlayerDaemon/MPD
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/MusicPlayerDaemon/MPD
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/MusicPlayerDaemon/MPD
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/MusicPlayerDaemon/MPD

### ntfy

- Slug: ntfy
- URL: https://www.canagentsuse.com/tools/ntfy
- Website: https://ntfy.sh/
- Docs: https://github.com/binwiederhier/ntfy
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Custom Communication Systems
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - custom communication systems workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0, GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker, K8S. Source code: https://github.com/binwiederhier/ntfy
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

ntfy is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/binwiederhier/ntfy
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://ntfy.sh/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/binwiederhier/ntfy
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/binwiederhier/ntfy
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/binwiederhier/ntfy
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/binwiederhier/ntfy

### OnionShare

- Slug: onionshare
- URL: https://www.canagentsuse.com/tools/onionshare
- Website: https://github.com/onionshare/onionshare
- Docs: https://github.com/onionshare/onionshare
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, File Transfer - Single-click & Drag-n-drop Upload
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted file transfer - single-click & drag-n-drop upload workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python, deb. Source code: https://github.com/onionshare/onionshare
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

OnionShare is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/onionshare/onionshare
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/onionshare/onionshare
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/onionshare/onionshare
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/onionshare/onionshare
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/onionshare/onionshare
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/onionshare/onionshare

### OpenZiti

- Slug: openziti
- URL: https://www.canagentsuse.com/tools/openziti
- Website: https://openziti.io/
- Docs: https://github.com/openziti/ziti
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, Miscellaneous
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted miscellaneous workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go. Source code: https://github.com/openziti/ziti
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

OpenZiti is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/openziti/ziti
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://openziti.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/openziti/ziti
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/openziti/ziti
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/openziti/ziti
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/openziti/ziti

### Ownfoil

- Slug: ownfoil
- URL: https://www.canagentsuse.com/tools/ownfoil
- Website: https://github.com/a1ex4/ownfoil
- Docs: https://github.com/a1ex4/ownfoil
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, Games - Administrative Utilities & Control Panels
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted games - administrative utilities & control panels workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Python. Source code: https://github.com/a1ex4/ownfoil
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Ownfoil is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/a1ex4/ownfoil
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/a1ex4/ownfoil
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/a1ex4/ownfoil
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/a1ex4/ownfoil
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/a1ex4/ownfoil
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/a1ex4/ownfoil

### Peergos

- Slug: peergos
- URL: https://www.canagentsuse.com/tools/peergos
- Website: https://peergos.org
- Docs: https://github.com/Peergos/Peergos
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, File Transfer & Synchronization
- Use cases: Self-host a tool, Inspect open source, Publish content
- Best for: Self-hosted file transfer & synchronization workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Java. Source code: https://github.com/Peergos/Peergos
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Peergos is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/Peergos/Peergos
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://peergos.org
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Peergos/Peergos
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Peergos/Peergos
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Peergos/Peergos
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Peergos/Peergos

### PicoShare

- Slug: picoshare
- URL: https://www.canagentsuse.com/tools/picoshare
- Website: https://github.com/mtlynch/picoshare
- Docs: https://github.com/mtlynch/picoshare
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, File Transfer - Single-click & Drag-n-drop Upload
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted file transfer - single-click & drag-n-drop upload workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker. Source code: https://github.com/mtlynch/picoshare
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

PicoShare is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/mtlynch/picoshare
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/mtlynch/picoshare
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/mtlynch/picoshare
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/mtlynch/picoshare
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/mtlynch/picoshare
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/mtlynch/picoshare

### Picsur

- Slug: picsur
- URL: https://www.canagentsuse.com/tools/picsur
- Website: https://github.com/CaramelFur/Picsur
- Docs: https://github.com/CaramelFur/Picsur
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, File Transfer - Single-click & Drag-n-drop Upload
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted file transfer - single-click & drag-n-drop upload workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/CaramelFur/Picsur
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Picsur is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/CaramelFur/Picsur
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/CaramelFur/Picsur
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/CaramelFur/Picsur
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/CaramelFur/Picsur
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/CaramelFur/Picsur
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/CaramelFur/Picsur

### Plik

- Slug: plik
- URL: https://www.canagentsuse.com/tools/plik
- Website: https://github.com/root-gg/plik
- Docs: https://github.com/root-gg/plik
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, File Transfer - Single-click & Drag-n-drop Upload
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted file transfer - single-click & drag-n-drop upload workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker. Source code: https://github.com/root-gg/plik
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Plik is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/root-gg/plik
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/root-gg/plik
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/root-gg/plik
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/root-gg/plik
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/root-gg/plik
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/root-gg/plik

### ProjectSend

- Slug: projectsend
- URL: https://www.canagentsuse.com/tools/projectsend
- Website: https://www.projectsend.org/
- Docs: https://github.com/projectsend/projectsend
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, File Transfer - Single-click & Drag-n-drop Upload
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted file transfer - single-click & drag-n-drop upload workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/projectsend/projectsend
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

ProjectSend is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/projectsend/projectsend
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.projectsend.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/projectsend/projectsend
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/projectsend/projectsend
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/projectsend/projectsend
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/projectsend/projectsend

### PsiTransfer

- Slug: psitransfer
- URL: https://www.canagentsuse.com/tools/psitransfer
- Website: https://github.com/psi-4ward/psitransfer
- Docs: https://github.com/psi-4ward/psitransfer
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, File Transfer - Single-click & Drag-n-drop Upload
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted file transfer - single-click & drag-n-drop upload workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as BSD-2-Clause; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs. Source code: https://github.com/psi-4ward/psitransfer
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

PsiTransfer is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/psi-4ward/psitransfer
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/psi-4ward/psitransfer
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/psi-4ward/psitransfer
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/psi-4ward/psitransfer
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/psi-4ward/psitransfer
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/psi-4ward/psitransfer

### qBittorrent

- Slug: qbittorrent
- URL: https://www.canagentsuse.com/tools/qbittorrent
- Website: https://www.qbittorrent.org/
- Docs: https://github.com/qbittorrent/qBittorrent
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, File Transfer - Peer-to-peer Filesharing
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted file transfer - peer-to-peer filesharing workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C++. Source code: https://github.com/qbittorrent/qBittorrent
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

qBittorrent is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/qbittorrent/qBittorrent
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.qbittorrent.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/qbittorrent/qBittorrent
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/qbittorrent/qBittorrent
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/qbittorrent/qBittorrent
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/qbittorrent/qBittorrent

### Quassel IRC

- Slug: quassel-irc
- URL: https://www.canagentsuse.com/tools/quassel-irc
- Website: https://quassel-irc.org/
- Docs: https://github.com/quassel/quassel
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - IRC
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - irc workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C++. Source code: https://github.com/quassel/quassel
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Quassel IRC is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/quassel/quassel
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://quassel-irc.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/quassel/quassel
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/quassel/quassel
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/quassel/quassel
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/quassel/quassel

### QuickShare

- Slug: quickshare
- URL: https://www.canagentsuse.com/tools/quickshare
- Website: https://ihexxa.github.io/quickshare.site/
- Docs: https://github.com/ihexxa/quickshare
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, File Transfer - Single-click & Drag-n-drop Upload
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted file transfer - single-click & drag-n-drop upload workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as LGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Go. Source code: https://github.com/ihexxa/quickshare
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

QuickShare is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/ihexxa/quickshare
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://ihexxa.github.io/quickshare.site/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/ihexxa/quickshare
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/ihexxa/quickshare
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/ihexxa/quickshare
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/ihexxa/quickshare

### Red Eclipse 2

- Slug: red-eclipse-2
- URL: https://www.canagentsuse.com/tools/red-eclipse-2
- Website: https://www.redeclipse.net/
- Docs: https://github.com/redeclipse/base
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, Games
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted games workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Zlib, MIT, CC-BY-SA-4.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C, C++, deb. Source code: https://github.com/redeclipse/base
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Red Eclipse 2 is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/redeclipse/base
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.redeclipse.net/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/redeclipse/base
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/redeclipse/base
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/redeclipse/base
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/redeclipse/base

### Roundcube

- Slug: roundcube
- URL: https://www.canagentsuse.com/tools/roundcube
- Website: https://roundcube.net
- Docs: https://github.com/roundcube/roundcubemail
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Email - Webmail Clients
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - email - webmail clients workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP, deb. Source code: https://github.com/roundcube/roundcubemail
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Roundcube is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/roundcube/roundcubemail
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://roundcube.net
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/roundcube/roundcubemail
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/roundcube/roundcubemail
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/roundcube/roundcubemail
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/roundcube/roundcubemail

### Safebucket

- Slug: safebucket
- URL: https://www.canagentsuse.com/tools/safebucket
- Website: https://docs.safebucket.io/
- Docs: https://github.com/safebucket/safebucket
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, File Transfer - Single-click & Drag-n-drop Upload
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted file transfer - single-click & drag-n-drop upload workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker. Source code: https://github.com/safebucket/safebucket
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Safebucket is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/safebucket/safebucket
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://docs.safebucket.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/safebucket/safebucket
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/safebucket/safebucket
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/safebucket/safebucket
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/safebucket/safebucket

### Sharry

- Slug: sharry
- URL: https://www.canagentsuse.com/tools/sharry
- Website: https://github.com/eikek/sharry
- Docs: https://github.com/eikek/sharry
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, File Transfer - Single-click & Drag-n-drop Upload
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted file transfer - single-click & drag-n-drop upload workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Scala, Java, deb, Docker. Source code: https://github.com/eikek/sharry
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Sharry is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/eikek/sharry
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/eikek/sharry
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/eikek/sharry
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/eikek/sharry
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/eikek/sharry
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/eikek/sharry

### Slink

- Slug: slink
- URL: https://www.canagentsuse.com/tools/slink
- Website: https://docs.slinkapp.io/
- Docs: https://github.com/andrii-kryvoviaz/slink
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, File Transfer - Single-click & Drag-n-drop Upload
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted file transfer - single-click & drag-n-drop upload workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/andrii-kryvoviaz/slink
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Slink is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/andrii-kryvoviaz/slink
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://docs.slinkapp.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/andrii-kryvoviaz/slink
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/andrii-kryvoviaz/slink
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/andrii-kryvoviaz/slink
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/andrii-kryvoviaz/slink

### SnappyMail

- Slug: snappymail
- URL: https://www.canagentsuse.com/tools/snappymail
- Website: https://snappymail.eu/
- Docs: https://github.com/the-djmaze/snappymail
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Email - Webmail Clients
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - email - webmail clients workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/the-djmaze/snappymail
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

SnappyMail is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/the-djmaze/snappymail
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://snappymail.eu/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/the-djmaze/snappymail
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/the-djmaze/snappymail
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/the-djmaze/snappymail
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/the-djmaze/snappymail

### Starbase 80

- Slug: starbase-80
- URL: https://www.canagentsuse.com/tools/starbase-80
- Website: https://github.com/notclickable-jordan/starbase-80
- Docs: https://github.com/notclickable-jordan/starbase-80
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, Personal Dashboards
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted personal dashboards workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/notclickable-jordan/starbase-80
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Starbase 80 is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/notclickable-jordan/starbase-80
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/notclickable-jordan/starbase-80
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/notclickable-jordan/starbase-80
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/notclickable-jordan/starbase-80
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/notclickable-jordan/starbase-80
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/notclickable-jordan/starbase-80

### The Lounge

- Slug: the-lounge
- URL: https://www.canagentsuse.com/tools/the-lounge
- Website: https://thelounge.chat/
- Docs: https://github.com/thelounge/thelounge
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - IRC
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - irc workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/thelounge/thelounge
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

The Lounge is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/thelounge/thelounge
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://thelounge.chat/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/thelounge/thelounge
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/thelounge/thelounge
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/thelounge/thelounge
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/thelounge/thelounge

### Tinode

- Slug: tinode
- URL: https://www.canagentsuse.com/tools/tinode
- Website: https://github.com/tinode
- Docs: https://github.com/tinode/chat
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Custom Communication Systems
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - custom communication systems workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go. Source code: https://github.com/tinode/chat
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Tinode is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/tinode/chat
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/tinode
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/tinode/chat
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/tinode/chat
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/tinode/chat
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/tinode/chat

### TinyFeed

- Slug: tinyfeed
- URL: https://www.canagentsuse.com/tools/tinyfeed
- Website: https://feed.lovergne.dev/
- Docs: https://github.com/TheBigRoomXXL/tinyfeed
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, Feed Readers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted feed readers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker. Source code: https://github.com/TheBigRoomXXL/tinyfeed
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

TinyFeed is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/TheBigRoomXXL/tinyfeed
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://feed.lovergne.dev/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/TheBigRoomXXL/tinyfeed
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/TheBigRoomXXL/tinyfeed
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/TheBigRoomXXL/tinyfeed
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/TheBigRoomXXL/tinyfeed

### transfer.sh

- Slug: transfer-sh
- URL: https://www.canagentsuse.com/tools/transfer-sh
- Website: https://github.com/dutchcoders/transfer.sh
- Docs: https://github.com/dutchcoders/transfer.sh
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, File Transfer - Single-click & Drag-n-drop Upload
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted file transfer - single-click & drag-n-drop upload workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go. Source code: https://github.com/dutchcoders/transfer.sh
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

transfer.sh is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/dutchcoders/transfer.sh
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/dutchcoders/transfer.sh
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/dutchcoders/transfer.sh
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/dutchcoders/transfer.sh
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/dutchcoders/transfer.sh
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/dutchcoders/transfer.sh

### Transmission

- Slug: transmission
- URL: https://www.canagentsuse.com/tools/transmission
- Website: https://transmissionbt.com/
- Docs: https://github.com/transmission/transmission
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, File Transfer - Peer-to-peer Filesharing
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted file transfer - peer-to-peer filesharing workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C++, deb. Source code: https://github.com/transmission/transmission
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Transmission is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/transmission/transmission
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://transmissionbt.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/transmission/transmission
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/transmission/transmission
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/transmission/transmission
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/transmission/transmission

### Uguu

- Slug: uguu
- URL: https://www.canagentsuse.com/tools/uguu
- Website: https://github.com/nokonoko/uguu
- Docs: https://github.com/nokonoko/uguu
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, File Transfer - Single-click & Drag-n-drop Upload
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted file transfer - single-click & drag-n-drop upload workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/nokonoko/uguu
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Uguu is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/nokonoko/uguu
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/nokonoko/uguu
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/nokonoko/uguu
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/nokonoko/uguu
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/nokonoko/uguu
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/nokonoko/uguu

### UVDesk

- Slug: uvdesk
- URL: https://www.canagentsuse.com/tools/uvdesk
- Website: https://www.uvdesk.com/
- Docs: https://github.com/uvdesk/community-skeleton
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, Software Development - Project Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted software development - project management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/uvdesk/community-skeleton
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

UVDesk is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/uvdesk/community-skeleton
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.uvdesk.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/uvdesk/community-skeleton
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/uvdesk/community-skeleton
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/uvdesk/community-skeleton
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/uvdesk/community-skeleton

### vod2pod-rss

- Slug: vod2pod-rss
- URL: https://www.canagentsuse.com/tools/vod2pod-rss
- Website: https://github.com/madiele/vod2pod-rss
- Docs: https://github.com/madiele/vod2pod-rss
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, Media Streaming - Audio Streaming
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted media streaming - audio streaming workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/madiele/vod2pod-rss
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

vod2pod-rss is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/madiele/vod2pod-rss
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/madiele/vod2pod-rss
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/madiele/vod2pod-rss
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/madiele/vod2pod-rss
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/madiele/vod2pod-rss
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/madiele/vod2pod-rss

### Warpgate

- Slug: warpgate
- URL: https://www.canagentsuse.com/tools/warpgate
- Website: https://github.com/warp-tech/warpgate
- Docs: https://github.com/warp-tech/warpgate
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, Remote Access
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted remote access workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Rust, Docker. Source code: https://github.com/warp-tech/warpgate
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Warpgate is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/warp-tech/warpgate
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/warp-tech/warpgate
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/warp-tech/warpgate
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/warp-tech/warpgate
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/warp-tech/warpgate
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/warp-tech/warpgate

### Webtor

- Slug: webtor
- URL: https://www.canagentsuse.com/tools/webtor
- Website: https://github.com/webtor-io/self-hosted
- Docs: https://github.com/webtor-io/self-hosted
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, File Transfer - Peer-to-peer Filesharing
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted file transfer - peer-to-peer filesharing workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/webtor-io/self-hosted
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Webtor is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/webtor-io/self-hosted
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/webtor-io/self-hosted
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/webtor-io/self-hosted
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/webtor-io/self-hosted
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/webtor-io/self-hosted
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/webtor-io/self-hosted

### Weechat

- Slug: weechat
- URL: https://www.canagentsuse.com/tools/weechat
- Website: https://weechat.org/
- Docs: https://github.com/weechat/weechat
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - IRC
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - irc workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C, Docker, deb. Source code: https://github.com/weechat/weechat
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Weechat is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/weechat/weechat
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://weechat.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/weechat/weechat
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/weechat/weechat
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/weechat/weechat
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/weechat/weechat

### WeTTY

- Slug: wetty
- URL: https://www.canagentsuse.com/tools/wetty
- Website: https://butlerx.github.io/wetty/#/
- Docs: https://github.com/butlerx/wetty
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, Miscellaneous
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted miscellaneous workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Nodejs. Source code: https://github.com/butlerx/wetty
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

WeTTY is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/butlerx/wetty
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://butlerx.github.io/wetty/#/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/butlerx/wetty
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/butlerx/wetty
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/butlerx/wetty
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/butlerx/wetty

### Yopass

- Slug: yopass
- URL: https://www.canagentsuse.com/tools/yopass
- Website: https://github.com/jhaals/yopass
- Docs: https://github.com/jhaals/yopass
- Agent score: 54
- Agent tier: Browser-assisted
- Categories: Self-hosted, Pastebins, File Transfer - Single-click & Drag-n-drop Upload
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted pastebins workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. CLI access is powerful but can run destructive local or production commands; prefer dry runs, preview environments, and non-production credentials. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker. Source code: https://github.com/jhaals/yopass
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Yopass is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 7/25
- Agent safety: 19.2/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- CLI: partial. Metadata suggests command-line operation; verify install and command coverage in project docs. Evidence: https://github.com/jhaals/yopass
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/jhaals/yopass
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/jhaals/yopass
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/jhaals/yopass
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/jhaals/yopass
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/jhaals/yopass

### 2FAuth

- Slug: 2fauth
- URL: https://www.canagentsuse.com/tools/2fauth
- Website: https://github.com/Bubka/2FAuth
- Docs: https://github.com/Bubka/2FAuth
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Miscellaneous
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted miscellaneous workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP, Docker. Source code: https://github.com/Bubka/2FAuth
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

2FAuth is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/Bubka/2FAuth
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Bubka/2FAuth
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Bubka/2FAuth
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Bubka/2FAuth
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Bubka/2FAuth

### 4ga Boards

- Slug: 4ga-boards
- URL: https://www.canagentsuse.com/tools/4ga-boards
- Website: https://4gaboards.com
- Docs: https://github.com/RARgames/4gaBoards
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Task Management & To-do Lists, Software Development - Project Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted task management & to-do lists workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker, K8S. Source code: https://github.com/RARgames/4gaBoards
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

4ga Boards is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://4gaboards.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/RARgames/4gaBoards
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/RARgames/4gaBoards
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/RARgames/4gaBoards
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/RARgames/4gaBoards

### A Dark Room

- Slug: a-dark-room
- URL: https://www.canagentsuse.com/tools/a-dark-room
- Website: https://github.com/doublespeakgames/adarkroom
- Docs: https://github.com/doublespeakgames/adarkroom
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Games
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted games workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Javascript. Source code: https://github.com/doublespeakgames/adarkroom
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

A Dark Room is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/doublespeakgames/adarkroom
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/doublespeakgames/adarkroom
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/doublespeakgames/adarkroom
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/doublespeakgames/adarkroom
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/doublespeakgames/adarkroom

### Accent

- Slug: accent
- URL: https://www.canagentsuse.com/tools/accent
- Website: https://www.accent.reviews/
- Docs: https://github.com/mirego/accent
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Software Development - Localization
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted software development - localization workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as BSD-3-Clause; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Elixir, Docker. Source code: https://github.com/mirego/accent
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Accent is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.accent.reviews/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/mirego/accent
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/mirego/accent
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/mirego/accent
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/mirego/accent

### ActivityWatch

- Slug: activitywatch
- URL: https://www.canagentsuse.com/tools/activitywatch
- Website: https://activitywatch.net
- Docs: https://github.com/ActivityWatch/activitywatch
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Time Tracking
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted time tracking workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python. Source code: https://github.com/ActivityWatch/activitywatch
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

ActivityWatch is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://activitywatch.net
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/ActivityWatch/activitywatch
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/ActivityWatch/activitywatch
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/ActivityWatch/activitywatch
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/ActivityWatch/activitywatch

### Actual

- Slug: actual
- URL: https://www.canagentsuse.com/tools/actual
- Website: https://actualbudget.org
- Docs: https://github.com/actualbudget/actual
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Money, Budgeting & Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted money, budgeting & management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/actualbudget/actual
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Actual is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://actualbudget.org
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/actualbudget/actual
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/actualbudget/actual
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/actualbudget/actual
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/actualbudget/actual

### admidio

- Slug: admidio
- URL: https://www.canagentsuse.com/tools/admidio
- Website: https://www.admidio.org/
- Docs: https://github.com/Admidio/admidio
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Human Resources Management (HRM)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted human resources management (hrm) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP, Docker. Source code: https://github.com/Admidio/admidio
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

admidio is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.admidio.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Admidio/admidio
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Admidio/admidio
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Admidio/admidio
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Admidio/admidio

### AFFiNE Community Edition

- Slug: affine-community-edition
- URL: https://www.canagentsuse.com/tools/affine-community-edition
- Website: https://affine.pro/
- Docs: https://github.com/toeverything/AFFiNE
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Knowledge Management Tools
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted knowledge management tools workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT, AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/toeverything/AFFiNE
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

AFFiNE Community Edition is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://affine.pro/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/toeverything/AFFiNE
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/toeverything/AFFiNE
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/toeverything/AFFiNE
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/toeverything/AFFiNE

### Agenta

- Slug: agenta
- URL: https://www.canagentsuse.com/tools/agenta
- Website: https://agenta.ai/
- Docs: https://github.com/agenta-ai/agenta
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Generative Artificial Intelligence (GenAI)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Analyze product
- Best for: Self-hosted generative artificial intelligence (genai) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/agenta-ai/agenta
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Agenta is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://agenta.ai/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/agenta-ai/agenta
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/agenta-ai/agenta
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/agenta-ai/agenta
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/agenta-ai/agenta

### Aimeos

- Slug: aimeos
- URL: https://www.canagentsuse.com/tools/aimeos
- Website: https://aimeos.org/
- Docs: https://github.com/aimeos/aimeos
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, E-commerce
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted e-commerce workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as LGPL-3.0, MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/aimeos/aimeos
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Aimeos is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://aimeos.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/aimeos/aimeos
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/aimeos/aimeos
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/aimeos/aimeos
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/aimeos/aimeos

### AirTrail

- Slug: airtrail
- URL: https://www.canagentsuse.com/tools/airtrail
- Website: https://airtrail.johan.ohly.dk
- Docs: https://github.com/johanohly/AirTrail
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Maps and Global Positioning System (GPS)
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted maps and global positioning system (gps) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Nodejs. Source code: https://github.com/johanohly/AirTrail
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

AirTrail is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://airtrail.johan.ohly.dk
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/johanohly/AirTrail
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/johanohly/AirTrail
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/johanohly/AirTrail
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/johanohly/AirTrail

### Akaunting

- Slug: akaunting
- URL: https://www.canagentsuse.com/tools/akaunting
- Website: https://akaunting.com/
- Docs: https://github.com/akaunting/akaunting
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Money, Budgeting & Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted money, budgeting & management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as BUSL-1.1; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/akaunting/akaunting
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Akaunting is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://akaunting.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/akaunting/akaunting
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/akaunting/akaunting
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/akaunting/akaunting
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/akaunting/akaunting

### Aleph

- Slug: aleph
- URL: https://www.canagentsuse.com/tools/aleph
- Website: https://aleph.occrp.org/
- Docs: https://github.com/alephdata/aleph
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Search Engines, Knowledge Management Tools
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content, Triage work
- Best for: Self-hosted search engines workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, K8S. Source code: https://github.com/alephdata/aleph
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Aleph is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://aleph.occrp.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/alephdata/aleph
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/alephdata/aleph
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/alephdata/aleph
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/alephdata/aleph

### Ampache

- Slug: ampache
- URL: https://www.canagentsuse.com/tools/ampache
- Website: https://ampache.org/
- Docs: https://github.com/ampache/ampache
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Media Streaming - Audio Streaming
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted media streaming - audio streaming workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/ampache/ampache
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Ampache is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://ampache.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/ampache/ampache
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/ampache/ampache
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/ampache/ampache
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/ampache/ampache

### Anchr

- Slug: anchr
- URL: https://www.canagentsuse.com/tools/anchr
- Website: https://anchr.io
- Docs: https://github.com/muety/anchr
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Miscellaneous
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted miscellaneous workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs. Source code: https://github.com/muety/anchr
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Anchr is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://anchr.io
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/muety/anchr
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/muety/anchr
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/muety/anchr
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/muety/anchr

### AnonAddy

- Slug: anonaddy
- URL: https://www.canagentsuse.com/tools/anonaddy
- Website: https://anonaddy.com
- Docs: https://github.com/anonaddy/anonaddy
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Email - Complete Solutions
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - email - complete solutions workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP, Docker. Source code: https://github.com/anonaddy/anonaddy
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

AnonAddy is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://anonaddy.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/anonaddy/anonaddy
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/anonaddy/anonaddy
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/anonaddy/anonaddy
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/anonaddy/anonaddy

### Answer

- Slug: answer
- URL: https://www.canagentsuse.com/tools/answer
- Website: https://answer.apache.org
- Docs: https://github.com/apache/answer
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Social Networks and Forums
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - social networks and forums workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Go. Source code: https://github.com/apache/answer
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Answer is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://answer.apache.org
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/apache/answer
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/apache/answer
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/apache/answer
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/apache/answer

### Anubis

- Slug: anubis
- URL: https://www.canagentsuse.com/tools/anubis
- Website: https://anubis.techaro.lol/
- Docs: https://github.com/TecharoHQ/anubis
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Miscellaneous
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted miscellaneous workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, deb, Go. Source code: https://github.com/TecharoHQ/anubis
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Anubis is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://anubis.techaro.lol/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/TecharoHQ/anubis
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/TecharoHQ/anubis
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/TecharoHQ/anubis
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/TecharoHQ/anubis

### AnythingLLM

- Slug: anythingllm
- URL: https://www.canagentsuse.com/tools/anythingllm
- Website: https://anythingllm.com/
- Docs: https://github.com/Mintplex-Labs/anything-llm
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Generative Artificial Intelligence (GenAI)
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted generative artificial intelligence (genai) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/Mintplex-Labs/anything-llm
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

AnythingLLM is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://anythingllm.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Mintplex-Labs/anything-llm
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Mintplex-Labs/anything-llm
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Mintplex-Labs/anything-llm
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Mintplex-Labs/anything-llm

### Apache Solr

- Slug: apache-solr
- URL: https://www.canagentsuse.com/tools/apache-solr
- Website: https://lucene.apache.org/solr/
- Docs: https://github.com/apache/solr
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Search Engines
- Use cases: Self-host a tool, Inspect open source, Publish content, Triage work
- Best for: Self-hosted search engines workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Java, Docker, K8S. Source code: https://github.com/apache/solr
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Apache Solr is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://lucene.apache.org/solr/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/apache/solr
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/apache/solr
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/apache/solr
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/apache/solr

### Apaxy

- Slug: apaxy
- URL: https://www.canagentsuse.com/tools/apaxy
- Website: https://oupala.github.io/apaxy/
- Docs: https://github.com/oupala/apaxy
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, File Transfer - Web-based File Managers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted file transfer - web-based file managers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Javascript. Source code: https://github.com/oupala/apaxy
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Apaxy is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://oupala.github.io/apaxy/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/oupala/apaxy
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/oupala/apaxy
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/oupala/apaxy
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/oupala/apaxy

### Apostrophe

- Slug: apostrophe
- URL: https://www.canagentsuse.com/tools/apostrophe
- Website: https://apostrophecms.com/
- Docs: https://github.com/apostrophecms/apostrophe
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Content Management Systems (CMS)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted content management systems (cms) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs. Source code: https://github.com/apostrophecms/apostrophe
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Apostrophe is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://apostrophecms.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/apostrophecms/apostrophe
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/apostrophecms/apostrophe
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/apostrophecms/apostrophe
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/apostrophecms/apostrophe

### AppFlowy

- Slug: appflowy
- URL: https://www.canagentsuse.com/tools/appflowy
- Website: https://appflowy.io/
- Docs: https://github.com/AppFlowy-IO/appflowy
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Task Management & To-do Lists
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted task management & to-do lists workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Rust, Dart, Docker. Source code: https://github.com/AppFlowy-IO/appflowy
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

AppFlowy is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://appflowy.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/AppFlowy-IO/appflowy
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/AppFlowy-IO/appflowy
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/AppFlowy-IO/appflowy
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/AppFlowy-IO/appflowy

### Apprise

- Slug: apprise
- URL: https://www.canagentsuse.com/tools/apprise
- Website: https://github.com/caronc/apprise
- Docs: https://github.com/caronc/apprise
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Custom Communication Systems
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - custom communication systems workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python, Docker, deb. Source code: https://github.com/caronc/apprise
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Apprise is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/caronc/apprise
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/caronc/apprise
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/caronc/apprise
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/caronc/apprise
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/caronc/apprise

### Appsmith

- Slug: appsmith
- URL: https://www.canagentsuse.com/tools/appsmith
- Website: https://www.appsmith.com/
- Docs: https://github.com/appsmithorg/appsmith
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Software Development - Low Code
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted software development - low code workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Java, Docker, K8S. Source code: https://github.com/appsmithorg/appsmith
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Appsmith is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.appsmith.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/appsmithorg/appsmith
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/appsmithorg/appsmith
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/appsmithorg/appsmith
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/appsmithorg/appsmith

### Aptabase

- Slug: aptabase
- URL: https://www.canagentsuse.com/tools/aptabase
- Website: https://aptabase.com/
- Docs: https://github.com/aptabase/aptabase
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Analytics
- Use cases: Self-host a tool, Inspect open source, Analyze product
- Best for: Self-hosted analytics workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/aptabase/aptabase
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Aptabase is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://aptabase.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/aptabase/aptabase
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/aptabase/aptabase
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/aptabase/aptabase
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/aptabase/aptabase

### ArchiveBox

- Slug: archivebox
- URL: https://www.canagentsuse.com/tools/archivebox
- Website: https://archivebox.io/
- Docs: https://github.com/ArchiveBox/ArchiveBox
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Archiving and Digital Preservation (DP)
- Use cases: Self-host a tool, Inspect open source, Triage work
- Best for: Self-hosted archiving and digital preservation (dp) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python, Docker. Source code: https://github.com/ArchiveBox/ArchiveBox
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

ArchiveBox is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://archivebox.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/ArchiveBox/ArchiveBox
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/ArchiveBox/ArchiveBox
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/ArchiveBox/ArchiveBox
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/ArchiveBox/ArchiveBox

### ArchivesSpace

- Slug: archivesspace
- URL: https://www.canagentsuse.com/tools/archivesspace
- Website: https://archivesspace.org/
- Docs: https://github.com/archivesspace/archivesspace
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Archiving and Digital Preservation (DP)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Triage work
- Best for: Self-hosted archiving and digital preservation (dp) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as ECL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Ruby. Source code: https://github.com/archivesspace/archivesspace
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

ArchivesSpace is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://archivesspace.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/archivesspace/archivesspace
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/archivesspace/archivesspace
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/archivesspace/archivesspace
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/archivesspace/archivesspace

### Artalk

- Slug: artalk
- URL: https://www.canagentsuse.com/tools/artalk
- Website: https://artalk.js.org/
- Docs: https://github.com/ArtalkJS/Artalk
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Social Networks and Forums
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - social networks and forums workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker. Source code: https://github.com/ArtalkJS/Artalk
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Artalk is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://artalk.js.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/ArtalkJS/Artalk
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/ArtalkJS/Artalk
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/ArtalkJS/Artalk
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/ArtalkJS/Artalk

### Atheos

- Slug: atheos
- URL: https://www.canagentsuse.com/tools/atheos
- Website: https://www.atheos.io
- Docs: https://github.com/Atheos/Atheos
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Software Development - IDE & Tools
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted software development - ide & tools workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP, Docker. Source code: https://github.com/Atheos/Atheos
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Atheos is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.atheos.io
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Atheos/Atheos
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Atheos/Atheos
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Atheos/Atheos
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Atheos/Atheos

### Automad

- Slug: automad
- URL: https://www.canagentsuse.com/tools/automad
- Website: https://automad.org/
- Docs: https://github.com/marcantondahmen/automad
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Content Management Systems (CMS)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted content management systems (cms) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP, Docker. Source code: https://github.com/marcantondahmen/automad
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Automad is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://automad.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/marcantondahmen/automad
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/marcantondahmen/automad
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/marcantondahmen/automad
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/marcantondahmen/automad

### AzuraCast

- Slug: azuracast
- URL: https://www.canagentsuse.com/tools/azuracast
- Website: https://www.azuracast.com/
- Docs: https://github.com/AzuraCast/AzuraCast
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Media Streaming - Audio Streaming
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted media streaming - audio streaming workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/AzuraCast/AzuraCast
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

AzuraCast is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.azuracast.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/AzuraCast/AzuraCast
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/AzuraCast/AzuraCast
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/AzuraCast/AzuraCast
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/AzuraCast/AzuraCast

### Baby Buddy

- Slug: baby-buddy
- URL: https://www.canagentsuse.com/tools/baby-buddy
- Website: https://github.com/babybuddy/babybuddy
- Docs: https://github.com/babybuddy/babybuddy
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Miscellaneous
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted miscellaneous workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as BSD-2-Clause; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python. Source code: https://github.com/babybuddy/babybuddy
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Baby Buddy is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/babybuddy/babybuddy
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/babybuddy/babybuddy
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/babybuddy/babybuddy
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/babybuddy/babybuddy
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/babybuddy/babybuddy

### Backdrop CMS

- Slug: backdrop-cms
- URL: https://www.canagentsuse.com/tools/backdrop-cms
- Website: https://backdropcms.org/
- Docs: https://github.com/backdrop/backdrop
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Content Management Systems (CMS)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted content management systems (cms) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/backdrop/backdrop
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Backdrop CMS is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://backdropcms.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/backdrop/backdrop
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/backdrop/backdrop
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/backdrop/backdrop
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/backdrop/backdrop

### Bagisto

- Slug: bagisto
- URL: https://www.canagentsuse.com/tools/bagisto
- Website: https://bagisto.com/en/
- Docs: https://github.com/bagisto/bagisto
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, E-commerce
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted e-commerce workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/bagisto/bagisto
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Bagisto is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://bagisto.com/en/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/bagisto/bagisto
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/bagisto/bagisto
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/bagisto/bagisto
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/bagisto/bagisto

### Bar Assistant

- Slug: bar-assistant
- URL: https://www.canagentsuse.com/tools/bar-assistant
- Website: https://barassistant.app/
- Docs: https://github.com/karlomikus/bar-assistant
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Recipe Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Triage work
- Best for: Self-hosted recipe management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP, Docker. Source code: https://github.com/karlomikus/bar-assistant
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Bar Assistant is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://barassistant.app/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/karlomikus/bar-assistant
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/karlomikus/bar-assistant
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/karlomikus/bar-assistant
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/karlomikus/bar-assistant

### Beaver Habit Tracker

- Slug: beaver-habit-tracker
- URL: https://www.canagentsuse.com/tools/beaver-habit-tracker
- Website: https://github.com/daya0576/beaverhabits
- Docs: https://github.com/daya0576/beaverhabits
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Time Tracking
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted time tracking workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as BSD-3-Clause; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/daya0576/beaverhabits
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Beaver Habit Tracker is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/daya0576/beaverhabits
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/daya0576/beaverhabits
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/daya0576/beaverhabits
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/daya0576/beaverhabits
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/daya0576/beaverhabits

### beelzebub

- Slug: beelzebub
- URL: https://www.canagentsuse.com/tools/beelzebub
- Website: https://beelzebub-honeypot.com/
- Docs: https://github.com/beelzebub-labs/beelzebub
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Network Utilities
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted network utilities workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, K8S, Go. Source code: https://github.com/beelzebub-labs/beelzebub
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

beelzebub is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://beelzebub-honeypot.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/beelzebub-labs/beelzebub
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/beelzebub-labs/beelzebub
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/beelzebub-labs/beelzebub
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/beelzebub-labs/beelzebub

### Beets

- Slug: beets
- URL: https://www.canagentsuse.com/tools/beets
- Website: https://beets.io/
- Docs: https://github.com/beetbox/beets
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Media Streaming - Audio Streaming
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted media streaming - audio streaming workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python, deb. Source code: https://github.com/beetbox/beets
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Beets is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://beets.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/beetbox/beets
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/beetbox/beets
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/beetbox/beets
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/beetbox/beets

### Bencher

- Slug: bencher
- URL: https://www.canagentsuse.com/tools/bencher
- Website: https://bencher.dev/
- Docs: https://github.com/bencherdev/bencher
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Software Development - Testing
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted software development - testing workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT, Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Rust. Source code: https://github.com/bencherdev/bencher
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Bencher is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://bencher.dev/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/bencherdev/bencher
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/bencherdev/bencher
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/bencherdev/bencher
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/bencherdev/bencher

### bewCloud

- Slug: bewcloud
- URL: https://www.canagentsuse.com/tools/bewcloud
- Website: https://bewcloud.com
- Docs: https://github.com/bewcloud/bewcloud
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, File Transfer & Synchronization, Groupware, Feed Readers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted file transfer & synchronization workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/bewcloud/bewcloud
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

bewCloud is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://bewcloud.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/bewcloud/bewcloud
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/bewcloud/bewcloud
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/bewcloud/bewcloud
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/bewcloud/bewcloud

### BigBlueButton

- Slug: bigbluebutton
- URL: https://www.canagentsuse.com/tools/bigbluebutton
- Website: https://bigbluebutton.org/
- Docs: https://github.com/bigbluebutton/bigbluebutton
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Video Conferencing
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - video conferencing workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as LGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Java. Source code: https://github.com/bigbluebutton/bigbluebutton
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

BigBlueButton is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://bigbluebutton.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/bigbluebutton/bigbluebutton
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/bigbluebutton/bigbluebutton
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/bigbluebutton/bigbluebutton
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/bigbluebutton/bigbluebutton

### bin

- Slug: bin
- URL: https://www.canagentsuse.com/tools/bin
- Website: https://github.com/w4/bin
- Docs: https://github.com/w4/bin
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Pastebins
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted pastebins workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as WTFPL, 0BSD; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Rust. Source code: https://github.com/w4/bin
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

bin is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/w4/bin
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/w4/bin
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/w4/bin
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/w4/bin
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/w4/bin

### Bitcart

- Slug: bitcart
- URL: https://www.canagentsuse.com/tools/bitcart
- Website: https://bitcart.ai
- Docs: https://github.com/bitcart/bitcart
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Money, Budgeting & Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted money, budgeting & management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Python, Nodejs. Source code: https://github.com/bitcart/bitcart
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Bitcart is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://bitcart.ai
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/bitcart/bitcart
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/bitcart/bitcart
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/bitcart/bitcart
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/bitcart/bitcart

### Blinko

- Slug: blinko
- URL: https://www.canagentsuse.com/tools/blinko
- Website: https://blinko.space/
- Docs: https://github.com/blinkospace/blinko
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Note-taking & Editors
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted note-taking & editors workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/blinkospace/blinko
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Blinko is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://blinko.space/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/blinkospace/blinko
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/blinkospace/blinko
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/blinkospace/blinko
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/blinkospace/blinko

### blocky

- Slug: blocky
- URL: https://www.canagentsuse.com/tools/blocky
- Website: https://0xerr0r.github.io/blocky/latest/
- Docs: https://github.com/0xERR0R/blocky
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, DNS
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted dns workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker. Source code: https://github.com/0xERR0R/blocky
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

blocky is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://0xerr0r.github.io/blocky/latest/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/0xERR0R/blocky
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/0xERR0R/blocky
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/0xERR0R/blocky
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/0xERR0R/blocky

### Bludit

- Slug: bludit
- URL: https://www.canagentsuse.com/tools/bludit
- Website: https://www.bludit.com/
- Docs: https://github.com/bludit/bludit
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Content Management Systems (CMS)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Analyze product, Publish content
- Best for: Self-hosted content management systems (cms) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/bludit/bludit
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Bludit is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.bludit.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/bludit/bludit
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/bludit/bludit
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/bludit/bludit
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/bludit/bludit

### Bluecherry

- Slug: bluecherry
- URL: https://www.canagentsuse.com/tools/bluecherry
- Website: https://www.bluecherrydvr.com/
- Docs: https://github.com/bluecherrydvr/bluecherry-apps
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Video Surveillance
- Use cases: Self-host a tool, Inspect open source, Analyze product
- Best for: Self-hosted video surveillance workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/bluecherrydvr/bluecherry-apps
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Bluecherry is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.bluecherrydvr.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/bluecherrydvr/bluecherry-apps
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/bluecherrydvr/bluecherry-apps
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/bluecherrydvr/bluecherry-apps
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/bluecherrydvr/bluecherry-apps

### Bolt CMS

- Slug: bolt-cms
- URL: https://www.canagentsuse.com/tools/bolt-cms
- Website: https://boltcms.io/
- Docs: https://github.com/bolt/core
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Content Management Systems (CMS)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted content management systems (cms) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/bolt/core
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Bolt CMS is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://boltcms.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/bolt/core
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/bolt/core
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/bolt/core
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/bolt/core

### Bookwyrm

- Slug: bookwyrm
- URL: https://www.canagentsuse.com/tools/bookwyrm
- Website: https://joinbookwyrm.com/
- Docs: https://github.com/bookwyrm-social/bookwyrm
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Document Management - E-books
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted document management - e-books workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as ⊘ Proprietary; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python. Source code: https://github.com/bookwyrm-social/bookwyrm
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Bookwyrm is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://joinbookwyrm.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/bookwyrm-social/bookwyrm
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/bookwyrm-social/bookwyrm
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/bookwyrm-social/bookwyrm
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/bookwyrm-social/bookwyrm

### Bubo Reader

- Slug: bubo-reader
- URL: https://www.canagentsuse.com/tools/bubo-reader
- Website: https://github.com/georgemandis/bubo-rss
- Docs: https://github.com/georgemandis/bubo-rss
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Feed Readers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted feed readers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs. Source code: https://github.com/georgemandis/bubo-rss
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Bubo Reader is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/georgemandis/bubo-rss
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/georgemandis/bubo-rss
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/georgemandis/bubo-rss
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/georgemandis/bubo-rss
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/georgemandis/bubo-rss

### BuddyPress

- Slug: buddypress
- URL: https://www.canagentsuse.com/tools/buddypress
- Website: https://buddypress.org/about/
- Docs: https://github.com/buddypress/BuddyPress
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Social Networks and Forums
- Use cases: Self-host a tool, Inspect open source, Analyze product, Publish content
- Best for: Self-hosted communication - social networks and forums workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/buddypress/BuddyPress
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

BuddyPress is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://buddypress.org/about/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/buddypress/BuddyPress
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/buddypress/BuddyPress
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/buddypress/BuddyPress
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/buddypress/BuddyPress

### Budibase

- Slug: budibase
- URL: https://www.canagentsuse.com/tools/budibase
- Website: https://www.budibase.com
- Docs: https://github.com/Budibase/budibase
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Software Development - Low Code
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted software development - low code workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as ⊘ Proprietary; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker, K8S. Source code: https://github.com/Budibase/budibase
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Budibase is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.budibase.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Budibase/budibase
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Budibase/budibase
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Budibase/budibase
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Budibase/budibase

### Buffer

- Slug: buffer
- URL: https://www.canagentsuse.com/tools/buffer
- Website: https://buffer.com
- Docs: https://support.buffer.com/article/859-does-buffer-have-an-api
- Agent score: 52
- Agent tier: Usable with gaps
- Categories: Social media
- Use cases: Publish content
- Best for: Cross-network social scheduling, content calendars, and simple social automation.
- Limitations: Key limitations: Brand voice, platform policy, media requirements, and accidental posting need human approval. Posting, moderation, DMs, paid campaigns, platform policy, brand voice, and account reputation should stay human-reviewed for public or customer-facing actions. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states.
- Pricing: Public channel/team-based pricing with free plan.
- Auth: Buffer account auth and API access.
- Account creation: Self-serve signup.
- Browser support: Calendar UI is useful for review and approval.
- CLI: Not listed
- API base: https://api.bufferapp.com
- MCP server: Not listed

Agents can schedule content through one interface, but media/network-specific requirements and approvals still matter.

Score breakdown:
- Machine operability: 12/25
- Agent safety: 4.4/25
- Agent readability: 17.4/20
- Auth and setup: 12/15
- Production reliability: 6.4/15

Capabilities:
- API: strong. Buffer documents API-supported posting across Instagram, Threads, LinkedIn, X, Facebook, TikTok, and more. Evidence: https://support.buffer.com/article/859-does-buffer-have-an-api
- Browser: strong. Approval and calendar review are browser-first. Evidence: https://support.buffer.com/article/859-does-buffer-have-an-api
- Account creation: strong. Self-serve signup. Evidence: https://buffer.com
- Pricing clarity: strong. Pricing is public by channels and users. Evidence: https://buffer.com/pricing
- Docs quality: strong. Official docs are listed for API behavior, authentication, limits, examples, and setup review. Evidence: https://support.buffer.com/article/859-does-buffer-have-an-api

### Bugsink

- Slug: bugsink
- URL: https://www.canagentsuse.com/tools/bugsink
- Website: https://www.bugsink.com/
- Docs: https://github.com/bugsink/bugsink/
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Ticketing
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted ticketing workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as ⊘ Proprietary; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python, Docker. Source code: https://github.com/bugsink/bugsink/
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Bugsink is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.bugsink.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/bugsink/bugsink/
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/bugsink/bugsink/
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/bugsink/bugsink/
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/bugsink/bugsink/

### Bugzilla

- Slug: bugzilla
- URL: https://www.canagentsuse.com/tools/bugzilla
- Website: https://www.bugzilla.org/
- Docs: https://github.com/bugzilla/bugzilla
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Ticketing
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted ticketing workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Perl. Source code: https://github.com/bugzilla/bugzilla
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Bugzilla is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.bugzilla.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/bugzilla/bugzilla
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/bugzilla/bugzilla
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/bugzilla/bugzilla
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/bugzilla/bugzilla

### Buku

- Slug: buku
- URL: https://www.canagentsuse.com/tools/buku
- Website: https://github.com/jarun/Buku
- Docs: https://github.com/jarun/Buku
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Bookmarks and Link Sharing
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted bookmarks and link sharing workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python, deb. Source code: https://github.com/jarun/Buku
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Buku is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/jarun/Buku
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/jarun/Buku
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/jarun/Buku
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/jarun/Buku
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/jarun/Buku

### ByteStash

- Slug: bytestash
- URL: https://www.canagentsuse.com/tools/bytestash
- Website: https://github.com/jordan-dalby/ByteStash
- Docs: https://github.com/jordan-dalby/ByteStash
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Pastebins
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted pastebins workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/jordan-dalby/ByteStash
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

ByteStash is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/jordan-dalby/ByteStash
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/jordan-dalby/ByteStash
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/jordan-dalby/ByteStash
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/jordan-dalby/ByteStash
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/jordan-dalby/ByteStash

### Cal.diy

- Slug: cal-diy
- URL: https://www.canagentsuse.com/tools/cal-diy
- Website: https://cal.diy/
- Docs: https://github.com/calcom/cal.diy
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Booking and Scheduling
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted booking and scheduling workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs. Source code: https://github.com/calcom/cal.diy
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Cal.diy is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://cal.diy/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/calcom/cal.diy
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/calcom/cal.diy
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/calcom/cal.diy
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/calcom/cal.diy

### Calibre Web Automated

- Slug: calibre-web-automated
- URL: https://www.canagentsuse.com/tools/calibre-web-automated
- Website: https://github.com/crocodilestick/Calibre-Web-Automated
- Docs: https://github.com/crocodilestick/Calibre-Web-Automated
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Document Management - E-books
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted document management - e-books workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/crocodilestick/Calibre-Web-Automated
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Calibre Web Automated is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/crocodilestick/Calibre-Web-Automated
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/crocodilestick/Calibre-Web-Automated
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/crocodilestick/Calibre-Web-Automated
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/crocodilestick/Calibre-Web-Automated
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/crocodilestick/Calibre-Web-Automated

### Canary Tokens

- Slug: canary-tokens
- URL: https://www.canagentsuse.com/tools/canary-tokens
- Website: https://canarytokens.org
- Docs: https://github.com/thinkst/opencanary
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Network Utilities
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted network utilities workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as BSD-3-Clause; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Python. Source code: https://github.com/thinkst/opencanary
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Canary Tokens is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://canarytokens.org
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/thinkst/opencanary
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/thinkst/opencanary
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/thinkst/opencanary
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/thinkst/opencanary

### Canvas LMS

- Slug: canvas-lms
- URL: https://www.canagentsuse.com/tools/canvas-lms
- Website: https://www.instructure.com/canvas/
- Docs: https://github.com/instructure/canvas-lms
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Learning and Courses
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted learning and courses workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Ruby. Source code: https://github.com/instructure/canvas-lms
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Canvas LMS is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.instructure.com/canvas/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/instructure/canvas-lms
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/instructure/canvas-lms
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/instructure/canvas-lms
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/instructure/canvas-lms

### CasaOS

- Slug: casaos
- URL: https://www.canagentsuse.com/tools/casaos
- Website: https://casaos.zimaspace.com/
- Docs: https://github.com/IceWhaleTech/CasaOS
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Self-hosting Solutions
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted self-hosting solutions workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker. Source code: https://github.com/IceWhaleTech/CasaOS
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

CasaOS is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://casaos.zimaspace.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/IceWhaleTech/CasaOS
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/IceWhaleTech/CasaOS
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/IceWhaleTech/CasaOS
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/IceWhaleTech/CasaOS

### Chamilo LMS

- Slug: chamilo-lms
- URL: https://www.canagentsuse.com/tools/chamilo-lms
- Website: https://chamilo.org/
- Docs: https://github.com/chamilo/chamilo-lms
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Learning and Courses
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted learning and courses workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/chamilo/chamilo-lms
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Chamilo LMS is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://chamilo.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/chamilo/chamilo-lms
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/chamilo/chamilo-lms
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/chamilo/chamilo-lms
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/chamilo/chamilo-lms

### ChannelTube

- Slug: channeltube
- URL: https://www.canagentsuse.com/tools/channeltube
- Website: https://github.com/TheWicklowWolf/ChannelTube
- Docs: https://github.com/TheWicklowWolf/ChannelTube
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Media Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted media management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/TheWicklowWolf/ChannelTube
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

ChannelTube is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/TheWicklowWolf/ChannelTube
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/TheWicklowWolf/ChannelTube
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/TheWicklowWolf/ChannelTube
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/TheWicklowWolf/ChannelTube
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/TheWicklowWolf/ChannelTube

### Chatwoot

- Slug: chatwoot
- URL: https://www.canagentsuse.com/tools/chatwoot
- Website: https://www.chatwoot.com
- Docs: https://github.com/chatwoot/chatwoot
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Custom Communication Systems
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - custom communication systems workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as ⊘ Proprietary; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Ruby, Docker, K8S. Source code: https://github.com/chatwoot/chatwoot
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Chatwoot is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.chatwoot.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/chatwoot/chatwoot
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/chatwoot/chatwoot
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/chatwoot/chatwoot
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/chatwoot/chatwoot

### Chevereto

- Slug: chevereto
- URL: https://www.canagentsuse.com/tools/chevereto
- Website: https://chevereto.com/
- Docs: https://github.com/chevereto/chevereto
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Photo Galleries
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted photo galleries workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP, Docker. Source code: https://github.com/chevereto/chevereto
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Chevereto is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://chevereto.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/chevereto/chevereto
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/chevereto/chevereto
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/chevereto/chevereto
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/chevereto/chevereto

### Chhoto URL

- Slug: chhoto-url
- URL: https://www.canagentsuse.com/tools/chhoto-url
- Website: https://github.com/SinTan1729/chhoto-url
- Docs: https://github.com/SinTan1729/chhoto-url
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, URL Shorteners
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted url shorteners workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Rust, Docker. Source code: https://github.com/SinTan1729/chhoto-url
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Chhoto URL is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/SinTan1729/chhoto-url
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/SinTan1729/chhoto-url
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/SinTan1729/chhoto-url
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/SinTan1729/chhoto-url
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/SinTan1729/chhoto-url

### Chirpy

- Slug: chirpy
- URL: https://www.canagentsuse.com/tools/chirpy
- Website: https://chirpy.dev
- Docs: https://github.com/devrsi0n/chirpy
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Social Networks and Forums
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - social networks and forums workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Nodejs. Source code: https://github.com/devrsi0n/chirpy
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Chirpy is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://chirpy.dev
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/devrsi0n/chirpy
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/devrsi0n/chirpy
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/devrsi0n/chirpy
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/devrsi0n/chirpy

### ChronoFrame

- Slug: chronoframe
- URL: https://www.canagentsuse.com/tools/chronoframe
- Website: https://chronoframe.bh8.ga/
- Docs: https://github.com/HoshinoSuzumi/chronoframe
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Photo Galleries
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted photo galleries workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/HoshinoSuzumi/chronoframe
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

ChronoFrame is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://chronoframe.bh8.ga/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/HoshinoSuzumi/chronoframe
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/HoshinoSuzumi/chronoframe
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/HoshinoSuzumi/chronoframe
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/HoshinoSuzumi/chronoframe

### CKAN

- Slug: ckan
- URL: https://www.canagentsuse.com/tools/ckan
- Website: https://ckan.org
- Docs: https://github.com/ckan/ckan
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Archiving and Digital Preservation (DP)
- Use cases: Self-host a tool, Inspect open source, Triage work
- Best for: Self-hosted archiving and digital preservation (dp) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python. Source code: https://github.com/ckan/ckan
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

CKAN is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://ckan.org
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/ckan/ckan
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/ckan/ckan
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/ckan/ckan
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/ckan/ckan

### Cloudreve

- Slug: cloudreve
- URL: https://www.canagentsuse.com/tools/cloudreve
- Website: https://cloudreve.org/
- Docs: https://github.com/cloudreve/cloudreve
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, File Transfer & Synchronization
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted file transfer & synchronization workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Go. Source code: https://github.com/cloudreve/cloudreve
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Cloudreve is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://cloudreve.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/cloudreve/cloudreve
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/cloudreve/cloudreve
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/cloudreve/cloudreve
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/cloudreve/cloudreve

### CNCjs

- Slug: cncjs
- URL: https://www.canagentsuse.com/tools/cncjs
- Website: https://cnc.js.org/
- Docs: https://github.com/cncjs/cncjs/
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Manufacturing
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted manufacturing workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs. Source code: https://github.com/cncjs/cncjs/
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

CNCjs is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://cnc.js.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/cncjs/cncjs/
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/cncjs/cncjs/
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/cncjs/cncjs/
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/cncjs/cncjs/

### Cockpit

- Slug: cockpit
- URL: https://www.canagentsuse.com/tools/cockpit
- Website: https://getcockpit.com
- Docs: https://github.com/Cockpit-HQ/Cockpit
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Content Management Systems (CMS)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted content management systems (cms) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/Cockpit-HQ/Cockpit
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Cockpit is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://getcockpit.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Cockpit-HQ/Cockpit
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Cockpit-HQ/Cockpit
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Cockpit-HQ/Cockpit
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Cockpit-HQ/Cockpit

### Coder

- Slug: coder
- URL: https://www.canagentsuse.com/tools/coder
- Website: https://coder.com/
- Docs: https://github.com/coder/coder
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Software Development - IDE & Tools
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted software development - ide & tools workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker, K8S, deb. Source code: https://github.com/coder/coder
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Coder is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://coder.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/coder/coder
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/coder/coder
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/coder/coder
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/coder/coder

### Collective Access - Providence

- Slug: collective-access-providence
- URL: https://www.canagentsuse.com/tools/collective-access-providence
- Website: https://collectiveaccess.org/
- Docs: https://github.com/collectiveaccess/providence
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Archiving and Digital Preservation (DP)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Triage work
- Best for: Self-hosted archiving and digital preservation (dp) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/collectiveaccess/providence
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Collective Access - Providence is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://collectiveaccess.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/collectiveaccess/providence
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/collectiveaccess/providence
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/collectiveaccess/providence
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/collectiveaccess/providence

### CommaFeed

- Slug: commafeed
- URL: https://www.canagentsuse.com/tools/commafeed
- Website: https://www.commafeed.com/
- Docs: https://github.com/Athou/commafeed
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Feed Readers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted feed readers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Java, Docker. Source code: https://github.com/Athou/commafeed
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

CommaFeed is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.commafeed.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Athou/commafeed
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Athou/commafeed
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Athou/commafeed
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Athou/commafeed

### Concrete 5 CMS

- Slug: concrete-5-cms
- URL: https://www.canagentsuse.com/tools/concrete-5-cms
- Website: https://www.concretecms.com
- Docs: https://github.com/concretecms/concretecms
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Content Management Systems (CMS)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted content management systems (cms) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/concretecms/concretecms
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Concrete 5 CMS is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.concretecms.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/concretecms/concretecms
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/concretecms/concretecms
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/concretecms/concretecms
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/concretecms/concretecms

### Contao

- Slug: contao
- URL: https://www.canagentsuse.com/tools/contao
- Website: https://contao.org/
- Docs: https://github.com/contao/contao/
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Content Management Systems (CMS)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted content management systems (cms) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as LGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/contao/contao/
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Contao is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://contao.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/contao/contao/
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/contao/contao/
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/contao/contao/
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/contao/contao/

### ConvertX

- Slug: convertx
- URL: https://www.canagentsuse.com/tools/convertx
- Website: https://github.com/C4illin/ConvertX
- Docs: https://github.com/C4illin/ConvertX
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Miscellaneous
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted miscellaneous workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/C4illin/ConvertX
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

ConvertX is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/C4illin/ConvertX
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/C4illin/ConvertX
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/C4illin/ConvertX
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/C4illin/ConvertX
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/C4illin/ConvertX

### Coral

- Slug: coral
- URL: https://www.canagentsuse.com/tools/coral
- Website: https://coralproject.net/
- Docs: https://github.com/coralproject/talk
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Social Networks and Forums
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - social networks and forums workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Nodejs. Source code: https://github.com/coralproject/talk
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Coral is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://coralproject.net/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/coralproject/talk
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/coralproject/talk
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/coralproject/talk
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/coralproject/talk

### CoreShop

- Slug: coreshop
- URL: https://www.canagentsuse.com/tools/coreshop
- Website: https://www.coreshop.org
- Docs: https://github.com/coreshop/CoreShop
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, E-commerce
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted e-commerce workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/coreshop/CoreShop
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

CoreShop is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.coreshop.org
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/coreshop/CoreShop
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/coreshop/CoreShop
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/coreshop/CoreShop
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/coreshop/CoreShop

### CouchCMS

- Slug: couchcms
- URL: https://www.canagentsuse.com/tools/couchcms
- Website: https://www.couchcms.com/
- Docs: https://github.com/CouchCMS/CouchCMS
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Content Management Systems (CMS)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted content management systems (cms) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as CPAL-1.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/CouchCMS/CouchCMS
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

CouchCMS is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.couchcms.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/CouchCMS/CouchCMS
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/CouchCMS/CouchCMS
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/CouchCMS/CouchCMS
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/CouchCMS/CouchCMS

### CraftCMS

- Slug: craftcms
- URL: https://www.canagentsuse.com/tools/craftcms
- Website: https://craftcms.com/
- Docs: https://github.com/craftcms/cms
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Content Management Systems (CMS)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted content management systems (cms) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as ⊘ Proprietary; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/craftcms/cms
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

CraftCMS is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://craftcms.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/craftcms/cms
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/craftcms/cms
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/craftcms/cms
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/craftcms/cms

### CryptPad

- Slug: cryptpad
- URL: https://www.canagentsuse.com/tools/cryptpad
- Website: https://cryptpad.org
- Docs: https://github.com/cryptpad/cryptpad
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Office Suites
- Use cases: Self-host a tool, Inspect open source, Publish content
- Best for: Self-hosted office suites workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/cryptpad/cryptpad
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

CryptPad is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://cryptpad.org
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/cryptpad/cryptpad
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/cryptpad/cryptpad
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/cryptpad/cryptpad
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/cryptpad/cryptpad

### CUPS

- Slug: cups
- URL: https://www.canagentsuse.com/tools/cups
- Website: https://www.cups.org/
- Docs: https://github.com/OpenPrinting/cups
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Miscellaneous
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted miscellaneous workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C. Source code: https://github.com/OpenPrinting/cups
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

CUPS is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.cups.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/OpenPrinting/cups
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/OpenPrinting/cups
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/OpenPrinting/cups
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/OpenPrinting/cups

### CyberChef

- Slug: cyberchef
- URL: https://www.canagentsuse.com/tools/cyberchef
- Website: https://github.com/gchq/CyberChef
- Docs: https://github.com/gchq/CyberChef
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Miscellaneous
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted miscellaneous workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Javascript. Source code: https://github.com/gchq/CyberChef
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

CyberChef is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/gchq/CyberChef
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/gchq/CyberChef
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/gchq/CyberChef
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/gchq/CyberChef
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/gchq/CyberChef

### CyTube

- Slug: cytube
- URL: https://www.canagentsuse.com/tools/cytube
- Website: https://github.com/calzoneman/sync
- Docs: https://github.com/calzoneman/sync
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Media Streaming - Video Streaming
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted media streaming - video streaming workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs. Source code: https://github.com/calzoneman/sync
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

CyTube is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/calzoneman/sync
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/calzoneman/sync
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/calzoneman/sync
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/calzoneman/sync
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/calzoneman/sync

### DailyTxT

- Slug: dailytxt
- URL: https://www.canagentsuse.com/tools/dailytxt
- Website: https://github.com/PhiTux/DailyTxT
- Docs: https://github.com/PhiTux/DailyTxT
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Note-taking & Editors
- Use cases: Self-host a tool, Inspect open source, Triage work
- Best for: Self-hosted note-taking & editors workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/PhiTux/DailyTxT
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

DailyTxT is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/PhiTux/DailyTxT
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/PhiTux/DailyTxT
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/PhiTux/DailyTxT
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/PhiTux/DailyTxT
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/PhiTux/DailyTxT

### Dashy

- Slug: dashy
- URL: https://www.canagentsuse.com/tools/dashy
- Website: https://dashy.to/
- Docs: https://github.com/lissy93/dashy
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Personal Dashboards
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted personal dashboards workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/lissy93/dashy
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Dashy is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://dashy.to/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/lissy93/dashy
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/lissy93/dashy
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/lissy93/dashy
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/lissy93/dashy

### Databag

- Slug: databag
- URL: https://www.canagentsuse.com/tools/databag
- Website: https://github.com/balzack/databag
- Docs: https://github.com/balzack/databag
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Custom Communication Systems
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - custom communication systems workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/balzack/databag
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Databag is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/balzack/databag
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/balzack/databag
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/balzack/databag
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/balzack/databag
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/balzack/databag

### Dawarich

- Slug: dawarich
- URL: https://www.canagentsuse.com/tools/dawarich
- Website: https://dawarich.app/
- Docs: https://github.com/Freika/dawarich
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Maps and Global Positioning System (GPS)
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted maps and global positioning system (gps) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/Freika/dawarich
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Dawarich is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://dawarich.app/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Freika/dawarich
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Freika/dawarich
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Freika/dawarich
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Freika/dawarich

### DDraceNetwork

- Slug: ddracenetwork
- URL: https://www.canagentsuse.com/tools/ddracenetwork
- Website: https://ddnet.org/
- Docs: https://github.com/ddnet/ddnet
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Games
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted games workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Zlib; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C++. Source code: https://github.com/ddnet/ddnet
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

DDraceNetwork is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://ddnet.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/ddnet/ddnet
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/ddnet/ddnet
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/ddnet/ddnet
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/ddnet/ddnet

### DebOps

- Slug: debops
- URL: https://www.canagentsuse.com/tools/debops
- Website: https://docs.debops.org/
- Docs: https://github.com/debops/debops
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Email - Complete Solutions
- Use cases: Self-host a tool, Inspect open source, Triage work
- Best for: Self-hosted communication - email - complete solutions workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Ansible, Python. Source code: https://github.com/debops/debops
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

DebOps is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://docs.debops.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/debops/debops
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/debops/debops
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/debops/debops
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/debops/debops

### Deleterr

- Slug: deleterr
- URL: https://www.canagentsuse.com/tools/deleterr
- Website: https://github.com/rfsbraz/deleterr
- Docs: https://github.com/rfsbraz/deleterr
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Media Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted media management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/rfsbraz/deleterr
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Deleterr is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/rfsbraz/deleterr
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/rfsbraz/deleterr
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/rfsbraz/deleterr
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/rfsbraz/deleterr
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/rfsbraz/deleterr

### DietPi

- Slug: dietpi
- URL: https://www.canagentsuse.com/tools/dietpi
- Website: https://dietpi.com/
- Docs: https://github.com/MichaIng/DietPi
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Self-hosting Solutions
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted self-hosting solutions workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Shell. Source code: https://github.com/MichaIng/DietPi
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

DietPi is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://dietpi.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/MichaIng/DietPi
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/MichaIng/DietPi
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/MichaIng/DietPi
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/MichaIng/DietPi

### Dify.ai

- Slug: dify-ai
- URL: https://www.canagentsuse.com/tools/dify-ai
- Website: https://dify.ai
- Docs: https://github.com/langgenius/dify
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Software Development - Low Code
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted software development - low code workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0, Commons-Clause; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/langgenius/dify
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Dify.ai is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://dify.ai
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/langgenius/dify
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/langgenius/dify
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/langgenius/dify
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/langgenius/dify

### Directory Lister

- Slug: directory-lister
- URL: https://www.canagentsuse.com/tools/directory-lister
- Website: https://www.directorylister.com/
- Docs: https://github.com/DirectoryLister/DirectoryLister
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, File Transfer - Web-based File Managers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted file transfer - web-based file managers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP, Docker. Source code: https://github.com/DirectoryLister/DirectoryLister
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Directory Lister is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.directorylister.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/DirectoryLister/DirectoryLister
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/DirectoryLister/DirectoryLister
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/DirectoryLister/DirectoryLister
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/DirectoryLister/DirectoryLister

### Discourse

- Slug: discourse
- URL: https://www.canagentsuse.com/tools/discourse
- Website: https://www.discourse.org/
- Docs: https://github.com/discourse/discourse
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Social Networks and Forums
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - social networks and forums workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/discourse/discourse
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Discourse is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.discourse.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/discourse/discourse
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/discourse/discourse
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/discourse/discourse
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/discourse/discourse

### Django-CRM

- Slug: django-crm
- URL: https://www.canagentsuse.com/tools/django-crm
- Website: https://DjangoCRM.github.io/info/
- Docs: https://github.com/DjangoCRM/django-crm
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Customer Relationship Management (CRM)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted customer relationship management (crm) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python. Source code: https://github.com/DjangoCRM/django-crm
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Django-CRM is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://DjangoCRM.github.io/info/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/DjangoCRM/django-crm
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/DjangoCRM/django-crm
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/DjangoCRM/django-crm
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/DjangoCRM/django-crm

### DOCAT

- Slug: docat
- URL: https://www.canagentsuse.com/tools/docat
- Website: https://github.com/docat-org/docat
- Docs: https://github.com/docat-org/docat
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Miscellaneous
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted miscellaneous workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python, Docker. Source code: https://github.com/docat-org/docat
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

DOCAT is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/docat-org/docat
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/docat-org/docat
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/docat-org/docat
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/docat-org/docat
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/docat-org/docat

### docmost

- Slug: docmost
- URL: https://www.canagentsuse.com/tools/docmost
- Website: https://docmost.com/
- Docs: https://github.com/docmost/docmost
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Wikis
- Use cases: Self-host a tool, Inspect open source, Publish content
- Best for: Self-hosted wikis workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Nodejs. Source code: https://github.com/docmost/docmost
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

docmost is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://docmost.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/docmost/docmost
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/docmost/docmost
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/docmost/docmost
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/docmost/docmost

### Docs

- Slug: docs
- URL: https://www.canagentsuse.com/tools/docs
- Website: https://docs.numerique.gouv.fr/
- Docs: https://github.com/suitenumerique/docs
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Note-taking & Editors, Knowledge Management Tools
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted note-taking & editors workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: K8S. Source code: https://github.com/suitenumerique/docs
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Docs is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://docs.numerique.gouv.fr/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/suitenumerique/docs
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/suitenumerique/docs
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/suitenumerique/docs
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/suitenumerique/docs

### Docspell

- Slug: docspell
- URL: https://www.canagentsuse.com/tools/docspell
- Website: https://docspell.org
- Docs: https://github.com/eikek/docspell
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Document Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content, Triage work
- Best for: Self-hosted document management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Scala, Java, Docker. Source code: https://github.com/eikek/docspell
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Docspell is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://docspell.org
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/eikek/docspell
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/eikek/docspell
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/eikek/docspell
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/eikek/docspell

### Documenso

- Slug: documenso
- URL: https://www.canagentsuse.com/tools/documenso
- Website: https://documenso.com
- Docs: https://github.com/documenso/documenso
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Document Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted document management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/documenso/documenso
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Documenso is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://documenso.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/documenso/documenso
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/documenso/documenso
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/documenso/documenso
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/documenso/documenso

### Documize

- Slug: documize
- URL: https://www.canagentsuse.com/tools/documize
- Website: https://documize.com
- Docs: https://github.com/documize/community
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Wikis
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted wikis workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go. Source code: https://github.com/documize/community
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Documize is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://documize.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/documize/community
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/documize/community
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/documize/community
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/documize/community

### Docuseal

- Slug: docuseal
- URL: https://www.canagentsuse.com/tools/docuseal
- Website: https://www.docuseal.co
- Docs: https://github.com/docusealco/docuseal
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Document Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted document management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/docusealco/docuseal
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Docuseal is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.docuseal.co
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/docusealco/docuseal
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/docusealco/docuseal
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/docusealco/docuseal
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/docusealco/docuseal

### Dolibarr

- Slug: dolibarr
- URL: https://www.canagentsuse.com/tools/dolibarr
- Website: https://www.dolibarr.org/
- Docs: https://github.com/Dolibarr/dolibarr
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Resource Planning, Customer Relationship Management (CRM)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted resource planning workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP, deb. Source code: https://github.com/Dolibarr/dolibarr
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Dolibarr is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.dolibarr.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Dolibarr/dolibarr
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Dolibarr/dolibarr
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Dolibarr/dolibarr
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Dolibarr/dolibarr

### Domain Locker

- Slug: domain-locker
- URL: https://www.canagentsuse.com/tools/domain-locker
- Website: https://domain-locker.com
- Docs: https://github.com/lissy93/domain-locker
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Miscellaneous
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted miscellaneous workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Deno, Docker. Source code: https://github.com/lissy93/domain-locker
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Domain Locker is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://domain-locker.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/lissy93/domain-locker
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/lissy93/domain-locker
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/lissy93/domain-locker
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/lissy93/domain-locker

### DOMJudge

- Slug: domjudge
- URL: https://www.canagentsuse.com/tools/domjudge
- Website: https://www.domjudge.org/
- Docs: https://github.com/DOMjudge/domjudge
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Miscellaneous
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted miscellaneous workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0, BSD-3-Clause, MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/DOMjudge/domjudge
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

DOMJudge is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.domjudge.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/DOMjudge/domjudge
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/DOMjudge/domjudge
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/DOMjudge/domjudge
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/DOMjudge/domjudge

### Downtify

- Slug: downtify
- URL: https://www.canagentsuse.com/tools/downtify
- Website: https://downtify.henriquesebastiao.com
- Docs: https://github.com/henriquesebastiao/downtify
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Media Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Triage work
- Best for: Self-hosted media management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/henriquesebastiao/downtify
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Downtify is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://downtify.henriquesebastiao.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/henriquesebastiao/downtify
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/henriquesebastiao/downtify
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/henriquesebastiao/downtify
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/henriquesebastiao/downtify

### dpaste

- Slug: dpaste
- URL: https://www.canagentsuse.com/tools/dpaste
- Website: https://dpaste.org/
- Docs: https://github.com/DarrenOfficial/dpaste
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Pastebins
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted pastebins workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Python. Source code: https://github.com/DarrenOfficial/dpaste
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

dpaste is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://dpaste.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/DarrenOfficial/dpaste
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/DarrenOfficial/dpaste
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/DarrenOfficial/dpaste
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/DarrenOfficial/dpaste

### DragonFly

- Slug: dragonfly
- URL: https://www.canagentsuse.com/tools/dragonfly
- Website: https://github.com/corecode/dma
- Docs: https://github.com/corecode/dma
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Email - Mail Transfer Agents
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - email - mail transfer agents workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as BSD-3-Clause; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C. Source code: https://github.com/corecode/dma
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

DragonFly is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/corecode/dma
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/corecode/dma
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/corecode/dma
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/corecode/dma
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/corecode/dma

### draw.io

- Slug: draw-io
- URL: https://www.canagentsuse.com/tools/draw-io
- Website: https://draw.io
- Docs: https://github.com/jgraph/drawio
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Note-taking & Editors
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted note-taking & editors workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Javascript, Docker. Source code: https://github.com/jgraph/drawio
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

draw.io is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://draw.io
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/jgraph/drawio
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/jgraph/drawio
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/jgraph/drawio
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/jgraph/drawio

### Drop

- Slug: drop
- URL: https://www.canagentsuse.com/tools/drop
- Website: https://droposs.org
- Docs: https://github.com/Drop-OSS/drop
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Games - Administrative Utilities & Control Panels
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted games - administrative utilities & control panels workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/Drop-OSS/drop
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Drop is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://droposs.org
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Drop-OSS/drop
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Drop-OSS/drop
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Drop-OSS/drop
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Drop-OSS/drop

### Druid

- Slug: druid
- URL: https://www.canagentsuse.com/tools/druid
- Website: https://druid.apache.org
- Docs: https://github.com/apache/druid
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Analytics
- Use cases: Self-host a tool, Inspect open source, Analyze product, Triage work
- Best for: Self-hosted analytics workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Java, Docker. Source code: https://github.com/apache/druid
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Druid is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://druid.apache.org
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/apache/druid
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/apache/druid
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/apache/druid
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/apache/druid

### DSpace

- Slug: dspace
- URL: https://www.canagentsuse.com/tools/dspace
- Website: http://www.dspace.org/
- Docs: https://github.com/DSpace/DSpace
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Document Management - Institutional Repository and Digital Library Software
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted document management - institutional repository and digital library software workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as BSD-3-Clause; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Java. Source code: https://github.com/DSpace/DSpace
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

DSpace is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: http://www.dspace.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/DSpace/DSpace
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/DSpace/DSpace
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/DSpace/DSpace
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/DSpace/DSpace

### Easy!Appointments

- Slug: easy-appointments
- URL: https://www.canagentsuse.com/tools/easy-appointments
- Website: https://easyappointments.org/
- Docs: https://github.com/alextselegidis/easyappointments
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Booking and Scheduling
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted booking and scheduling workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/alextselegidis/easyappointments
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Easy!Appointments is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://easyappointments.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/alextselegidis/easyappointments
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/alextselegidis/easyappointments
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/alextselegidis/easyappointments
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/alextselegidis/easyappointments

### eigenfocus

- Slug: eigenfocus
- URL: https://www.canagentsuse.com/tools/eigenfocus
- Website: https://eigenfocus.com/
- Docs: https://github.com/Eigenfocus/eigenfocus
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Software Development - Project Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted software development - project management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as ⊘ Proprietary; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/Eigenfocus/eigenfocus
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

eigenfocus is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://eigenfocus.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Eigenfocus/eigenfocus
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Eigenfocus/eigenfocus
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Eigenfocus/eigenfocus
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Eigenfocus/eigenfocus

### Elgg

- Slug: elgg
- URL: https://www.canagentsuse.com/tools/elgg
- Website: https://elgg.org/
- Docs: https://github.com/Elgg/Elgg
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Social Networks and Forums
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - social networks and forums workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/Elgg/Elgg
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Elgg is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://elgg.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Elgg/Elgg
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Elgg/Elgg
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Elgg/Elgg
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Elgg/Elgg

### EMQX

- Slug: emqx
- URL: https://www.canagentsuse.com/tools/emqx
- Website: https://www.emqx.io/
- Docs: https://github.com/emqx/emqx
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Internet of Things (IoT)
- Use cases: Self-host a tool, Inspect open source, Triage work
- Best for: Self-hosted internet of things (iot) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Erlang. Source code: https://github.com/emqx/emqx
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

EMQX is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.emqx.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/emqx/emqx
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/emqx/emqx
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/emqx/emqx
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/emqx/emqx

### Enigma 1/2 BBS

- Slug: enigma-1-2-bbs
- URL: https://www.canagentsuse.com/tools/enigma-1-2-bbs
- Website: https://nuskooler.github.io/enigma-bbs/
- Docs: https://github.com/NuSkooler/enigma-bbs
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Social Networks and Forums
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - social networks and forums workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as BSD-2-Clause; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Shell, Docker, Nodejs. Source code: https://github.com/NuSkooler/enigma-bbs
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Enigma 1/2 BBS is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://nuskooler.github.io/enigma-bbs/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/NuSkooler/enigma-bbs
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/NuSkooler/enigma-bbs
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/NuSkooler/enigma-bbs
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/NuSkooler/enigma-bbs

### Ente

- Slug: ente
- URL: https://www.canagentsuse.com/tools/ente
- Website: https://ente.io/
- Docs: https://github.com/ente-io/ente
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Photo Galleries
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted photo galleries workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Nodejs, Go. Source code: https://github.com/ente-io/ente
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Ente is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://ente.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/ente-io/ente
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/ente-io/ente
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/ente-io/ente
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/ente-io/ente

### ERPNext

- Slug: erpnext
- URL: https://www.canagentsuse.com/tools/erpnext
- Website: https://frappe.io/erpnext
- Docs: https://github.com/frappe/erpnext
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Resource Planning
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted resource planning workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python, Docker. Source code: https://github.com/frappe/erpnext
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

ERPNext is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://frappe.io/erpnext
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/frappe/erpnext
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/frappe/erpnext
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/frappe/erpnext
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/frappe/erpnext

### Erxes

- Slug: erxes
- URL: https://www.canagentsuse.com/tools/erxes
- Website: https://erxes.io/install/
- Docs: https://github.com/erxes/erxes
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Ticketing
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted ticketing workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0, Commons-Clause; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Nodejs. Source code: https://github.com/erxes/erxes
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Erxes is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://erxes.io/install/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/erxes/erxes
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/erxes/erxes
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/erxes/erxes
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/erxes/erxes

### Etherpad

- Slug: etherpad
- URL: https://www.canagentsuse.com/tools/etherpad
- Website: https://etherpad.org/
- Docs: https://github.com/ether/etherpad
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Office Suites
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted office suites workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/ether/etherpad
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Etherpad is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://etherpad.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/ether/etherpad
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/ether/etherpad
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/ether/etherpad
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/ether/etherpad

### evcc

- Slug: evcc
- URL: https://www.canagentsuse.com/tools/evcc
- Website: https://evcc.io/
- Docs: https://github.com/evcc-io/evcc
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Internet of Things (IoT)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted internet of things (iot) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: deb, Docker, Go. Source code: https://github.com/evcc-io/evcc
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

evcc is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://evcc.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/evcc-io/evcc
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/evcc-io/evcc
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/evcc-io/evcc
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/evcc-io/evcc

### Ever Gauzy

- Slug: ever-gauzy
- URL: https://www.canagentsuse.com/tools/ever-gauzy
- Website: https://gauzy.co
- Docs: https://github.com/ever-co/ever-gauzy
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Time Tracking, Inventory Management, Resource Planning
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted time tracking workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Nodejs. Source code: https://github.com/ever-co/ever-gauzy
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Ever Gauzy is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://gauzy.co
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/ever-co/ever-gauzy
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/ever-co/ever-gauzy
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/ever-co/ever-gauzy
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/ever-co/ever-gauzy

### EverShop

- Slug: evershop
- URL: https://www.canagentsuse.com/tools/evershop
- Website: https://evershop.io/
- Docs: https://github.com/evershopcommerce/evershop
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, E-commerce
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted e-commerce workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Nodejs. Source code: https://github.com/evershopcommerce/evershop
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

EverShop is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://evershop.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/evershopcommerce/evershop
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/evershopcommerce/evershop
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/evershopcommerce/evershop
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/evershopcommerce/evershop

### EveryDocs

- Slug: everydocs
- URL: https://www.canagentsuse.com/tools/everydocs
- Website: https://github.com/jonashellmann/everydocs-core
- Docs: https://github.com/jonashellmann/everydocs-core
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Document Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted document management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Ruby. Source code: https://github.com/jonashellmann/everydocs-core
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

EveryDocs is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/jonashellmann/everydocs-core
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/jonashellmann/everydocs-core
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/jonashellmann/everydocs-core
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/jonashellmann/everydocs-core
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/jonashellmann/everydocs-core

### ExpenseOwl

- Slug: expenseowl
- URL: https://www.canagentsuse.com/tools/expenseowl
- Website: https://github.com/tanq16/expenseowl
- Docs: https://github.com/tanq16/expenseowl
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Money, Budgeting & Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted money, budgeting & management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker, K8S. Source code: https://github.com/tanq16/expenseowl
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

ExpenseOwl is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/tanq16/expenseowl
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/tanq16/expenseowl
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/tanq16/expenseowl
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/tanq16/expenseowl
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/tanq16/expenseowl

### ezbookkeeping

- Slug: ezbookkeeping
- URL: https://www.canagentsuse.com/tools/ezbookkeeping
- Website: https://ezbookkeeping.mayswind.net/
- Docs: https://github.com/mayswind/ezbookkeeping
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Money, Budgeting & Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted money, budgeting & management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker. Source code: https://github.com/mayswind/ezbookkeeping
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

ezbookkeeping is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://ezbookkeeping.mayswind.net/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/mayswind/ezbookkeeping
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/mayswind/ezbookkeeping
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/mayswind/ezbookkeeping
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/mayswind/ezbookkeeping

### Family Accounting Tool

- Slug: family-accounting-tool
- URL: https://www.canagentsuse.com/tools/family-accounting-tool
- Website: https://github.com/nymanjens/facto
- Docs: https://github.com/nymanjens/facto
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Money, Budgeting & Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted money, budgeting & management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Scala. Source code: https://github.com/nymanjens/facto
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Family Accounting Tool is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/nymanjens/facto
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/nymanjens/facto
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/nymanjens/facto
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/nymanjens/facto
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/nymanjens/facto

### farmOS

- Slug: farmos
- URL: https://www.canagentsuse.com/tools/farmos
- Website: https://farmos.org/
- Docs: https://github.com/farmOS/farmOS
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Resource Planning
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted resource planning workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP, Docker. Source code: https://github.com/farmOS/farmOS
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

farmOS is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://farmos.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/farmOS/farmOS
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/farmOS/farmOS
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/farmOS/farmOS
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/farmOS/farmOS

### Fava

- Slug: fava
- URL: https://www.canagentsuse.com/tools/fava
- Website: https://beancount.github.io/fava/
- Docs: https://github.com/beancount/fava
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Money, Budgeting & Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted money, budgeting & management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python. Source code: https://github.com/beancount/fava
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Fava is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://beancount.github.io/fava/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/beancount/fava
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/beancount/fava
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/beancount/fava
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/beancount/fava

### Featbit

- Slug: featbit
- URL: https://www.canagentsuse.com/tools/featbit
- Website: https://www.featbit.co/
- Docs: https://github.com/featbit/featbit
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Software Development - Feature Toggle
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted software development - feature toggle workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, K8S. Source code: https://github.com/featbit/featbit
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Featbit is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.featbit.co/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/featbit/featbit
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/featbit/featbit
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/featbit/featbit
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/featbit/featbit

### Fedora Commons Repository

- Slug: fedora-commons-repository
- URL: https://www.canagentsuse.com/tools/fedora-commons-repository
- Website: https://wiki.lyrasis.org/display/FF/Fedora+Repository+Home
- Docs: https://github.com/fcrepo/fcrepo
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Document Management - Institutional Repository and Digital Library Software
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content, Triage work
- Best for: Self-hosted document management - institutional repository and digital library software workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Java. Source code: https://github.com/fcrepo/fcrepo
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Fedora Commons Repository is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://wiki.lyrasis.org/display/FF/Fedora+Repository+Home
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/fcrepo/fcrepo
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/fcrepo/fcrepo
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/fcrepo/fcrepo
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/fcrepo/fcrepo

### Feedpushr

- Slug: feedpushr
- URL: https://www.canagentsuse.com/tools/feedpushr
- Website: https://github.com/ncarlier/feedpushr
- Docs: https://github.com/ncarlier/feedpushr
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Feed Readers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted feed readers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker. Source code: https://github.com/ncarlier/feedpushr
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Feedpushr is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/ncarlier/feedpushr
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/ncarlier/feedpushr
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/ncarlier/feedpushr
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/ncarlier/feedpushr
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/ncarlier/feedpushr

### Feeds Fun

- Slug: feeds-fun
- URL: https://www.canagentsuse.com/tools/feeds-fun
- Website: https://feeds.fun/
- Docs: https://github.com/Tiendil/feeds.fun
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Feed Readers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted feed readers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as BSD-3-Clause; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python. Source code: https://github.com/Tiendil/feeds.fun
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Feeds Fun is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://feeds.fun/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Tiendil/feeds.fun
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Tiendil/feeds.fun
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Tiendil/feeds.fun
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Tiendil/feeds.fun

### filebrowser

- Slug: filebrowser
- URL: https://www.canagentsuse.com/tools/filebrowser
- Website: https://filebrowser.org/
- Docs: https://github.com/filebrowser/filebrowser
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, File Transfer - Web-based File Managers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted file transfer - web-based file managers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go. Source code: https://github.com/filebrowser/filebrowser
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

filebrowser is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://filebrowser.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/filebrowser/filebrowser
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/filebrowser/filebrowser
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/filebrowser/filebrowser
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/filebrowser/filebrowser

### FileGator

- Slug: filegator
- URL: https://www.canagentsuse.com/tools/filegator
- Website: https://filegator.io/
- Docs: https://github.com/filegator/filegator
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, File Transfer - Web-based File Managers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted file transfer - web-based file managers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP, Docker. Source code: https://github.com/filegator/filegator
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

FileGator is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://filegator.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/filegator/filegator
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/filegator/filegator
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/filegator/filegator
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/filegator/filegator

### FileRise

- Slug: filerise
- URL: https://www.canagentsuse.com/tools/filerise
- Website: https://github.com/error311/FileRise
- Docs: https://github.com/error311/FileRise
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, File Transfer - Web-based File Managers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted file transfer - web-based file managers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, PHP. Source code: https://github.com/error311/FileRise
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

FileRise is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/error311/FileRise
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/error311/FileRise
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/error311/FileRise
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/error311/FileRise
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/error311/FileRise

### Filestash

- Slug: filestash
- URL: https://www.canagentsuse.com/tools/filestash
- Website: https://www.filestash.app/
- Docs: https://github.com/mickael-kerjean/filestash
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, File Transfer - Web-based File Managers
- Use cases: Self-host a tool, Inspect open source, Triage work
- Best for: Self-hosted file transfer - web-based file managers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/mickael-kerjean/filestash
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Filestash is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.filestash.app/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/mickael-kerjean/filestash
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/mickael-kerjean/filestash
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/mickael-kerjean/filestash
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/mickael-kerjean/filestash

### Firefly III

- Slug: firefly-iii
- URL: https://www.canagentsuse.com/tools/firefly-iii
- Website: https://firefly-iii.org/
- Docs: https://github.com/firefly-iii/firefly-iii
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Money, Budgeting & Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Triage work
- Best for: Self-hosted money, budgeting & management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP, Docker. Source code: https://github.com/firefly-iii/firefly-iii
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Firefly III is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://firefly-iii.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/firefly-iii/firefly-iii
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/firefly-iii/firefly-iii
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/firefly-iii/firefly-iii
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/firefly-iii/firefly-iii

### Firezone

- Slug: firezone
- URL: https://www.canagentsuse.com/tools/firezone
- Website: https://www.firezone.dev/
- Docs: https://github.com/firezone/firezone
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Remote Access
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted remote access workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Elixir, Docker. Source code: https://github.com/firezone/firezone
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Firezone is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.firezone.dev/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/firezone/firezone
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/firezone/firezone
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/firezone/firezone
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/firezone/firezone

### FitTrackee

- Slug: fittrackee
- URL: https://www.canagentsuse.com/tools/fittrackee
- Website: https://docs.fittrackee.org/
- Docs: https://github.com/SamR1/FitTrackee
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Health and Fitness
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted health and fitness workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python, Docker. Source code: https://github.com/SamR1/FitTrackee
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

FitTrackee is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://docs.fittrackee.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/SamR1/FitTrackee
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/SamR1/FitTrackee
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/SamR1/FitTrackee
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/SamR1/FitTrackee

### Flarum

- Slug: flarum
- URL: https://www.canagentsuse.com/tools/flarum
- Website: https://flarum.org
- Docs: https://github.com/flarum/flarum
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Social Networks and Forums
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - social networks and forums workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/flarum/flarum
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Flarum is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://flarum.org
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/flarum/flarum
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/flarum/flarum
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/flarum/flarum
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/flarum/flarum

### Flipt

- Slug: flipt
- URL: https://www.canagentsuse.com/tools/flipt
- Website: https://flipt.io
- Docs: https://github.com/flipt-io/flipt
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Software Development - Feature Toggle
- Use cases: Self-host a tool, Inspect open source, Triage work
- Best for: Self-hosted software development - feature toggle workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, K8S, Go. Source code: https://github.com/flipt-io/flipt
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Flipt is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://flipt.io
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/flipt-io/flipt
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/flipt-io/flipt
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/flipt-io/flipt
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/flipt-io/flipt

### FlowForge

- Slug: flowforge
- URL: https://www.canagentsuse.com/tools/flowforge
- Website: https://flowforge.com/
- Docs: https://github.com/FlowFuse/flowfuse
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Internet of Things (IoT)
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted internet of things (iot) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker, K8S. Source code: https://github.com/FlowFuse/flowfuse
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

FlowForge is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://flowforge.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/FlowFuse/flowfuse
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/FlowFuse/flowfuse
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/FlowFuse/flowfuse
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/FlowFuse/flowfuse

### Fluidd

- Slug: fluidd
- URL: https://www.canagentsuse.com/tools/fluidd
- Website: https://docs.fluidd.xyz/
- Docs: https://github.com/fluidd-core/fluidd
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Manufacturing
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted manufacturing workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Nodejs. Source code: https://github.com/fluidd-core/fluidd
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Fluidd is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://docs.fluidd.xyz/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/fluidd-core/fluidd
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/fluidd-core/fluidd
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/fluidd-core/fluidd
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/fluidd-core/fluidd

### Flyimg

- Slug: flyimg
- URL: https://www.canagentsuse.com/tools/flyimg
- Website: https://flyimg.io
- Docs: https://github.com/flyimg/flyimg
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Miscellaneous
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted miscellaneous workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/flyimg/flyimg
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Flyimg is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://flyimg.io
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/flyimg/flyimg
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/flyimg/flyimg
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/flyimg/flyimg
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/flyimg/flyimg

### Focalboard

- Slug: focalboard
- URL: https://www.canagentsuse.com/tools/focalboard
- Website: https://www.focalboard.com/
- Docs: https://github.com/mattermost-community/focalboard
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Task Management & To-do Lists
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted task management & to-do lists workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT, AGPL-3.0, Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Go, Docker. Source code: https://github.com/mattermost-community/focalboard
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Focalboard is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.focalboard.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/mattermost-community/focalboard
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/mattermost-community/focalboard
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/mattermost-community/focalboard
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/mattermost-community/focalboard

### Foodsoft

- Slug: foodsoft
- URL: https://www.canagentsuse.com/tools/foodsoft
- Website: https://foodcoops.net/
- Docs: https://github.com/foodcoops/foodsoft
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Community-Supported Agriculture (CSA)
- Use cases: Self-host a tool, Inspect open source, Analyze product
- Best for: Self-hosted community-supported agriculture (csa) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Ruby. Source code: https://github.com/foodcoops/foodsoft
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Foodsoft is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://foodcoops.net/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/foodcoops/foodsoft
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/foodcoops/foodsoft
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/foodcoops/foodsoft
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/foodcoops/foodsoft

### Forward Email

- Slug: forward-email
- URL: https://www.canagentsuse.com/tools/forward-email
- Website: https://forwardemail.net
- Docs: https://github.com/forwardemail/forwardemail.net
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Email - Complete Solutions
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - email - complete solutions workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as BUSL-1.1, MPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/forwardemail/forwardemail.net
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Forward Email is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://forwardemail.net
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/forwardemail/forwardemail.net
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/forwardemail/forwardemail.net
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/forwardemail/forwardemail.net
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/forwardemail/forwardemail.net

### Frappe HR

- Slug: frappe-hr
- URL: https://www.canagentsuse.com/tools/frappe-hr
- Website: https://frappe.io/hr
- Docs: https://github.com/frappe/hrms
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Human Resources Management (HRM)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted human resources management (hrm) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Python, Nodejs. Source code: https://github.com/frappe/hrms
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Frappe HR is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://frappe.io/hr
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/frappe/hrms
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/frappe/hrms
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/frappe/hrms
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/frappe/hrms

### FreeScout

- Slug: freescout
- URL: https://www.canagentsuse.com/tools/freescout
- Website: https://freescout.net/
- Docs: https://github.com/freescout-help-desk/freescout
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Ticketing
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted ticketing workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP, Docker. Source code: https://github.com/freescout-help-desk/freescout
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

FreeScout is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://freescout.net/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/freescout-help-desk/freescout
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/freescout-help-desk/freescout
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/freescout-help-desk/freescout
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/freescout-help-desk/freescout

### FreeSWITCH

- Slug: freeswitch
- URL: https://www.canagentsuse.com/tools/freeswitch
- Website: https://freeswitch.org/
- Docs: https://github.com/signalwire/freeswitch
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - SIP
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - sip workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C. Source code: https://github.com/signalwire/freeswitch
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

FreeSWITCH is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://freeswitch.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/signalwire/freeswitch
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/signalwire/freeswitch
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/signalwire/freeswitch
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/signalwire/freeswitch

### FreshRSS

- Slug: freshrss
- URL: https://www.canagentsuse.com/tools/freshrss
- Website: https://freshrss.org/
- Docs: https://github.com/FreshRSS/FreshRSS
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Feed Readers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted feed readers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP, Docker. Source code: https://github.com/FreshRSS/FreshRSS
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

FreshRSS is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://freshrss.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/FreshRSS/FreshRSS
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/FreshRSS/FreshRSS
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/FreshRSS/FreshRSS
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/FreshRSS/FreshRSS

### Frigate

- Slug: frigate
- URL: https://www.canagentsuse.com/tools/frigate
- Website: https://frigate.video/
- Docs: https://github.com/blakeblackshear/frigate
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Video Surveillance
- Use cases: Self-host a tool, Inspect open source, Analyze product
- Best for: Self-hosted video surveillance workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Python, Nodejs. Source code: https://github.com/blakeblackshear/frigate
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Frigate is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://frigate.video/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/blakeblackshear/frigate
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/blakeblackshear/frigate
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/blakeblackshear/frigate
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/blakeblackshear/frigate

### Fusion

- Slug: fusion
- URL: https://www.canagentsuse.com/tools/fusion
- Website: https://github.com/0x2E/fusion
- Docs: https://github.com/0x2E/fusion
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Feed Readers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted feed readers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker. Source code: https://github.com/0x2E/fusion
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Fusion is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/0x2E/fusion
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/0x2E/fusion
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/0x2E/fusion
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/0x2E/fusion
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/0x2E/fusion

### FusionPBX

- Slug: fusionpbx
- URL: https://www.canagentsuse.com/tools/fusionpbx
- Website: https://www.fusionpbx.com/
- Docs: https://github.com/fusionpbx/fusionpbx
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - SIP
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - sip workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MPL-1.1; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/fusionpbx/fusionpbx
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

FusionPBX is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.fusionpbx.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/fusionpbx/fusionpbx
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/fusionpbx/fusionpbx
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/fusionpbx/fusionpbx
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/fusionpbx/fusionpbx

### Gameyfin

- Slug: gameyfin
- URL: https://www.canagentsuse.com/tools/gameyfin
- Website: https://gameyfin.org
- Docs: https://github.com/gameyfin/gameyfin
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Games - Administrative Utilities & Control Panels
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted games - administrative utilities & control panels workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/gameyfin/gameyfin
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Gameyfin is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://gameyfin.org
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/gameyfin/gameyfin
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/gameyfin/gameyfin
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/gameyfin/gameyfin
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/gameyfin/gameyfin

### Ganymede

- Slug: ganymede
- URL: https://www.canagentsuse.com/tools/ganymede
- Website: https://github.com/Zibbp/ganymede
- Docs: https://github.com/Zibbp/ganymede
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Archiving and Digital Preservation (DP)
- Use cases: Self-host a tool, Inspect open source, Triage work
- Best for: Self-hosted archiving and digital preservation (dp) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/Zibbp/ganymede
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Ganymede is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/Zibbp/ganymede
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Zibbp/ganymede
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Zibbp/ganymede
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Zibbp/ganymede
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Zibbp/ganymede

### Gerrit

- Slug: gerrit
- URL: https://www.canagentsuse.com/tools/gerrit
- Website: https://www.gerritcodereview.com/
- Docs: https://github.com/GerritCodeReview/gerrit
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Software Development - Project Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted software development - project management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Java, Docker. Source code: https://github.com/GerritCodeReview/gerrit
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Gerrit is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.gerritcodereview.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/GerritCodeReview/gerrit
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/GerritCodeReview/gerrit
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/GerritCodeReview/gerrit
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/GerritCodeReview/gerrit

### Ghostfolio

- Slug: ghostfolio
- URL: https://www.canagentsuse.com/tools/ghostfolio
- Website: https://ghostfol.io/
- Docs: https://github.com/ghostfolio/ghostfolio
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Money, Budgeting & Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted money, budgeting & management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Nodejs. Source code: https://github.com/ghostfolio/ghostfolio
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Ghostfolio is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://ghostfol.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/ghostfolio/ghostfolio
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/ghostfolio/ghostfolio
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/ghostfolio/ghostfolio
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/ghostfolio/ghostfolio

### Gibbon

- Slug: gibbon
- URL: https://www.canagentsuse.com/tools/gibbon
- Website: https://gibbonedu.org/
- Docs: https://github.com/GibbonEdu/core
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Learning and Courses
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted learning and courses workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/GibbonEdu/core
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Gibbon is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://gibbonedu.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/GibbonEdu/core
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/GibbonEdu/core
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/GibbonEdu/core
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/GibbonEdu/core

### Gitea

- Slug: gitea
- URL: https://www.canagentsuse.com/tools/gitea
- Website: https://gitea.com
- Docs: https://github.com/go-gitea/gitea
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Software Development - Project Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted software development - project management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker, K8S. Source code: https://github.com/go-gitea/gitea
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Gitea is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://gitea.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/go-gitea/gitea
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/go-gitea/gitea
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/go-gitea/gitea
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/go-gitea/gitea

### Gladys

- Slug: gladys
- URL: https://www.canagentsuse.com/tools/gladys
- Website: https://gladysassistant.com/
- Docs: https://github.com/GladysAssistant/Gladys
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Internet of Things (IoT)
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted internet of things (iot) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/GladysAssistant/Gladys
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Gladys is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://gladysassistant.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/GladysAssistant/Gladys
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/GladysAssistant/Gladys
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/GladysAssistant/Gladys
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/GladysAssistant/Gladys

### Glance

- Slug: glance
- URL: https://www.canagentsuse.com/tools/glance
- Website: https://github.com/glanceapp/glance
- Docs: https://github.com/glanceapp/glance
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Personal Dashboards, Feed Readers
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted personal dashboards workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Go. Source code: https://github.com/glanceapp/glance
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Glance is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/glanceapp/glance
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/glanceapp/glance
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/glanceapp/glance
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/glanceapp/glance
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/glanceapp/glance

### GlobaLeaks

- Slug: globaleaks
- URL: https://www.canagentsuse.com/tools/globaleaks
- Website: https://www.globaleaks.org/
- Docs: https://github.com/globaleaks/globaleaks-whistleblowing-software
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Custom Communication Systems
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - custom communication systems workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python, deb, Docker. Source code: https://github.com/globaleaks/globaleaks-whistleblowing-software
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

GlobaLeaks is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.globaleaks.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/globaleaks/globaleaks-whistleblowing-software
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/globaleaks/globaleaks-whistleblowing-software
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/globaleaks/globaleaks-whistleblowing-software
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/globaleaks/globaleaks-whistleblowing-software

### Glowing Bear

- Slug: glowing-bear
- URL: https://www.canagentsuse.com/tools/glowing-bear
- Website: https://github.com/glowing-bear/glowing-bear
- Docs: https://github.com/glowing-bear/glowing-bear
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - IRC
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - irc workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs. Source code: https://github.com/glowing-bear/glowing-bear
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Glowing Bear is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/glowing-bear/glowing-bear
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/glowing-bear/glowing-bear
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/glowing-bear/glowing-bear
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/glowing-bear/glowing-bear
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/glowing-bear/glowing-bear

### GO Feature Flag

- Slug: go-feature-flag
- URL: https://www.canagentsuse.com/tools/go-feature-flag
- Website: https://gofeatureflag.org
- Docs: https://github.com/thomaspoignant/go-feature-flag
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Software Development - Feature Toggle
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted software development - feature toggle workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go. Source code: https://github.com/thomaspoignant/go-feature-flag
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

GO Feature Flag is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://gofeatureflag.org
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/thomaspoignant/go-feature-flag
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/thomaspoignant/go-feature-flag
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/thomaspoignant/go-feature-flag
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/thomaspoignant/go-feature-flag

### GoatCounter

- Slug: goatcounter
- URL: https://www.canagentsuse.com/tools/goatcounter
- Website: https://www.goatcounter.com
- Docs: https://github.com/arp242/goatcounter
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Analytics
- Use cases: Self-host a tool, Inspect open source, Analyze product, Triage work
- Best for: Self-hosted analytics workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as EUPL-1.2; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go. Source code: https://github.com/arp242/goatcounter
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

GoatCounter is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.goatcounter.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/arp242/goatcounter
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/arp242/goatcounter
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/arp242/goatcounter
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/arp242/goatcounter

### Gogs

- Slug: gogs
- URL: https://www.canagentsuse.com/tools/gogs
- Website: https://gogs.io/
- Docs: https://github.com/gogs/gogs
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Software Development - Project Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted software development - project management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go. Source code: https://github.com/gogs/gogs
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Gogs is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://gogs.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/gogs/gogs
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/gogs/gogs
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/gogs/gogs
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/gogs/gogs

### google-webfonts-helper

- Slug: google-webfonts-helper
- URL: https://www.canagentsuse.com/tools/google-webfonts-helper
- Website: https://github.com/majodev/google-webfonts-helper
- Docs: https://github.com/majodev/google-webfonts-helper
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Miscellaneous
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted miscellaneous workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs. Source code: https://github.com/majodev/google-webfonts-helper
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

google-webfonts-helper is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/majodev/google-webfonts-helper
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/majodev/google-webfonts-helper
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/majodev/google-webfonts-helper
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/majodev/google-webfonts-helper
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/majodev/google-webfonts-helper

### Grist

- Slug: grist
- URL: https://www.canagentsuse.com/tools/grist
- Website: https://getgrist.com/
- Docs: https://github.com/gristlabs/grist-core
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Office Suites
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted office suites workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Python, Docker. Source code: https://github.com/gristlabs/grist-core
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Grist is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://getgrist.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/gristlabs/grist-core
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/gristlabs/grist-core
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/gristlabs/grist-core
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/gristlabs/grist-core

### grocy

- Slug: grocy
- URL: https://www.canagentsuse.com/tools/grocy
- Website: https://grocy.info/
- Docs: https://github.com/grocy/grocy
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Resource Planning, Inventory Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted resource planning workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP, Docker. Source code: https://github.com/grocy/grocy
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

grocy is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://grocy.info/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/grocy/grocy
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/grocy/grocy
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/grocy/grocy
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/grocy/grocy

### Habitica

- Slug: habitica
- URL: https://www.canagentsuse.com/tools/habitica
- Website: https://habitica.com/
- Docs: https://github.com/HabitRPG/habitica
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Miscellaneous
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted miscellaneous workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0, CC-BY-SA-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/HabitRPG/habitica
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Habitica is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://habitica.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/HabitRPG/habitica
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/HabitRPG/habitica
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/HabitRPG/habitica
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/HabitRPG/habitica

### Halo

- Slug: halo
- URL: https://www.canagentsuse.com/tools/halo
- Website: https://www.halo.run
- Docs: https://github.com/halo-dev/halo
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Software Development - Low Code
- Use cases: Self-host a tool, Inspect open source, Publish content
- Best for: Self-hosted software development - low code workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Java, Docker. Source code: https://github.com/halo-dev/halo
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Halo is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.halo.run
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/halo-dev/halo
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/halo-dev/halo
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/halo-dev/halo
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/halo-dev/halo

### HamsterBase Tasks

- Slug: hamsterbase-tasks
- URL: https://www.canagentsuse.com/tools/hamsterbase-tasks
- Website: https://tasks.hamsterbase.com
- Docs: https://github.com/hamsterbase/tasks
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Task Management & To-do Lists
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted task management & to-do lists workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/hamsterbase/tasks
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

HamsterBase Tasks is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://tasks.hamsterbase.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/hamsterbase/tasks
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/hamsterbase/tasks
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/hamsterbase/tasks
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/hamsterbase/tasks

### Headphones

- Slug: headphones
- URL: https://www.canagentsuse.com/tools/headphones
- Website: https://github.com/rembo10/headphones
- Docs: https://github.com/rembo10/headphones
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Media Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted media management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python. Source code: https://github.com/rembo10/headphones
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Headphones is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/rembo10/headphones
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/rembo10/headphones
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/rembo10/headphones
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/rembo10/headphones
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/rembo10/headphones

### HedgeDoc

- Slug: hedgedoc
- URL: https://www.canagentsuse.com/tools/hedgedoc
- Website: https://hedgedoc.org/
- Docs: https://github.com/hedgedoc/hedgedoc
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Note-taking & Editors
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted note-taking & editors workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Nodejs. Source code: https://github.com/hedgedoc/hedgedoc
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

HedgeDoc is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://hedgedoc.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/hedgedoc/hedgedoc
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/hedgedoc/hedgedoc
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/hedgedoc/hedgedoc
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/hedgedoc/hedgedoc

### Hemmelig

- Slug: hemmelig
- URL: https://www.canagentsuse.com/tools/hemmelig
- Website: https://hemmelig.app
- Docs: https://github.com/HemmeligOrg/Hemmelig.app
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Pastebins
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted pastebins workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Nodejs. Source code: https://github.com/HemmeligOrg/Hemmelig.app
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Hemmelig is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://hemmelig.app
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/HemmeligOrg/Hemmelig.app
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/HemmeligOrg/Hemmelig.app
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/HemmeligOrg/Hemmelig.app
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/HemmeligOrg/Hemmelig.app

### Hister

- Slug: hister
- URL: https://www.canagentsuse.com/tools/hister
- Website: https://hister.org/
- Docs: https://github.com/asciimoo/hister
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Search Engines
- Use cases: Self-host a tool, Inspect open source, Triage work
- Best for: Self-hosted search engines workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker. Source code: https://github.com/asciimoo/hister
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Hister is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://hister.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/asciimoo/hister
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/asciimoo/hister
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/asciimoo/hister
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/asciimoo/hister

### HomeBox (SysAdminsMedia)

- Slug: homebox-sysadminsmedia
- URL: https://www.canagentsuse.com/tools/homebox-sysadminsmedia
- Website: https://homebox.software/
- Docs: https://github.com/sysadminsmedia/homebox
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Inventory Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted inventory management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Go. Source code: https://github.com/sysadminsmedia/homebox
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

HomeBox (SysAdminsMedia) is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://homebox.software/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/sysadminsmedia/homebox
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/sysadminsmedia/homebox
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/sysadminsmedia/homebox
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/sysadminsmedia/homebox

### HomeGallery

- Slug: homegallery
- URL: https://www.canagentsuse.com/tools/homegallery
- Website: https://home-gallery.org
- Docs: https://github.com/xemle/home-gallery
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Photo Galleries
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted photo galleries workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/xemle/home-gallery
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

HomeGallery is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://home-gallery.org
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/xemle/home-gallery
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/xemle/home-gallery
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/xemle/home-gallery
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/xemle/home-gallery

### HomelabOS

- Slug: homelabos
- URL: https://www.canagentsuse.com/tools/homelabos
- Website: https://homelabos.com
- Docs: https://gitlab.com/NickBusey/HomelabOS
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Self-hosting Solutions
- Use cases: Self-host a tool, Inspect open source, Triage work
- Best for: Self-hosted self-hosting solutions workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://gitlab.com/NickBusey/HomelabOS
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

HomelabOS is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://homelabos.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://gitlab.com/NickBusey/HomelabOS
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://gitlab.com/NickBusey/HomelabOS
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://gitlab.com/NickBusey/HomelabOS
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://gitlab.com/NickBusey/HomelabOS

### HortusFox

- Slug: hortusfox
- URL: https://www.canagentsuse.com/tools/hortusfox
- Website: https://hortusfox.github.io
- Docs: https://github.com/danielbrendel/hortusfox-web
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Miscellaneous
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted miscellaneous workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP, Docker. Source code: https://github.com/danielbrendel/hortusfox-web
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

HortusFox is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://hortusfox.github.io
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/danielbrendel/hortusfox-web
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/danielbrendel/hortusfox-web
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/danielbrendel/hortusfox-web
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/danielbrendel/hortusfox-web

### Huly

- Slug: huly
- URL: https://www.canagentsuse.com/tools/huly
- Website: https://huly.io
- Docs: https://github.com/hcengineering/platform
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Software Development - Project Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted software development - project management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as EPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, K8S, Nodejs. Source code: https://github.com/hcengineering/platform
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Huly is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://huly.io
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/hcengineering/platform
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/hcengineering/platform
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/hcengineering/platform
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/hcengineering/platform

### HumHub

- Slug: humhub
- URL: https://www.canagentsuse.com/tools/humhub
- Website: https://www.humhub.org/
- Docs: https://github.com/humhub/humhub
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Social Networks and Forums
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - social networks and forums workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/humhub/humhub
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

HumHub is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.humhub.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/humhub/humhub
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/humhub/humhub
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/humhub/humhub
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/humhub/humhub

### Hypersomnia

- Slug: hypersomnia
- URL: https://www.canagentsuse.com/tools/hypersomnia
- Website: https://github.com/TeamHypersomnia/Hypersomnia
- Docs: https://github.com/TeamHypersomnia/Hypersomnia
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Games
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted games workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C++, Docker. Source code: https://github.com/TeamHypersomnia/Hypersomnia
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Hypersomnia is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/TeamHypersomnia/Hypersomnia
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/TeamHypersomnia/Hypersomnia
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/TeamHypersomnia/Hypersomnia
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/TeamHypersomnia/Hypersomnia
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/TeamHypersomnia/Hypersomnia

### Hyphanet

- Slug: hyphanet
- URL: https://www.canagentsuse.com/tools/hyphanet
- Website: https://hyphanet.org/
- Docs: https://github.com/hyphanet/fred
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Custom Communication Systems
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - custom communication systems workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Java. Source code: https://github.com/hyphanet/fred
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Hyphanet is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://hyphanet.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/hyphanet/fred
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/hyphanet/fred
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/hyphanet/fred
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/hyphanet/fred

### I, Librarian

- Slug: i-librarian
- URL: https://www.canagentsuse.com/tools/i-librarian
- Website: https://i-librarian.net
- Docs: https://github.com/mkucej/i-librarian-free
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Document Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content, Triage work
- Best for: Self-hosted document management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/mkucej/i-librarian-free
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

I, Librarian is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://i-librarian.net
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/mkucej/i-librarian-free
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/mkucej/i-librarian-free
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/mkucej/i-librarian-free
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/mkucej/i-librarian-free

### IFM

- Slug: ifm
- URL: https://www.canagentsuse.com/tools/ifm
- Website: https://github.com/misterunknown/ifm
- Docs: https://github.com/misterunknown/ifm
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, File Transfer - Web-based File Managers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted file transfer - web-based file managers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/misterunknown/ifm
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

IFM is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/misterunknown/ifm
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/misterunknown/ifm
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/misterunknown/ifm
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/misterunknown/ifm
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/misterunknown/ifm

### IHateMoney

- Slug: ihatemoney
- URL: https://www.canagentsuse.com/tools/ihatemoney
- Website: https://ihatemoney.org/
- Docs: https://github.com/spiral-project/ihatemoney
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Money, Budgeting & Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted money, budgeting & management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as BSD-3-Clause; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Python. Source code: https://github.com/spiral-project/ihatemoney
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

IHateMoney is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://ihatemoney.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/spiral-project/ihatemoney
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/spiral-project/ihatemoney
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/spiral-project/ihatemoney
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/spiral-project/ihatemoney

### ILIAS

- Slug: ilias
- URL: https://www.canagentsuse.com/tools/ilias
- Website: https://www.ilias.de
- Docs: https://github.com/ILIAS-eLearning/ILIAS
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Learning and Courses
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted learning and courses workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/ILIAS-eLearning/ILIAS
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

ILIAS is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.ilias.de
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/ILIAS-eLearning/ILIAS
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/ILIAS-eLearning/ILIAS
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/ILIAS-eLearning/ILIAS
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/ILIAS-eLearning/ILIAS

### ImgCompress

- Slug: imgcompress
- URL: https://www.canagentsuse.com/tools/imgcompress
- Website: https://imgcompress.karimzouine.com
- Docs: https://github.com/karimz1/imgcompress
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Miscellaneous
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted miscellaneous workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/karimz1/imgcompress
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

ImgCompress is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://imgcompress.karimzouine.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/karimz1/imgcompress
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/karimz1/imgcompress
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/karimz1/imgcompress
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/karimz1/imgcompress

### Immich

- Slug: immich
- URL: https://www.canagentsuse.com/tools/immich
- Website: https://immich.app/
- Docs: https://github.com/immich-app/immich
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Photo Galleries
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted photo galleries workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/immich-app/immich
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Immich is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://immich.app/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/immich-app/immich
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/immich-app/immich
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/immich-app/immich
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/immich-app/immich

### Immich Kiosk

- Slug: immich-kiosk
- URL: https://www.canagentsuse.com/tools/immich-kiosk
- Website: https://github.com/damongolding/immich-kiosk
- Docs: https://github.com/damongolding/immich-kiosk
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Photo Galleries
- Use cases: Self-host a tool, Inspect open source, Triage work
- Best for: Self-hosted photo galleries workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Go. Source code: https://github.com/damongolding/immich-kiosk
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Immich Kiosk is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/damongolding/immich-kiosk
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/damongolding/immich-kiosk
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/damongolding/immich-kiosk
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/damongolding/immich-kiosk
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/damongolding/immich-kiosk

### indico

- Slug: indico
- URL: https://www.canagentsuse.com/tools/indico
- Website: https://getindico.io/
- Docs: https://github.com/indico/indico
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Conference Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted conference management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python. Source code: https://github.com/indico/indico
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

indico is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://getindico.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/indico/indico
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/indico/indico
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/indico/indico
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/indico/indico

### Infisical Community Edition

- Slug: infisical-community-edition
- URL: https://www.canagentsuse.com/tools/infisical-community-edition
- Website: https://infisical.com/
- Docs: https://github.com/Infisical/infisical
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Miscellaneous
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted miscellaneous workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, K8S, deb. Source code: https://github.com/Infisical/infisical
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Infisical Community Edition is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://infisical.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Infisical/infisical
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Infisical/infisical
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Infisical/infisical
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Infisical/infisical

### INGInious

- Slug: inginious
- URL: https://www.canagentsuse.com/tools/inginious
- Website: https://inginious.org/?lang=en
- Docs: https://github.com/INGInious/INGInious
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Learning and Courses
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted learning and courses workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python, Docker. Source code: https://github.com/INGInious/INGInious
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

INGInious is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://inginious.org/?lang=en
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/INGInious/INGInious
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/INGInious/INGInious
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/INGInious/INGInious
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/INGInious/INGInious

### Inventaire

- Slug: inventaire
- URL: https://www.canagentsuse.com/tools/inventaire
- Website: https://inventaire.io/welcome
- Docs: https://codeberg.org/inventaire/inventaire
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Inventory Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content, Triage work
- Best for: Self-hosted inventory management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs. Source code: https://codeberg.org/inventaire/inventaire
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Inventaire is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://inventaire.io/welcome
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://codeberg.org/inventaire/inventaire
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://codeberg.org/inventaire/inventaire
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://codeberg.org/inventaire/inventaire
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://codeberg.org/inventaire/inventaire

### Inventree

- Slug: inventree
- URL: https://www.canagentsuse.com/tools/inventree
- Website: https://docs.inventree.org/en/latest/
- Docs: https://github.com/inventree/InvenTree
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Inventory Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted inventory management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python. Source code: https://github.com/inventree/InvenTree
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Inventree is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://docs.inventree.org/en/latest/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/inventree/InvenTree
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/inventree/InvenTree
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/inventree/InvenTree
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/inventree/InvenTree

### Invidious

- Slug: invidious
- URL: https://www.canagentsuse.com/tools/invidious
- Website: https://github.com/iv-org/invidious
- Docs: https://github.com/iv-org/invidious
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Media Streaming - Video Streaming
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted media streaming - video streaming workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Crystal. Source code: https://github.com/iv-org/invidious
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Invidious is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/iv-org/invidious
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/iv-org/invidious
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/iv-org/invidious
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/iv-org/invidious
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/iv-org/invidious

### InvoicePlane

- Slug: invoiceplane
- URL: https://www.canagentsuse.com/tools/invoiceplane
- Website: https://www.invoiceplane.com/
- Docs: https://github.com/InvoicePlane/InvoicePlane
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Money, Budgeting & Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted money, budgeting & management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/InvoicePlane/InvoicePlane
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

InvoicePlane is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.invoiceplane.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/InvoicePlane/InvoicePlane
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/InvoicePlane/InvoicePlane
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/InvoicePlane/InvoicePlane
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/InvoicePlane/InvoicePlane

### InvoiceShelf

- Slug: invoiceshelf
- URL: https://www.canagentsuse.com/tools/invoiceshelf
- Website: https://invoiceshelf.com/
- Docs: https://github.com/InvoiceShelf/InvoiceShelf
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Money, Budgeting & Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted money, budgeting & management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP, Docker. Source code: https://github.com/InvoiceShelf/InvoiceShelf
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

InvoiceShelf is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://invoiceshelf.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/InvoiceShelf/InvoiceShelf
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/InvoiceShelf/InvoiceShelf
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/InvoiceShelf/InvoiceShelf
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/InvoiceShelf/InvoiceShelf

### iodine

- Slug: iodine
- URL: https://www.canagentsuse.com/tools/iodine
- Website: https://code.kryo.se/iodine/
- Docs: https://github.com/yarrick/iodine
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Proxy
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted proxy workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as ISC; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C, deb. Source code: https://github.com/yarrick/iodine
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

iodine is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://code.kryo.se/iodine/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/yarrick/iodine
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/yarrick/iodine
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/yarrick/iodine
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/yarrick/iodine

### iSponsorBlockTV

- Slug: isponsorblocktv
- URL: https://www.canagentsuse.com/tools/isponsorblocktv
- Website: https://github.com/dmunozv04/iSponsorBlockTV
- Docs: https://github.com/dmunozv04/iSponsorBlockTV
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Miscellaneous
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted miscellaneous workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Python. Source code: https://github.com/dmunozv04/iSponsorBlockTV
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

iSponsorBlockTV is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/dmunozv04/iSponsorBlockTV
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/dmunozv04/iSponsorBlockTV
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/dmunozv04/iSponsorBlockTV
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/dmunozv04/iSponsorBlockTV
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/dmunozv04/iSponsorBlockTV

### IT-Tools by sharevb

- Slug: it-tools-by-sharevb
- URL: https://www.canagentsuse.com/tools/it-tools-by-sharevb
- Website: https://github.com/sharevb/it-tools
- Docs: https://github.com/sharevb/it-tools
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Miscellaneous
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted miscellaneous workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/sharevb/it-tools
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

IT-Tools by sharevb is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/sharevb/it-tools
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/sharevb/it-tools
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/sharevb/it-tools
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/sharevb/it-tools
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/sharevb/it-tools

### Jelu

- Slug: jelu
- URL: https://www.canagentsuse.com/tools/jelu
- Website: https://bayang.github.io/jelu-web
- Docs: https://github.com/bayang/jelu
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Miscellaneous
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted miscellaneous workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Java, Docker. Source code: https://github.com/bayang/jelu
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Jelu is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://bayang.github.io/jelu-web
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/bayang/jelu
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/bayang/jelu
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/bayang/jelu
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/bayang/jelu

### Jitsi Meet

- Slug: jitsi-meet
- URL: https://www.canagentsuse.com/tools/jitsi-meet
- Website: https://jitsi.org/Projects/JitsiMeet
- Docs: https://github.com/jitsi/jitsi-meet
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Video Conferencing
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - video conferencing workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker, deb. Source code: https://github.com/jitsi/jitsi-meet
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Jitsi Meet is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://jitsi.org/Projects/JitsiMeet
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/jitsi/jitsi-meet
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/jitsi/jitsi-meet
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/jitsi/jitsi-meet
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/jitsi/jitsi-meet

### Jitsi Video Bridge

- Slug: jitsi-video-bridge
- URL: https://www.canagentsuse.com/tools/jitsi-video-bridge
- Website: https://jitsi.org/Projects/JitsiVideobridge
- Docs: https://github.com/jitsi/jitsi-videobridge
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Video Conferencing
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - video conferencing workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Java, deb. Source code: https://github.com/jitsi/jitsi-videobridge
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Jitsi Video Bridge is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://jitsi.org/Projects/JitsiVideobridge
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/jitsi/jitsi-videobridge
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/jitsi/jitsi-videobridge
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/jitsi/jitsi-videobridge
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/jitsi/jitsi-videobridge

### Joomla!

- Slug: joomla
- URL: https://www.canagentsuse.com/tools/joomla
- Website: https://www.joomla.org/
- Docs: https://github.com/joomla/joomla-cms
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Content Management Systems (CMS)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted content management systems (cms) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/joomla/joomla-cms
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Joomla! is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.joomla.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/joomla/joomla-cms
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/joomla/joomla-cms
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/joomla/joomla-cms
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/joomla/joomla-cms

### Jotty

- Slug: jotty
- URL: https://www.canagentsuse.com/tools/jotty
- Website: https://jotty.page
- Docs: https://github.com/fccview/jotty
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Note-taking & Editors, Task Management & To-do Lists
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted note-taking & editors workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/fccview/jotty
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Jotty is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://jotty.page
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/fccview/jotty
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/fccview/jotty
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/fccview/jotty
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/fccview/jotty

### JupyterLab

- Slug: jupyterlab
- URL: https://www.canagentsuse.com/tools/jupyterlab
- Website: https://jupyterlab.readthedocs.io/en/stable/
- Docs: https://github.com/jupyterlab/jupyterlab/
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Software Development - IDE & Tools
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted software development - ide & tools workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as BSD-3-Clause; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python, Docker. Source code: https://github.com/jupyterlab/jupyterlab/
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

JupyterLab is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://jupyterlab.readthedocs.io/en/stable/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/jupyterlab/jupyterlab/
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/jupyterlab/jupyterlab/
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/jupyterlab/jupyterlab/
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/jupyterlab/jupyterlab/

### Kanboard

- Slug: kanboard
- URL: https://www.canagentsuse.com/tools/kanboard
- Website: https://kanboard.org/
- Docs: https://github.com/kanboard/kanboard
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Task Management & To-do Lists
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted task management & to-do lists workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/kanboard/kanboard
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Kanboard is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://kanboard.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/kanboard/kanboard
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/kanboard/kanboard
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/kanboard/kanboard
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/kanboard/kanboard

### Kaneo

- Slug: kaneo
- URL: https://www.canagentsuse.com/tools/kaneo
- Website: https://kaneo.app/
- Docs: https://github.com/usekaneo/kaneo
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Software Development - Project Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted software development - project management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: K8S, Docker. Source code: https://github.com/usekaneo/kaneo
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Kaneo is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://kaneo.app/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/usekaneo/kaneo
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/usekaneo/kaneo
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/usekaneo/kaneo
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/usekaneo/kaneo

### Kapowarr

- Slug: kapowarr
- URL: https://www.canagentsuse.com/tools/kapowarr
- Website: https://casvt.github.io/Kapowarr/
- Docs: https://github.com/Casvt/Kapowarr
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Document Management - E-books
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted document management - e-books workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Python. Source code: https://github.com/Casvt/Kapowarr
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Kapowarr is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://casvt.github.io/Kapowarr/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Casvt/Kapowarr
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Casvt/Kapowarr
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Casvt/Kapowarr
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Casvt/Kapowarr

### Karakeep

- Slug: karakeep
- URL: https://www.canagentsuse.com/tools/karakeep
- Website: https://karakeep.app/
- Docs: https://github.com/karakeep-app/karakeep
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Bookmarks and Link Sharing, Pastebins
- Use cases: Self-host a tool, Inspect open source, Triage work
- Best for: Self-hosted bookmarks and link sharing workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/karakeep-app/karakeep
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Karakeep is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://karakeep.app/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/karakeep-app/karakeep
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/karakeep-app/karakeep
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/karakeep-app/karakeep
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/karakeep-app/karakeep

### Karaoke Eternal

- Slug: karaoke-eternal
- URL: https://www.canagentsuse.com/tools/karaoke-eternal
- Website: https://www.karaoke-eternal.com
- Docs: https://github.com/bhj/KaraokeEternal
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Media Streaming - Multimedia Streaming
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted media streaming - multimedia streaming workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as ISC; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Nodejs. Source code: https://github.com/bhj/KaraokeEternal
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Karaoke Eternal is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.karaoke-eternal.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/bhj/KaraokeEternal
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/bhj/KaraokeEternal
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/bhj/KaraokeEternal
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/bhj/KaraokeEternal

### Keila

- Slug: keila
- URL: https://www.canagentsuse.com/tools/keila
- Website: https://www.keila.io
- Docs: https://github.com/pentacent/keila
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Email - Mailing Lists and Newsletters
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - email - mailing lists and newsletters workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/pentacent/keila
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Keila is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.keila.io
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/pentacent/keila
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/pentacent/keila
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/pentacent/keila
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/pentacent/keila

### KeystoneJS

- Slug: keystonejs
- URL: https://www.canagentsuse.com/tools/keystonejs
- Website: https://keystonejs.com/
- Docs: https://github.com/keystonejs/keystone
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Content Management Systems (CMS)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted content management systems (cms) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs. Source code: https://github.com/keystonejs/keystone
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

KeystoneJS is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://keystonejs.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/keystonejs/keystone
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/keystonejs/keystone
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/keystonejs/keystone
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/keystonejs/keystone

### Kill Bill

- Slug: kill-bill
- URL: https://www.canagentsuse.com/tools/kill-bill
- Website: https://killbill.io/
- Docs: https://github.com/killbill/killbill
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Money, Budgeting & Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Analyze product
- Best for: Self-hosted money, budgeting & management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Java, Docker. Source code: https://github.com/killbill/killbill
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Kill Bill is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://killbill.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/killbill/killbill
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/killbill/killbill
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/killbill/killbill
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/killbill/killbill

### Kimai

- Slug: kimai
- URL: https://www.canagentsuse.com/tools/kimai
- Website: https://www.kimai.org/
- Docs: https://github.com/kimai/kimai
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Time Tracking
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted time tracking workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/kimai/kimai
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Kimai is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.kimai.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/kimai/kimai
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/kimai/kimai
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/kimai/kimai
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/kimai/kimai

### Kinto

- Slug: kinto
- URL: https://www.canagentsuse.com/tools/kinto
- Website: https://kinto.readthedocs.org
- Docs: https://github.com/Kinto/kinto
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, File Transfer & Synchronization
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted file transfer & synchronization workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python. Source code: https://github.com/Kinto/kinto
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Kinto is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://kinto.readthedocs.org
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Kinto/kinto
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Kinto/kinto
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Kinto/kinto
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Kinto/kinto

### Kirby

- Slug: kirby
- URL: https://www.canagentsuse.com/tools/kirby
- Website: https://getkirby.com/
- Docs: https://github.com/getkirby/kirby
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Content Management Systems (CMS)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted content management systems (cms) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as ⊘ Proprietary; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/getkirby/kirby
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Kirby is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://getkirby.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/getkirby/kirby
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/getkirby/kirby
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/getkirby/kirby
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/getkirby/kirby

### kiwix-serve

- Slug: kiwix-serve
- URL: https://www.canagentsuse.com/tools/kiwix-serve
- Website: https://github.com/kiwix/kiwix-tools
- Docs: https://github.com/kiwix/kiwix-tools
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Document Management - E-books
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted document management - e-books workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C++. Source code: https://github.com/kiwix/kiwix-tools
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

kiwix-serve is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/kiwix/kiwix-tools
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/kiwix/kiwix-tools
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/kiwix/kiwix-tools
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/kiwix/kiwix-tools
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/kiwix/kiwix-tools

### Kodi

- Slug: kodi
- URL: https://www.canagentsuse.com/tools/kodi
- Website: https://kodi.tv/
- Docs: https://github.com/xbmc/xbmc
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Media Streaming - Multimedia Streaming
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted media streaming - multimedia streaming workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C++, deb. Source code: https://github.com/xbmc/xbmc
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Kodi is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://kodi.tv/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/xbmc/xbmc
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/xbmc/xbmc
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/xbmc/xbmc
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/xbmc/xbmc

### Koha

- Slug: koha
- URL: https://www.canagentsuse.com/tools/koha
- Website: https://koha-community.org/
- Docs: https://github.com/Koha-Community/Koha
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Document Management - Integrated Library Systems (ILS)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Analyze product, Publish content
- Best for: Self-hosted document management - integrated library systems (ils) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Perl. Source code: https://github.com/Koha-Community/Koha
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Koha is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://koha-community.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Koha-Community/Koha
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Koha-Community/Koha
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Koha-Community/Koha
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Koha-Community/Koha

### Koillection

- Slug: koillection
- URL: https://www.canagentsuse.com/tools/koillection
- Website: https://koillection.github.io/
- Docs: https://github.com/benjaminjonard/koillection
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Miscellaneous
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted miscellaneous workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, PHP. Source code: https://github.com/benjaminjonard/koillection
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Koillection is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://koillection.github.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/benjaminjonard/koillection
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/benjaminjonard/koillection
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/benjaminjonard/koillection
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/benjaminjonard/koillection

### Krayin

- Slug: krayin
- URL: https://www.canagentsuse.com/tools/krayin
- Website: https://krayincrm.com/
- Docs: https://github.com/krayin/laravel-crm
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Customer Relationship Management (CRM)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted customer relationship management (crm) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/krayin/laravel-crm
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Krayin is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://krayincrm.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/krayin/laravel-crm
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/krayin/laravel-crm
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/krayin/laravel-crm
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/krayin/laravel-crm

### Kresus

- Slug: kresus
- URL: https://www.canagentsuse.com/tools/kresus
- Website: https://kresus.org/
- Docs: https://github.com/kresusapp/kresus
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Money, Budgeting & Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted money, budgeting & management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/kresusapp/kresus
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Kresus is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://kresus.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/kresusapp/kresus
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/kresusapp/kresus
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/kresusapp/kresus
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/kresusapp/kresus

### Kriss Feed

- Slug: kriss-feed
- URL: https://www.canagentsuse.com/tools/kriss-feed
- Website: https://github.com/tontof/kriss_feed
- Docs: https://github.com/tontof/kriss_feed
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Feed Readers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted feed readers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as CC0-1.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/tontof/kriss_feed
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Kriss Feed is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/tontof/kriss_feed
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/tontof/kriss_feed
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/tontof/kriss_feed
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/tontof/kriss_feed
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/tontof/kriss_feed

### Kutt

- Slug: kutt
- URL: https://www.canagentsuse.com/tools/kutt
- Website: https://kutt.to
- Docs: https://github.com/thedevs-network/kutt
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, URL Shorteners
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted url shorteners workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/thedevs-network/kutt
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Kutt is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://kutt.to
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/thedevs-network/kutt
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/thedevs-network/kutt
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/thedevs-network/kutt
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/thedevs-network/kutt

### Kyoo

- Slug: kyoo
- URL: https://www.canagentsuse.com/tools/kyoo
- Website: https://github.com/zoriya/kyoo
- Docs: https://github.com/zoriya/kyoo
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Media Streaming - Multimedia Streaming
- Use cases: Self-host a tool, Inspect open source, Triage work
- Best for: Self-hosted media streaming - multimedia streaming workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/zoriya/kyoo
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Kyoo is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/zoriya/kyoo
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/zoriya/kyoo
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/zoriya/kyoo
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/zoriya/kyoo
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/zoriya/kyoo

### Lago

- Slug: lago
- URL: https://www.canagentsuse.com/tools/lago
- Website: https://www.getlago.com/
- Docs: https://github.com/getlago/lago
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Money, Budgeting & Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted money, budgeting & management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/getlago/lago
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Lago is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.getlago.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/getlago/lago
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/getlago/lago
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/getlago/lago
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/getlago/lago

### Lancache

- Slug: lancache
- URL: https://www.canagentsuse.com/tools/lancache
- Website: https://lancache.net
- Docs: https://github.com/lancachenet/monolithic
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Games - Administrative Utilities & Control Panels
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted games - administrative utilities & control panels workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Shell. Source code: https://github.com/lancachenet/monolithic
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Lancache is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://lancache.net
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/lancachenet/monolithic
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/lancachenet/monolithic
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/lancachenet/monolithic
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/lancachenet/monolithic

### Langfuse

- Slug: langfuse
- URL: https://www.canagentsuse.com/tools/langfuse
- Website: https://langfuse.com
- Docs: https://github.com/langfuse/langfuse
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Software Development - IDE & Tools
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted software development - ide & tools workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/langfuse/langfuse
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Langfuse is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://langfuse.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/langfuse/langfuse
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/langfuse/langfuse
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/langfuse/langfuse
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/langfuse/langfuse

### LanguageTool

- Slug: languagetool
- URL: https://www.canagentsuse.com/tools/languagetool
- Website: https://languagetool.org/
- Docs: https://github.com/languagetool-org/languagetool
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Miscellaneous
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted miscellaneous workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as LGPL-2.1; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Java, Docker. Source code: https://github.com/languagetool-org/languagetool
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

LanguageTool is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://languagetool.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/languagetool-org/languagetool
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/languagetool-org/languagetool
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/languagetool-org/languagetool
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/languagetool-org/languagetool

### LeafWiki

- Slug: leafwiki
- URL: https://www.canagentsuse.com/tools/leafwiki
- Website: https://github.com/perber/leafwiki
- Docs: https://github.com/perber/leafwiki
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Wikis
- Use cases: Self-host a tool, Inspect open source, Publish content
- Best for: Self-hosted wikis workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Go. Source code: https://github.com/perber/leafwiki
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

LeafWiki is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/perber/leafwiki
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/perber/leafwiki
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/perber/leafwiki
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/perber/leafwiki
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/perber/leafwiki

### Leantime

- Slug: leantime
- URL: https://www.canagentsuse.com/tools/leantime
- Website: https://leantime.io
- Docs: https://github.com/leantime/leantime
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Software Development - Project Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted software development - project management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP, Docker. Source code: https://github.com/leantime/leantime
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Leantime is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://leantime.io
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/leantime/leantime
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/leantime/leantime
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/leantime/leantime
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/leantime/leantime

### LedgerSMB

- Slug: ledgersmb
- URL: https://www.canagentsuse.com/tools/ledgersmb
- Website: https://ledgersmb.org/
- Docs: https://github.com/ledgersmb/LedgerSMB
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Resource Planning
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted resource planning workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Perl. Source code: https://github.com/ledgersmb/LedgerSMB
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

LedgerSMB is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://ledgersmb.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/ledgersmb/LedgerSMB
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/ledgersmb/LedgerSMB
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/ledgersmb/LedgerSMB
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/ledgersmb/LedgerSMB

### Leed

- Slug: leed
- URL: https://www.canagentsuse.com/tools/leed
- Website: https://github.com/LeedRSS/Leed
- Docs: https://github.com/LeedRSS/Leed
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Feed Readers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted feed readers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/LeedRSS/Leed
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Leed is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/LeedRSS/Leed
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/LeedRSS/Leed
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/LeedRSS/Leed
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/LeedRSS/Leed
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/LeedRSS/Leed

### Lemmy

- Slug: lemmy
- URL: https://www.canagentsuse.com/tools/lemmy
- Website: https://join-lemmy.org/
- Docs: https://github.com/LemmyNet/lemmy
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Social Networks and Forums
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - social networks and forums workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Rust. Source code: https://github.com/LemmyNet/lemmy
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Lemmy is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://join-lemmy.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/LemmyNet/lemmy
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/LemmyNet/lemmy
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/LemmyNet/lemmy
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/LemmyNet/lemmy

### LibreBooking

- Slug: librebooking
- URL: https://www.canagentsuse.com/tools/librebooking
- Website: https://librebooking.readthedocs.io/
- Docs: https://github.com/LibreBooking/librebooking
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Booking and Scheduling
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted booking and scheduling workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP, Docker. Source code: https://github.com/LibreBooking/librebooking
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

LibreBooking is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://librebooking.readthedocs.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/LibreBooking/librebooking
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/LibreBooking/librebooking
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/LibreBooking/librebooking
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/LibreBooking/librebooking

### LibreChat

- Slug: librechat
- URL: https://www.canagentsuse.com/tools/librechat
- Website: https://www.librechat.ai
- Docs: https://github.com/danny-avila/LibreChat
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Generative Artificial Intelligence (GenAI)
- Use cases: Self-host a tool, Inspect open source, Triage work
- Best for: Self-hosted generative artificial intelligence (genai) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/danny-avila/LibreChat
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

LibreChat is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.librechat.ai
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/danny-avila/LibreChat
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/danny-avila/LibreChat
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/danny-avila/LibreChat
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/danny-avila/LibreChat

### Libredesk

- Slug: libredesk
- URL: https://www.canagentsuse.com/tools/libredesk
- Website: https://libredesk.io/
- Docs: https://github.com/abhinavxd/libredesk
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Ticketing
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted ticketing workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Go, Nodejs. Source code: https://github.com/abhinavxd/libredesk
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Libredesk is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://libredesk.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/abhinavxd/libredesk
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/abhinavxd/libredesk
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/abhinavxd/libredesk
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/abhinavxd/libredesk

### LibrePhotos

- Slug: librephotos
- URL: https://www.canagentsuse.com/tools/librephotos
- Website: https://github.com/LibrePhotos/librephotos
- Docs: https://github.com/LibrePhotos/librephotos
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Photo Galleries
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted photo galleries workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python, Docker. Source code: https://github.com/LibrePhotos/librephotos
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

LibrePhotos is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/LibrePhotos/librephotos
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/LibrePhotos/librephotos
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/LibrePhotos/librephotos
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/LibrePhotos/librephotos
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/LibrePhotos/librephotos

### LibreTime

- Slug: libretime
- URL: https://www.canagentsuse.com/tools/libretime
- Website: https://libretime.org
- Docs: https://github.com/LibreTime/libretime
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Media Streaming - Audio Streaming
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted media streaming - audio streaming workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, PHP. Source code: https://github.com/LibreTime/libretime
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

LibreTime is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://libretime.org
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/LibreTime/libretime
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/LibreTime/libretime
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/LibreTime/libretime
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/LibreTime/libretime

### Lidarr

- Slug: lidarr
- URL: https://www.canagentsuse.com/tools/lidarr
- Website: https://lidarr.audio/
- Docs: https://github.com/Lidarr/Lidarr
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Media Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted media management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C#, Docker. Source code: https://github.com/Lidarr/Lidarr
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Lidarr is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://lidarr.audio/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Lidarr/Lidarr
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Lidarr/Lidarr
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Lidarr/Lidarr
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Lidarr/Lidarr

### LidaTube

- Slug: lidatube
- URL: https://www.canagentsuse.com/tools/lidatube
- Website: https://github.com/TheWicklowWolf/LidaTube
- Docs: https://github.com/TheWicklowWolf/LidaTube
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Media Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted media management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/TheWicklowWolf/LidaTube
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

LidaTube is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/TheWicklowWolf/LidaTube
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/TheWicklowWolf/LidaTube
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/TheWicklowWolf/LidaTube
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/TheWicklowWolf/LidaTube
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/TheWicklowWolf/LidaTube

### Lidify

- Slug: lidify
- URL: https://www.canagentsuse.com/tools/lidify
- Website: https://github.com/TheWicklowWolf/Lidify
- Docs: https://github.com/TheWicklowWolf/Lidify
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Media Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted media management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/TheWicklowWolf/Lidify
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Lidify is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/TheWicklowWolf/Lidify
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/TheWicklowWolf/Lidify
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/TheWicklowWolf/Lidify
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/TheWicklowWolf/Lidify
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/TheWicklowWolf/Lidify

### linkding

- Slug: linkding
- URL: https://www.canagentsuse.com/tools/linkding
- Website: https://linkding.link/
- Docs: https://github.com/sissbruecker/linkding
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Bookmarks and Link Sharing
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted bookmarks and link sharing workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/sissbruecker/linkding
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

linkding is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://linkding.link/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/sissbruecker/linkding
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/sissbruecker/linkding
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/sissbruecker/linkding
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/sissbruecker/linkding

### LinkStack

- Slug: linkstack
- URL: https://www.canagentsuse.com/tools/linkstack
- Website: https://linkstack.org/
- Docs: https://github.com/LinkStackOrg/LinkStack
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Personal Dashboards
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted personal dashboards workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP, Docker. Source code: https://github.com/LinkStackOrg/LinkStack
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

LinkStack is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://linkstack.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/LinkStackOrg/LinkStack
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/LinkStackOrg/LinkStack
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/LinkStackOrg/LinkStack
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/LinkStackOrg/LinkStack

### LinkWarden

- Slug: linkwarden
- URL: https://www.canagentsuse.com/tools/linkwarden
- Website: https://linkwarden.app/
- Docs: https://github.com/linkwarden/linkwarden
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Bookmarks and Link Sharing
- Use cases: Self-host a tool, Inspect open source, Triage work
- Best for: Self-hosted bookmarks and link sharing workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Nodejs. Source code: https://github.com/linkwarden/linkwarden
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

LinkWarden is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://linkwarden.app/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/linkwarden/linkwarden
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/linkwarden/linkwarden
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/linkwarden/linkwarden
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/linkwarden/linkwarden

### Listmonk

- Slug: listmonk
- URL: https://www.canagentsuse.com/tools/listmonk
- Website: https://listmonk.app/
- Docs: https://github.com/knadh/listmonk
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Email - Mailing Lists and Newsletters
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted communication - email - mailing lists and newsletters workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker. Source code: https://github.com/knadh/listmonk
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Listmonk is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://listmonk.app/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/knadh/listmonk
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/knadh/listmonk
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/knadh/listmonk
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/knadh/listmonk

### Litlyx

- Slug: litlyx
- URL: https://www.canagentsuse.com/tools/litlyx
- Website: https://litlyx.com
- Docs: https://github.com/Litlyx/litlyx
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Analytics
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Analyze product, Triage work
- Best for: Self-hosted analytics workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/Litlyx/litlyx
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Litlyx is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://litlyx.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Litlyx/litlyx
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Litlyx/litlyx
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Litlyx/litlyx
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Litlyx/litlyx

### LittleLink

- Slug: littlelink
- URL: https://www.canagentsuse.com/tools/littlelink
- Website: https://littlelink.io/
- Docs: https://github.com/sethcottle/littlelink
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Personal Dashboards
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted personal dashboards workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Javascript. Source code: https://github.com/sethcottle/littlelink
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

LittleLink is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://littlelink.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/sethcottle/littlelink
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/sethcottle/littlelink
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/sethcottle/littlelink
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/sethcottle/littlelink

### Live Helper Chat

- Slug: live-helper-chat
- URL: https://www.canagentsuse.com/tools/live-helper-chat
- Website: https://livehelperchat.com/
- Docs: https://github.com/LiveHelperChat/livehelperchat
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Custom Communication Systems
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - custom communication systems workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/LiveHelperChat/livehelperchat
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Live Helper Chat is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://livehelperchat.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/LiveHelperChat/livehelperchat
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/LiveHelperChat/livehelperchat
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/LiveHelperChat/livehelperchat
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/LiveHelperChat/livehelperchat

### Livebook

- Slug: livebook
- URL: https://www.canagentsuse.com/tools/livebook
- Website: https://livebook.dev
- Docs: https://github.com/livebook-dev/livebook
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Note-taking & Editors
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted note-taking & editors workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Elixir, Docker. Source code: https://github.com/livebook-dev/livebook
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Livebook is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://livebook.dev
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/livebook-dev/livebook
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/livebook-dev/livebook
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/livebook-dev/livebook
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/livebook-dev/livebook

### LMS

- Slug: lms
- URL: https://www.canagentsuse.com/tools/lms
- Website: https://github.com/epoupon/lms
- Docs: https://github.com/epoupon/lms
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Media Streaming - Audio Streaming
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted media streaming - audio streaming workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, deb, C++. Source code: https://github.com/epoupon/lms
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

LMS is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/epoupon/lms
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/epoupon/lms
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/epoupon/lms
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/epoupon/lms
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/epoupon/lms

### Local Deep Research

- Slug: local-deep-research
- URL: https://www.canagentsuse.com/tools/local-deep-research
- Website: https://github.com/LearningCircuit/local-deep-research
- Docs: https://github.com/LearningCircuit/local-deep-research
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Generative Artificial Intelligence (GenAI)
- Use cases: Self-host a tool, Inspect open source, Triage work
- Best for: Self-hosted generative artificial intelligence (genai) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Python. Source code: https://github.com/LearningCircuit/local-deep-research
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Local Deep Research is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/LearningCircuit/local-deep-research
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/LearningCircuit/local-deep-research
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/LearningCircuit/local-deep-research
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/LearningCircuit/local-deep-research
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/LearningCircuit/local-deep-research

### LocalAI

- Slug: localai
- URL: https://www.canagentsuse.com/tools/localai
- Website: https://localai.io/
- Docs: https://github.com/mudler/LocalAI
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Generative Artificial Intelligence (GenAI)
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted generative artificial intelligence (genai) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, K8S. Source code: https://github.com/mudler/LocalAI
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

LocalAI is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://localai.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/mudler/LocalAI
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/mudler/LocalAI
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/mudler/LocalAI
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/mudler/LocalAI

### Loomio

- Slug: loomio
- URL: https://www.canagentsuse.com/tools/loomio
- Website: https://www.loomio.org/
- Docs: https://github.com/loomio/loomio
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Social Networks and Forums
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - social networks and forums workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/loomio/loomio
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Loomio is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.loomio.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/loomio/loomio
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/loomio/loomio
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/loomio/loomio
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/loomio/loomio

### Lychee

- Slug: lychee
- URL: https://www.canagentsuse.com/tools/lychee
- Website: https://lycheeorg.github.io/
- Docs: https://github.com/LycheeOrg/Lychee
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Photo Galleries
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted photo galleries workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP, Docker. Source code: https://github.com/LycheeOrg/Lychee
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Lychee is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://lycheeorg.github.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/LycheeOrg/Lychee
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/LycheeOrg/Lychee
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/LycheeOrg/Lychee
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/LycheeOrg/Lychee

### Mafl

- Slug: mafl
- URL: https://www.canagentsuse.com/tools/mafl
- Website: https://mafl.hywax.space/
- Docs: https://github.com/hywax/mafl
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Personal Dashboards
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted personal dashboards workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Nodejs. Source code: https://github.com/hywax/mafl
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Mafl is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://mafl.hywax.space/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/hywax/mafl
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/hywax/mafl
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/hywax/mafl
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/hywax/mafl

### Magento Open Source

- Slug: magento-open-source
- URL: https://www.canagentsuse.com/tools/magento-open-source
- Website: https://business.adobe.com/products/magento/magento-commerce.html
- Docs: https://github.com/magento/magento2
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, E-commerce
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted e-commerce workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as OSL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/magento/magento2
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Magento Open Source is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://business.adobe.com/products/magento/magento-commerce.html
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/magento/magento2
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/magento/magento2
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/magento/magento2
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/magento/magento2

### mail-archiver

- Slug: mail-archiver
- URL: https://www.canagentsuse.com/tools/mail-archiver
- Website: https://github.com/s1t5/mail-archiver
- Docs: https://github.com/s1t5/mail-archiver
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Archiving and Digital Preservation (DP)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Triage work
- Best for: Self-hosted archiving and digital preservation (dp) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/s1t5/mail-archiver
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

mail-archiver is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/s1t5/mail-archiver
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/s1t5/mail-archiver
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/s1t5/mail-archiver
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/s1t5/mail-archiver
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/s1t5/mail-archiver

### Mainsail

- Slug: mainsail
- URL: https://www.canagentsuse.com/tools/mainsail
- Website: https://docs.mainsail.xyz/
- Docs: https://github.com/mainsail-crew/mainsail
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Manufacturing
- Use cases: Self-host a tool, Inspect open source, Analyze product
- Best for: Self-hosted manufacturing workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Python. Source code: https://github.com/mainsail-crew/mainsail
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Mainsail is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://docs.mainsail.xyz/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/mainsail-crew/mainsail
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/mainsail-crew/mainsail
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/mainsail-crew/mainsail
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/mainsail-crew/mainsail

### Manage My Damn Life

- Slug: manage-my-damn-life
- URL: https://www.canagentsuse.com/tools/manage-my-damn-life
- Website: https://intri.in/manage-my-damn-life/
- Docs: https://github.com/intri-in/manage-my-damn-life-nextjs
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Calendar & Contacts
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted calendar & contacts workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/intri-in/manage-my-damn-life-nextjs
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Manage My Damn Life is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://intri.in/manage-my-damn-life/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/intri-in/manage-my-damn-life-nextjs
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/intri-in/manage-my-damn-life-nextjs
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/intri-in/manage-my-damn-life-nextjs
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/intri-in/manage-my-damn-life-nextjs

### Manifest

- Slug: manifest
- URL: https://www.canagentsuse.com/tools/manifest
- Website: https://manifest.build
- Docs: https://github.com/mnfst/manifest
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Software Development - Low Code
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted software development - low code workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs. Source code: https://github.com/mnfst/manifest
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Manifest is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://manifest.build
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/mnfst/manifest
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/mnfst/manifest
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/mnfst/manifest
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/mnfst/manifest

### Manticore Search

- Slug: manticore-search
- URL: https://www.canagentsuse.com/tools/manticore-search
- Website: https://github.com/manticoresoftware/manticoresearch/
- Docs: https://github.com/manticoresoftware/manticoresearch/
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Search Engines
- Use cases: Self-host a tool, Inspect open source, Analyze product, Triage work
- Best for: Self-hosted search engines workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, deb, C++, K8S. Source code: https://github.com/manticoresoftware/manticoresearch/
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Manticore Search is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/manticoresoftware/manticoresearch/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/manticoresoftware/manticoresearch/
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/manticoresoftware/manticoresearch/
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/manticoresoftware/manticoresearch/
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/manticoresoftware/manticoresearch/

### MantisBT

- Slug: mantisbt
- URL: https://www.canagentsuse.com/tools/mantisbt
- Website: https://www.mantisbt.org/
- Docs: https://github.com/mantisbt/mantisbt
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Ticketing
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted ticketing workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/mantisbt/mantisbt
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

MantisBT is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.mantisbt.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/mantisbt/mantisbt
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/mantisbt/mantisbt
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/mantisbt/mantisbt
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/mantisbt/mantisbt

### Many Notes

- Slug: many-notes
- URL: https://www.canagentsuse.com/tools/many-notes
- Website: https://github.com/brufdev/many-notes
- Docs: https://github.com/brufdev/many-notes
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Note-taking & Editors
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted note-taking & editors workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/brufdev/many-notes
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Many Notes is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/brufdev/many-notes
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/brufdev/many-notes
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/brufdev/many-notes
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/brufdev/many-notes
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/brufdev/many-notes

### Manyfold

- Slug: manyfold
- URL: https://www.canagentsuse.com/tools/manyfold
- Website: https://manyfold.app
- Docs: https://github.com/manyfold3d/manyfold
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Manufacturing
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted manufacturing workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/manyfold3d/manyfold
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Manyfold is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://manyfold.app
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/manyfold3d/manyfold
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/manyfold3d/manyfold
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/manyfold3d/manyfold
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/manyfold3d/manyfold

### Matomo

- Slug: matomo
- URL: https://www.canagentsuse.com/tools/matomo
- Website: https://matomo.org/
- Docs: https://github.com/matomo-org/matomo
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Analytics
- Use cases: Self-host a tool, Inspect open source, Analyze product, Triage work
- Best for: Self-hosted analytics workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/matomo-org/matomo
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Matomo is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://matomo.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/matomo-org/matomo
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/matomo-org/matomo
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/matomo-org/matomo
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/matomo-org/matomo

### Mattermost

- Slug: mattermost
- URL: https://www.canagentsuse.com/tools/mattermost
- Website: https://mattermost.com/
- Docs: https://github.com/mattermost/mattermost
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Custom Communication Systems
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - custom communication systems workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as ⊘ Proprietary; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker, K8S. Source code: https://github.com/mattermost/mattermost
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Mattermost is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://mattermost.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/mattermost/mattermost
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/mattermost/mattermost
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/mattermost/mattermost
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/mattermost/mattermost

### Mayan EDMS

- Slug: mayan-edms
- URL: https://www.canagentsuse.com/tools/mayan-edms
- Website: https://www.mayan-edms.com
- Docs: https://gitlab.com/mayan-edms/mayan-edms
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Document Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted document management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, K8S. Source code: https://gitlab.com/mayan-edms/mayan-edms
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Mayan EDMS is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.mayan-edms.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://gitlab.com/mayan-edms/mayan-edms
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://gitlab.com/mayan-edms/mayan-edms
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://gitlab.com/mayan-edms/mayan-edms
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://gitlab.com/mayan-edms/mayan-edms

### Maza ad blocking

- Slug: maza-ad-blocking
- URL: https://www.canagentsuse.com/tools/maza-ad-blocking
- Website: https://maza-ad-blocking.andros.dev/
- Docs: https://github.com/tanrax/maza-ad-blocking
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, DNS
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted dns workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Shell. Source code: https://github.com/tanrax/maza-ad-blocking
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Maza ad blocking is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://maza-ad-blocking.andros.dev/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/tanrax/maza-ad-blocking
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/tanrax/maza-ad-blocking
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/tanrax/maza-ad-blocking
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/tanrax/maza-ad-blocking

### Mealie

- Slug: mealie
- URL: https://www.canagentsuse.com/tools/mealie
- Website: https://nightly.mealie.io/
- Docs: https://github.com/mealie-recipes/mealie
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Recipe Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted recipe management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python. Source code: https://github.com/mealie-recipes/mealie
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Mealie is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://nightly.mealie.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/mealie-recipes/mealie
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/mealie-recipes/mealie
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/mealie-recipes/mealie
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/mealie-recipes/mealie

### Medama Analytics

- Slug: medama-analytics
- URL: https://www.canagentsuse.com/tools/medama-analytics
- Website: https://oss.medama.io
- Docs: https://github.com/medama-io/medama
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Analytics
- Use cases: Self-host a tool, Inspect open source, Analyze product
- Best for: Self-hosted analytics workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0, MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Go. Source code: https://github.com/medama-io/medama
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Medama Analytics is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://oss.medama.io
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/medama-io/medama
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/medama-io/medama
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/medama-io/medama
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/medama-io/medama

### Medusa

- Slug: medusa
- URL: https://www.canagentsuse.com/tools/medusa
- Website: https://github.com/pymedusa/Medusa
- Docs: https://github.com/pymedusa/Medusa
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Media Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted media management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python. Source code: https://github.com/pymedusa/Medusa
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Medusa is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/pymedusa/Medusa
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/pymedusa/Medusa
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/pymedusa/Medusa
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/pymedusa/Medusa
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/pymedusa/Medusa

### MedusaJs

- Slug: medusajs
- URL: https://www.canagentsuse.com/tools/medusajs
- Website: https://medusajs.com/
- Docs: https://github.com/medusajs/medusa
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, E-commerce
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted e-commerce workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs. Source code: https://github.com/medusajs/medusa
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

MedusaJs is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://medusajs.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/medusajs/medusa
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/medusajs/medusa
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/medusajs/medusa
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/medusajs/medusa

### Meme Search

- Slug: meme-search
- URL: https://www.canagentsuse.com/tools/meme-search
- Website: https://github.com/neonwatty/meme-search
- Docs: https://github.com/neonwatty/meme-search
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Search Engines
- Use cases: Self-host a tool, Inspect open source, Triage work
- Best for: Self-hosted search engines workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/neonwatty/meme-search
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Meme Search is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/neonwatty/meme-search
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/neonwatty/meme-search
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/neonwatty/meme-search
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/neonwatty/meme-search
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/neonwatty/meme-search

### Memos

- Slug: memos
- URL: https://www.canagentsuse.com/tools/memos
- Website: https://usememos.com/
- Docs: https://github.com/usememos/memos
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Note-taking & Editors
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted note-taking & editors workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Go. Source code: https://github.com/usememos/memos
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Memos is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://usememos.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/usememos/memos
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/usememos/memos
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/usememos/memos
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/usememos/memos

### Mere Medical

- Slug: mere-medical
- URL: https://www.canagentsuse.com/tools/mere-medical
- Website: https://meremedical.co/
- Docs: https://github.com/cfu288/mere-medical
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Health and Fitness
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted health and fitness workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Nodejs. Source code: https://github.com/cfu288/mere-medical
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Mere Medical is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://meremedical.co/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/cfu288/mere-medical
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/cfu288/mere-medical
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/cfu288/mere-medical
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/cfu288/mere-medical

### Metabase

- Slug: metabase
- URL: https://www.canagentsuse.com/tools/metabase
- Website: https://metabase.com/
- Docs: https://github.com/metabase/metabase
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Analytics
- Use cases: Self-host a tool, Inspect open source, Analyze product, Triage work
- Best for: Self-hosted analytics workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Java, Docker. Source code: https://github.com/metabase/metabase
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Metabase is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://metabase.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/metabase/metabase
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/metabase/metabase
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/metabase/metabase
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/metabase/metabase

### MeTube

- Slug: metube
- URL: https://www.canagentsuse.com/tools/metube
- Website: https://github.com/alexta69/metube
- Docs: https://github.com/alexta69/metube
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Media Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted media management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python, Nodejs, Docker. Source code: https://github.com/alexta69/metube
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

MeTube is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/alexta69/metube
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/alexta69/metube
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/alexta69/metube
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/alexta69/metube
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/alexta69/metube

### Microweber

- Slug: microweber
- URL: https://www.canagentsuse.com/tools/microweber
- Website: https://microweber.com/
- Docs: https://github.com/microweber/microweber
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, E-commerce, Content Management Systems (CMS)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted e-commerce workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/microweber/microweber
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Microweber is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://microweber.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/microweber/microweber
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/microweber/microweber
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/microweber/microweber
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/microweber/microweber

### Middleware

- Slug: middleware
- URL: https://www.canagentsuse.com/tools/middleware
- Website: https://middlewarehq.com/
- Docs: https://github.com/middlewarehq/middleware
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Analytics
- Use cases: Self-host a tool, Inspect open source, Analyze product
- Best for: Self-hosted analytics workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Python, Nodejs. Source code: https://github.com/middlewarehq/middleware
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Middleware is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://middlewarehq.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/middlewarehq/middleware
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/middlewarehq/middleware
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/middlewarehq/middleware
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/middlewarehq/middleware

### mikochi

- Slug: mikochi
- URL: https://www.canagentsuse.com/tools/mikochi
- Website: https://github.com/zer0tonin/Mikochi
- Docs: https://github.com/zer0tonin/Mikochi
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, File Transfer - Web-based File Managers, Media Streaming - Multimedia Streaming
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted file transfer - web-based file managers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker, K8S. Source code: https://github.com/zer0tonin/Mikochi
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

mikochi is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/zer0tonin/Mikochi
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/zer0tonin/Mikochi
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/zer0tonin/Mikochi
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/zer0tonin/Mikochi
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/zer0tonin/Mikochi

### Mindustry

- Slug: mindustry
- URL: https://www.canagentsuse.com/tools/mindustry
- Website: https://mindustrygame.github.io/
- Docs: https://github.com/Anuken/Mindustry
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Games
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted games workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Java. Source code: https://github.com/Anuken/Mindustry
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Mindustry is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://mindustrygame.github.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Anuken/Mindustry
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Anuken/Mindustry
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Anuken/Mindustry
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Anuken/Mindustry

### Miniflux

- Slug: miniflux
- URL: https://www.canagentsuse.com/tools/miniflux
- Website: https://miniflux.app/
- Docs: https://github.com/miniflux/v2
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Feed Readers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted feed readers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, deb, Docker. Source code: https://github.com/miniflux/v2
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Miniflux is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 3/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://miniflux.app/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/miniflux/v2
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/miniflux/v2
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/miniflux/v2
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/miniflux/v2

### MiroTalk C2C

- Slug: mirotalk-c2c
- URL: https://www.canagentsuse.com/tools/mirotalk-c2c
- Website: https://c2c.mirotalk.com
- Docs: https://github.com/miroslavpejic85/mirotalkc2c
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Video Conferencing
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - video conferencing workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/miroslavpejic85/mirotalkc2c
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

MiroTalk C2C is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://c2c.mirotalk.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/miroslavpejic85/mirotalkc2c
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/miroslavpejic85/mirotalkc2c
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/miroslavpejic85/mirotalkc2c
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/miroslavpejic85/mirotalkc2c

### MiroTalk P2P

- Slug: mirotalk-p2p
- URL: https://www.canagentsuse.com/tools/mirotalk-p2p
- Website: https://p2p.mirotalk.com
- Docs: https://github.com/miroslavpejic85/mirotalk
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Video Conferencing
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - video conferencing workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/miroslavpejic85/mirotalk
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

MiroTalk P2P is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://p2p.mirotalk.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/miroslavpejic85/mirotalk
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/miroslavpejic85/mirotalk
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/miroslavpejic85/mirotalk
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/miroslavpejic85/mirotalk

### MiroTalk SFU

- Slug: mirotalk-sfu
- URL: https://www.canagentsuse.com/tools/mirotalk-sfu
- Website: https://sfu.mirotalk.com
- Docs: https://github.com/miroslavpejic85/mirotalksfu
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Video Conferencing
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - video conferencing workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/miroslavpejic85/mirotalksfu
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

MiroTalk SFU is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://sfu.mirotalk.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/miroslavpejic85/mirotalksfu
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/miroslavpejic85/mirotalksfu
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/miroslavpejic85/mirotalksfu
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/miroslavpejic85/mirotalksfu

### Misago

- Slug: misago
- URL: https://www.canagentsuse.com/tools/misago
- Website: https://misago-project.org/
- Docs: https://github.com/rafalp/Misago
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Social Networks and Forums
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - social networks and forums workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/rafalp/Misago
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Misago is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://misago-project.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/rafalp/Misago
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/rafalp/Misago
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/rafalp/Misago
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/rafalp/Misago

### Modoboa

- Slug: modoboa
- URL: https://www.canagentsuse.com/tools/modoboa
- Website: https://modoboa.org/en/
- Docs: https://github.com/modoboa/modoboa
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Email - Complete Solutions
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted communication - email - complete solutions workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as ISC; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python. Source code: https://github.com/modoboa/modoboa
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Modoboa is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://modoboa.org/en/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/modoboa/modoboa
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/modoboa/modoboa
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/modoboa/modoboa
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/modoboa/modoboa

### MODX

- Slug: modx
- URL: https://www.canagentsuse.com/tools/modx
- Website: https://modx.com/
- Docs: https://github.com/modxcms/revolution
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Content Management Systems (CMS)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted content management systems (cms) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/modxcms/revolution
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

MODX is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://modx.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/modxcms/revolution
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/modxcms/revolution
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/modxcms/revolution
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/modxcms/revolution

### monetr

- Slug: monetr
- URL: https://www.canagentsuse.com/tools/monetr
- Website: https://monetr.app/
- Docs: https://github.com/monetr/monetr
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Money, Budgeting & Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted money, budgeting & management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as FSL-1.1-MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, K8S. Source code: https://github.com/monetr/monetr
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

monetr is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://monetr.app/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/monetr/monetr
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/monetr/monetr
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/monetr/monetr
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/monetr/monetr

### Monica

- Slug: monica
- URL: https://www.canagentsuse.com/tools/monica
- Website: https://monicahq.com/
- Docs: https://github.com/monicahq/monica
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Customer Relationship Management (CRM)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted customer relationship management (crm) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP, Docker. Source code: https://github.com/monicahq/monica
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Monica is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://monicahq.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/monicahq/monica
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/monicahq/monica
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/monicahq/monica
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/monicahq/monica

### moOde Audio

- Slug: moode-audio
- URL: https://www.canagentsuse.com/tools/moode-audio
- Website: https://moodeaudio.org/
- Docs: https://github.com/moode-player/moode
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Media Streaming - Audio Streaming
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted media streaming - audio streaming workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/moode-player/moode
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

moOde Audio is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://moodeaudio.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/moode-player/moode
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/moode-player/moode
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/moode-player/moode
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/moode-player/moode

### mosparo

- Slug: mosparo
- URL: https://www.canagentsuse.com/tools/mosparo
- Website: https://mosparo.io/
- Docs: https://github.com/mosparo/mosparo
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Miscellaneous
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted miscellaneous workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/mosparo/mosparo
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

mosparo is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://mosparo.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/mosparo/mosparo
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/mosparo/mosparo
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/mosparo/mosparo
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/mosparo/mosparo

### motionEye

- Slug: motioneye
- URL: https://www.canagentsuse.com/tools/motioneye
- Website: https://github.com/motioneye-project/motioneye
- Docs: https://github.com/motioneye-project/motioneye
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Video Surveillance
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted video surveillance workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python, Docker. Source code: https://github.com/motioneye-project/motioneye
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

motionEye is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/motioneye-project/motioneye
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/motioneye-project/motioneye
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/motioneye-project/motioneye
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/motioneye-project/motioneye
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/motioneye-project/motioneye

### Movary

- Slug: movary
- URL: https://www.canagentsuse.com/tools/movary
- Website: https://github.com/leepeuker/movary
- Docs: https://github.com/leepeuker/movary
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Miscellaneous
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted miscellaneous workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, PHP. Source code: https://github.com/leepeuker/movary
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Movary is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/leepeuker/movary
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/leepeuker/movary
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/leepeuker/movary
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/leepeuker/movary
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/leepeuker/movary

### Movim

- Slug: movim
- URL: https://www.canagentsuse.com/tools/movim
- Website: https://movim.eu/
- Docs: https://github.com/movim/movim
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Social Networks and Forums
- Use cases: Self-host a tool, Inspect open source, Analyze product, Publish content
- Best for: Self-hosted communication - social networks and forums workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP, Docker. Source code: https://github.com/movim/movim
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Movim is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://movim.eu/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/movim/movim
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/movim/movim
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/movim/movim
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/movim/movim

### Mox

- Slug: mox
- URL: https://www.canagentsuse.com/tools/mox
- Website: https://www.xmox.nl/
- Docs: https://github.com/mjl-/mox
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Email - Complete Solutions
- Use cases: Self-host a tool, Inspect open source, Publish content
- Best for: Self-hosted communication - email - complete solutions workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go. Source code: https://github.com/mjl-/mox
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Mox is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.xmox.nl/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/mjl-/mox
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/mjl-/mox
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/mjl-/mox
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/mjl-/mox

### MTA:SA

- Slug: mta-sa
- URL: https://www.canagentsuse.com/tools/mta-sa
- Website: https://multitheftauto.com/
- Docs: https://github.com/multitheftauto/mtasa-blue
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Games
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted games workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C++. Source code: https://github.com/multitheftauto/mtasa-blue
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

MTA:SA is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://multitheftauto.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/multitheftauto/mtasa-blue
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/multitheftauto/mtasa-blue
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/multitheftauto/mtasa-blue
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/multitheftauto/mtasa-blue

### multi-scrobbler

- Slug: multi-scrobbler
- URL: https://www.canagentsuse.com/tools/multi-scrobbler
- Website: https://foxxmd.github.io/multi-scrobbler
- Docs: https://github.com/FoxxMD/multi-scrobbler
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Media Streaming - Audio Streaming
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted media streaming - audio streaming workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/FoxxMD/multi-scrobbler
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

multi-scrobbler is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://foxxmd.github.io/multi-scrobbler
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/FoxxMD/multi-scrobbler
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/FoxxMD/multi-scrobbler
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/FoxxMD/multi-scrobbler
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/FoxxMD/multi-scrobbler

### Mumble

- Slug: mumble
- URL: https://www.canagentsuse.com/tools/mumble
- Website: https://wiki.mumble.info/wiki/Main_Page
- Docs: https://github.com/mumble-voip/mumble
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Custom Communication Systems
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - custom communication systems workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as BSD-3-Clause; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C++, deb. Source code: https://github.com/mumble-voip/mumble
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Mumble is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://wiki.mumble.info/wiki/Main_Page
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/mumble-voip/mumble
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/mumble-voip/mumble
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/mumble-voip/mumble
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/mumble-voip/mumble

### MyBB

- Slug: mybb
- URL: https://www.canagentsuse.com/tools/mybb
- Website: https://mybb.com/
- Docs: https://github.com/mybb/mybb
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Social Networks and Forums
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - social networks and forums workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as LGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/mybb/mybb
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

MyBB is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://mybb.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/mybb/mybb
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/mybb/mybb
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/mybb/mybb
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/mybb/mybb

### myCart

- Slug: mycart
- URL: https://www.canagentsuse.com/tools/mycart
- Website: https://github.com/shurco/mycart
- Docs: https://github.com/shurco/mycart
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, E-commerce
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted e-commerce workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker. Source code: https://github.com/shurco/mycart
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

myCart is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/shurco/mycart
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/shurco/mycart
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/shurco/mycart
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/shurco/mycart
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/shurco/mycart

### Mycorrhiza Wiki

- Slug: mycorrhiza-wiki
- URL: https://www.canagentsuse.com/tools/mycorrhiza-wiki
- Website: https://mycorrhiza.wiki/
- Docs: https://github.com/bouncepaw/mycorrhiza/
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Wikis
- Use cases: Self-host a tool, Inspect open source, Publish content
- Best for: Self-hosted wikis workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go. Source code: https://github.com/bouncepaw/mycorrhiza/
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Mycorrhiza Wiki is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://mycorrhiza.wiki/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/bouncepaw/mycorrhiza/
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/bouncepaw/mycorrhiza/
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/bouncepaw/mycorrhiza/
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/bouncepaw/mycorrhiza/

### MyIP

- Slug: myip
- URL: https://www.canagentsuse.com/tools/myip
- Website: https://ipcheck.ing
- Docs: https://github.com/jason5ng32/MyIP
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Network Utilities
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted network utilities workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/jason5ng32/MyIP
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

MyIP is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://ipcheck.ing
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/jason5ng32/MyIP
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/jason5ng32/MyIP
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/jason5ng32/MyIP
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/jason5ng32/MyIP

### MySpeed

- Slug: myspeed
- URL: https://www.canagentsuse.com/tools/myspeed
- Website: https://myspeed.dev/
- Docs: https://github.com/gnmyt/myspeed
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Network Utilities
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted network utilities workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Nodejs. Source code: https://github.com/gnmyt/myspeed
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

MySpeed is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://myspeed.dev/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/gnmyt/myspeed
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/gnmyt/myspeed
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/gnmyt/myspeed
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/gnmyt/myspeed

### MyTube

- Slug: mytube
- URL: https://www.canagentsuse.com/tools/mytube
- Website: https://github.com/franklioxygen/MyTube
- Docs: https://github.com/franklioxygen/MyTube
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Media Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted media management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/franklioxygen/MyTube
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

MyTube is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/franklioxygen/MyTube
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/franklioxygen/MyTube
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/franklioxygen/MyTube
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/franklioxygen/MyTube
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/franklioxygen/MyTube

### nefarious

- Slug: nefarious
- URL: https://www.canagentsuse.com/tools/nefarious
- Website: https://lardbit.github.io/nefarious/
- Docs: https://github.com/lardbit/nefarious
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Media Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted media management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python. Source code: https://github.com/lardbit/nefarious
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

nefarious is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://lardbit.github.io/nefarious/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/lardbit/nefarious
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/lardbit/nefarious
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/lardbit/nefarious
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/lardbit/nefarious

### Neko

- Slug: neko
- URL: https://www.canagentsuse.com/tools/neko
- Website: https://neko.m1k1o.net
- Docs: https://github.com/m1k1o/neko
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Miscellaneous
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted miscellaneous workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Go. Source code: https://github.com/m1k1o/neko
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Neko is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://neko.m1k1o.net
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/m1k1o/neko
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/m1k1o/neko
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/m1k1o/neko
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/m1k1o/neko

### NeonLink

- Slug: neonlink
- URL: https://www.canagentsuse.com/tools/neonlink
- Website: https://github.com/AlexSciFier/neonlink
- Docs: https://github.com/AlexSciFier/neonlink
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Bookmarks and Link Sharing
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted bookmarks and link sharing workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/AlexSciFier/neonlink
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

NeonLink is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/AlexSciFier/neonlink
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/AlexSciFier/neonlink
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/AlexSciFier/neonlink
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/AlexSciFier/neonlink
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/AlexSciFier/neonlink

### NetAlertX

- Slug: netalertx
- URL: https://www.canagentsuse.com/tools/netalertx
- Website: https://netalertx.com/
- Docs: https://github.com/netalertx/NetAlertX
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Network Utilities
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted network utilities workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/netalertx/NetAlertX
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

NetAlertX is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://netalertx.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/netalertx/NetAlertX
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/netalertx/NetAlertX
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/netalertx/NetAlertX
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/netalertx/NetAlertX

### Netron

- Slug: netron
- URL: https://www.canagentsuse.com/tools/netron
- Website: https://netron.app/
- Docs: https://github.com/lutzroeder/netron
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Analytics
- Use cases: Self-host a tool, Inspect open source, Analyze product
- Best for: Self-hosted analytics workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python, Nodejs. Source code: https://github.com/lutzroeder/netron
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Netron is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://netron.app/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/lutzroeder/netron
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/lutzroeder/netron
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/lutzroeder/netron
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/lutzroeder/netron

### NewsBlur

- Slug: newsblur
- URL: https://www.canagentsuse.com/tools/newsblur
- Website: https://www.newsblur.com/
- Docs: https://github.com/samuelclay/NewsBlur
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Feed Readers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted feed readers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python. Source code: https://github.com/samuelclay/NewsBlur
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

NewsBlur is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.newsblur.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/samuelclay/NewsBlur
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/samuelclay/NewsBlur
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/samuelclay/NewsBlur
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/samuelclay/NewsBlur

### Nextcloud Memories

- Slug: nextcloud-memories
- URL: https://www.canagentsuse.com/tools/nextcloud-memories
- Website: https://memories.gallery/
- Docs: https://github.com/pulsejet/memories
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Photo Galleries
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted photo galleries workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/pulsejet/memories
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Nextcloud Memories is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://memories.gallery/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/pulsejet/memories
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/pulsejet/memories
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/pulsejet/memories
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/pulsejet/memories

### NextCloudPi

- Slug: nextcloudpi
- URL: https://www.canagentsuse.com/tools/nextcloudpi
- Website: https://github.com/nextcloud/nextcloudpi
- Docs: https://github.com/nextcloud/nextcloudpi
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Self-hosting Solutions
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Triage work
- Best for: Self-hosted self-hosting solutions workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Shell, PHP. Source code: https://github.com/nextcloud/nextcloudpi
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

NextCloudPi is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/nextcloud/nextcloudpi
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/nextcloud/nextcloudpi
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/nextcloud/nextcloudpi
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/nextcloud/nextcloudpi
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/nextcloud/nextcloudpi

### NodeBB

- Slug: nodebb
- URL: https://www.canagentsuse.com/tools/nodebb
- Website: https://nodebb.org/
- Docs: https://github.com/NodeBB/NodeBB
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Social Networks and Forums
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - social networks and forums workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/NodeBB/NodeBB
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

NodeBB is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://nodebb.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/NodeBB/NodeBB
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/NodeBB/NodeBB
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/NodeBB/NodeBB
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/NodeBB/NodeBB

### Note Mark

- Slug: note-mark
- URL: https://www.canagentsuse.com/tools/note-mark
- Website: https://notemark.docs.enchantedcode.co.uk/
- Docs: https://github.com/enchant97/note-mark
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Note-taking & Editors
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted note-taking & editors workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/enchant97/note-mark
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Note Mark is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://notemark.docs.enchantedcode.co.uk/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/enchant97/note-mark
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/enchant97/note-mark
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/enchant97/note-mark
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/enchant97/note-mark

### Novu

- Slug: novu
- URL: https://www.canagentsuse.com/tools/novu
- Website: https://novu.co/
- Docs: https://github.com/novuhq/novu/
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Custom Communication Systems
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - custom communication systems workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Nodejs. Source code: https://github.com/novuhq/novu/
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Novu is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://novu.co/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/novuhq/novu/
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/novuhq/novu/
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/novuhq/novu/
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/novuhq/novu/

### Nullboard

- Slug: nullboard
- URL: https://www.canagentsuse.com/tools/nullboard
- Website: https://github.com/apankrat/nullboard
- Docs: https://github.com/apankrat/nullboard
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Task Management & To-do Lists
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted task management & to-do lists workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as BSD-2-Clause; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Javascript. Source code: https://github.com/apankrat/nullboard
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Nullboard is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/apankrat/nullboard
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/apankrat/nullboard
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/apankrat/nullboard
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/apankrat/nullboard
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/apankrat/nullboard

### NymphCast

- Slug: nymphcast
- URL: https://www.canagentsuse.com/tools/nymphcast
- Website: http://nyanko.ws/nymphcast.php
- Docs: https://github.com/MayaPosch/NymphCast
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Media Streaming - Multimedia Streaming
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted media streaming - multimedia streaming workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as BSD-3-Clause; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C++. Source code: https://github.com/MayaPosch/NymphCast
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

NymphCast is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: http://nyanko.ws/nymphcast.php
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/MayaPosch/NymphCast
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/MayaPosch/NymphCast
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/MayaPosch/NymphCast
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/MayaPosch/NymphCast

### october

- Slug: october
- URL: https://www.canagentsuse.com/tools/october
- Website: https://octobercms.com/
- Docs: https://github.com/octobercms/october
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Content Management Systems (CMS)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted content management systems (cms) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as ⊘ Proprietary; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/octobercms/october
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

october is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://octobercms.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/octobercms/october
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/octobercms/october
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/octobercms/october
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/octobercms/october

### OctoBot

- Slug: octobot
- URL: https://www.canagentsuse.com/tools/octobot
- Website: https://www.octobot.cloud/
- Docs: https://github.com/Drakkar-Software/OctoBot
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Money, Budgeting & Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted money, budgeting & management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python, Docker. Source code: https://github.com/Drakkar-Software/OctoBot
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

OctoBot is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.octobot.cloud/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Drakkar-Software/OctoBot
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Drakkar-Software/OctoBot
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Drakkar-Software/OctoBot
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Drakkar-Software/OctoBot

### Octobox

- Slug: octobox
- URL: https://www.canagentsuse.com/tools/octobox
- Website: https://octobox.io/
- Docs: https://github.com/octobox/octobox
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Software Development - Project Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted software development - project management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Ruby, Docker. Source code: https://github.com/octobox/octobox
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Octobox is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://octobox.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/octobox/octobox
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/octobox/octobox
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/octobox/octobox
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/octobox/octobox

### Octoprint

- Slug: octoprint
- URL: https://www.canagentsuse.com/tools/octoprint
- Website: https://octoprint.org/
- Docs: https://github.com/OctoPrint/OctoPrint
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Manufacturing
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted manufacturing workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Python. Source code: https://github.com/OctoPrint/OctoPrint
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Octoprint is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://octoprint.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/OctoPrint/OctoPrint
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/OctoPrint/OctoPrint
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/OctoPrint/OctoPrint
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/OctoPrint/OctoPrint

### Ocular

- Slug: ocular
- URL: https://www.canagentsuse.com/tools/ocular
- Website: https://simonwep.github.io/ocular/
- Docs: https://github.com/simonwep/ocular
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Money, Budgeting & Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted money, budgeting & management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/simonwep/ocular
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Ocular is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://simonwep.github.io/ocular/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/simonwep/ocular
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/simonwep/ocular
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/simonwep/ocular
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/simonwep/ocular

### Odoo

- Slug: odoo
- URL: https://www.canagentsuse.com/tools/odoo
- Website: https://www.odoo.com
- Docs: https://github.com/odoo/odoo
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Resource Planning
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted resource planning workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as LGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python, deb, Docker. Source code: https://github.com/odoo/odoo
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Odoo is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.odoo.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/odoo/odoo
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/odoo/odoo
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/odoo/odoo
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/odoo/odoo

### OFBiz

- Slug: ofbiz
- URL: https://www.canagentsuse.com/tools/ofbiz
- Website: https://ofbiz.apache.org/
- Docs: https://github.com/apache/ofbiz-framework
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Resource Planning
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted resource planning workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Java. Source code: https://github.com/apache/ofbiz-framework
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

OFBiz is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://ofbiz.apache.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/apache/ofbiz-framework
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/apache/ofbiz-framework
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/apache/ofbiz-framework
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/apache/ofbiz-framework

### Offen

- Slug: offen
- URL: https://www.canagentsuse.com/tools/offen
- Website: https://www.offen.dev/
- Docs: https://github.com/offen/offen
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Analytics
- Use cases: Self-host a tool, Inspect open source, Analyze product, Triage work
- Best for: Self-hosted analytics workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker. Source code: https://github.com/offen/offen
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Offen is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.offen.dev/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/offen/offen
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/offen/offen
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/offen/offen
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/offen/offen

### Ollama

- Slug: ollama
- URL: https://www.canagentsuse.com/tools/ollama
- Website: https://ollama.com/
- Docs: https://github.com/ollama/ollama
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Generative Artificial Intelligence (GenAI)
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted generative artificial intelligence (genai) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Python. Source code: https://github.com/ollama/ollama
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Ollama is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://ollama.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/ollama/ollama
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/ollama/ollama
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/ollama/ollama
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/ollama/ollama

### Ombi

- Slug: ombi
- URL: https://www.canagentsuse.com/tools/ombi
- Website: https://ombi.io/
- Docs: https://github.com/Ombi-app/Ombi
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Media Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted media management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C#, deb. Source code: https://github.com/Ombi-app/Ombi
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Ombi is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://ombi.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Ombi-app/Ombi
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Ombi-app/Ombi
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Ombi-app/Ombi
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Ombi-app/Ombi

### OmniTools

- Slug: omnitools
- URL: https://www.canagentsuse.com/tools/omnitools
- Website: https://omnitools.app/
- Docs: https://github.com/iib0011/omni-tools
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Miscellaneous
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted miscellaneous workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/iib0011/omni-tools
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

OmniTools is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://omnitools.app/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/iib0011/omni-tools
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/iib0011/omni-tools
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/iib0011/omni-tools
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/iib0011/omni-tools

### One Time Secret

- Slug: one-time-secret
- URL: https://www.canagentsuse.com/tools/one-time-secret
- Website: https://docs.onetimesecret.com
- Docs: https://github.com/onetimesecret/onetimesecret
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Custom Communication Systems
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - custom communication systems workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Ruby, Nodejs. Source code: https://github.com/onetimesecret/onetimesecret
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

One Time Secret is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://docs.onetimesecret.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/onetimesecret/onetimesecret
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/onetimesecret/onetimesecret
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/onetimesecret/onetimesecret
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/onetimesecret/onetimesecret

### Onyx Community Edition

- Slug: onyx-community-edition
- URL: https://www.canagentsuse.com/tools/onyx-community-edition
- Website: https://onyx.app
- Docs: https://github.com/onyx-dot-app/onyx
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Generative Artificial Intelligence (GenAI)
- Use cases: Self-host a tool, Inspect open source, Triage work
- Best for: Self-hosted generative artificial intelligence (genai) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, K8S. Source code: https://github.com/onyx-dot-app/onyx
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Onyx Community Edition is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://onyx.app
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/onyx-dot-app/onyx
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/onyx-dot-app/onyx
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/onyx-dot-app/onyx
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/onyx-dot-app/onyx

### Open Food Network

- Slug: open-food-network
- URL: https://www.canagentsuse.com/tools/open-food-network
- Website: https://www.openfoodnetwork.org/
- Docs: https://github.com/openfoodfoundation/openfoodnetwork
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Community-Supported Agriculture (CSA)
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted community-supported agriculture (csa) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Ruby. Source code: https://github.com/openfoodfoundation/openfoodnetwork
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Open Food Network is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.openfoodnetwork.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/openfoodfoundation/openfoodnetwork
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/openfoodfoundation/openfoodnetwork
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/openfoodfoundation/openfoodnetwork
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/openfoodfoundation/openfoodnetwork

### Open Source POS

- Slug: open-source-pos
- URL: https://www.canagentsuse.com/tools/open-source-pos
- Website: https://github.com/opensourcepos/opensourcepos
- Docs: https://github.com/opensourcepos/opensourcepos
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, E-commerce
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted e-commerce workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/opensourcepos/opensourcepos
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Open Source POS is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/opensourcepos/opensourcepos
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/opensourcepos/opensourcepos
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/opensourcepos/opensourcepos
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/opensourcepos/opensourcepos
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/opensourcepos/opensourcepos

### OpenBudgeteer

- Slug: openbudgeteer
- URL: https://www.canagentsuse.com/tools/openbudgeteer
- Website: https://github.com/TheAxelander/OpenBudgeteer
- Docs: https://github.com/TheAxelander/OpenBudgeteer
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Money, Budgeting & Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted money, budgeting & management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, C#. Source code: https://github.com/TheAxelander/OpenBudgeteer
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

OpenBudgeteer is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/TheAxelander/OpenBudgeteer
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/TheAxelander/OpenBudgeteer
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/TheAxelander/OpenBudgeteer
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/TheAxelander/OpenBudgeteer
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/TheAxelander/OpenBudgeteer

### OpenCart

- Slug: opencart
- URL: https://www.canagentsuse.com/tools/opencart
- Website: https://www.opencart.com
- Docs: https://github.com/opencart/opencart
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, E-commerce
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted e-commerce workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/opencart/opencart
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

OpenCart is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.opencart.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/opencart/opencart
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/opencart/opencart
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/opencart/opencart
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/opencart/opencart

### OpenCloud

- Slug: opencloud
- URL: https://www.canagentsuse.com/tools/opencloud
- Website: https://docs.opencloud.eu/
- Docs: https://github.com/opencloud-eu/opencloud
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, File Transfer & Synchronization
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted file transfer & synchronization workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Go, Nodejs. Source code: https://github.com/opencloud-eu/opencloud
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

OpenCloud is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://docs.opencloud.eu/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/opencloud-eu/opencloud
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/opencloud-eu/opencloud
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/opencloud-eu/opencloud
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/opencloud-eu/opencloud

### OpenEMR

- Slug: openemr
- URL: https://www.canagentsuse.com/tools/openemr
- Website: https://www.open-emr.org/
- Docs: https://github.com/openemr/openemr
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Health and Fitness
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted health and fitness workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP, Docker. Source code: https://github.com/openemr/openemr
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

OpenEMR is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.open-emr.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/openemr/openemr
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/openemr/openemr
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/openemr/openemr
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/openemr/openemr

### Opengist

- Slug: opengist
- URL: https://www.canagentsuse.com/tools/opengist
- Website: https://opengist.io
- Docs: https://github.com/thomiceli/opengist
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Pastebins
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted pastebins workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Go, Nodejs. Source code: https://github.com/thomiceli/opengist
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Opengist is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://opengist.io
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/thomiceli/opengist
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/thomiceli/opengist
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/thomiceli/opengist
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/thomiceli/opengist

### OpenHabitTracker

- Slug: openhabittracker
- URL: https://www.canagentsuse.com/tools/openhabittracker
- Website: https://openhabittracker.net
- Docs: https://github.com/Jinjinov/OpenHabitTracker
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Task Management & To-do Lists, Time Tracking
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted task management & to-do lists workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/Jinjinov/OpenHabitTracker
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

OpenHabitTracker is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://openhabittracker.net
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Jinjinov/OpenHabitTracker
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Jinjinov/OpenHabitTracker
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Jinjinov/OpenHabitTracker
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Jinjinov/OpenHabitTracker

### OpenOLAT

- Slug: openolat
- URL: https://www.canagentsuse.com/tools/openolat
- Website: https://www.openolat.com/?lang=en
- Docs: https://github.com/OpenOLAT/OpenOLAT
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Learning and Courses
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted learning and courses workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Java. Source code: https://github.com/OpenOLAT/OpenOLAT
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

OpenOLAT is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.openolat.com/?lang=en
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/OpenOLAT/OpenOLAT
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/OpenOLAT/OpenOLAT
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/OpenOLAT/OpenOLAT
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/OpenOLAT/OpenOLAT

### OpenProject

- Slug: openproject
- URL: https://www.canagentsuse.com/tools/openproject
- Website: https://www.openproject.org
- Docs: https://github.com/opf/openproject
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Software Development - Project Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted software development - project management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Ruby, deb, Docker. Source code: https://github.com/opf/openproject
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

OpenProject is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.openproject.org
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/opf/openproject
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/opf/openproject
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/opf/openproject
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/opf/openproject

### OpenReader

- Slug: openreader
- URL: https://www.canagentsuse.com/tools/openreader
- Website: https://openreader.richardr.dev/
- Docs: https://github.com/richardr1126/openreader
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Miscellaneous
- Use cases: Self-host a tool, Inspect open source, Publish content
- Best for: Self-hosted miscellaneous workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/richardr1126/openreader
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

OpenReader is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://openreader.richardr.dev/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/richardr1126/openreader
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/richardr1126/openreader
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/richardr1126/openreader
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/richardr1126/openreader

### OpenRemote

- Slug: openremote
- URL: https://www.canagentsuse.com/tools/openremote
- Website: https://openremote.io
- Docs: https://github.com/openremote/openremote
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Internet of Things (IoT)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Triage work
- Best for: Self-hosted internet of things (iot) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Java. Source code: https://github.com/openremote/openremote
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

OpenRemote is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://openremote.io
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/openremote/openremote
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/openremote/openremote
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/openremote/openremote
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/openremote/openremote

### OpenRouteService

- Slug: openrouteservice
- URL: https://www.canagentsuse.com/tools/openrouteservice
- Website: https://openrouteservice.org/
- Docs: https://github.com/GIScience/openrouteservice
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Maps and Global Positioning System (GPS)
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted maps and global positioning system (gps) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Java. Source code: https://github.com/GIScience/openrouteservice
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

OpenRouteService is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://openrouteservice.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/GIScience/openrouteservice
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/GIScience/openrouteservice
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/GIScience/openrouteservice
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/GIScience/openrouteservice

### OpenSign

- Slug: opensign
- URL: https://www.canagentsuse.com/tools/opensign
- Website: https://www.opensignlabs.com
- Docs: https://github.com/opensignlabs/opensign
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Document Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted document management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/opensignlabs/opensign
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

OpenSign is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.opensignlabs.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/opensignlabs/opensign
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/opensignlabs/opensign
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/opensignlabs/opensign
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/opensignlabs/opensign

### OpenSlides

- Slug: openslides
- URL: https://www.canagentsuse.com/tools/openslides
- Website: https://openslides.com/
- Docs: https://github.com/OpenSlides/OpenSlides
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Conference Management, Booking and Scheduling
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted conference management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/OpenSlides/OpenSlides
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

OpenSlides is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://openslides.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/OpenSlides/OpenSlides
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/OpenSlides/OpenSlides
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/OpenSlides/OpenSlides
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/OpenSlides/OpenSlides

### OpenStreetMap

- Slug: openstreetmap
- URL: https://www.canagentsuse.com/tools/openstreetmap
- Website: https://www.openstreetmap.org/
- Docs: https://github.com/openstreetmap/openstreetmap-website
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Maps and Global Positioning System (GPS)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted maps and global positioning system (gps) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Ruby. Source code: https://github.com/openstreetmap/openstreetmap-website
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

OpenStreetMap is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.openstreetmap.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/openstreetmap/openstreetmap-website
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/openstreetmap/openstreetmap-website
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/openstreetmap/openstreetmap-website
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/openstreetmap/openstreetmap-website

### OpenTripPlanner

- Slug: opentripplanner
- URL: https://www.canagentsuse.com/tools/opentripplanner
- Website: https://www.opentripplanner.org/
- Docs: https://github.com/opentripplanner/OpenTripPlanner
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Maps and Global Positioning System (GPS)
- Use cases: Self-host a tool, Inspect open source, Triage work
- Best for: Self-hosted maps and global positioning system (gps) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as LGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Java, Javascript. Source code: https://github.com/opentripplanner/OpenTripPlanner
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

OpenTripPlanner is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.opentripplanner.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/opentripplanner/OpenTripPlanner
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/opentripplanner/OpenTripPlanner
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/opentripplanner/OpenTripPlanner
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/opentripplanner/OpenTripPlanner

### OpenTTD

- Slug: openttd
- URL: https://www.canagentsuse.com/tools/openttd
- Website: https://www.openttd.org/
- Docs: https://github.com/OpenTTD/OpenTTD
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Games
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted games workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C++, Docker. Source code: https://github.com/OpenTTD/OpenTTD
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

OpenTTD is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.openttd.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/OpenTTD/OpenTTD
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/OpenTTD/OpenTTD
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/OpenTTD/OpenTTD
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/OpenTTD/OpenTTD

### Operational.co

- Slug: operational-co
- URL: https://www.canagentsuse.com/tools/operational-co
- Website: https://operational.co
- Docs: https://github.com/operational-co/operational.co
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Miscellaneous
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted miscellaneous workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/operational-co/operational.co
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Operational.co is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://operational.co
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/operational-co/operational.co
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/operational-co/operational.co
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/operational-co/operational.co
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/operational-co/operational.co

### osem

- Slug: osem
- URL: https://www.canagentsuse.com/tools/osem
- Website: https://osem.io/
- Docs: https://github.com/openSUSE/osem
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Conference Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted conference management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Ruby, Docker. Source code: https://github.com/openSUSE/osem
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

osem is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://osem.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/openSUSE/osem
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/openSUSE/osem
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/openSUSE/osem
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/openSUSE/osem

### OTOBO

- Slug: otobo
- URL: https://www.canagentsuse.com/tools/otobo
- Website: https://otobo.io/en/
- Docs: https://github.com/RotherOSS/otobo
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Ticketing
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted ticketing workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Perl, Docker. Source code: https://github.com/RotherOSS/otobo
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

OTOBO is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://otobo.io/en/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/RotherOSS/otobo
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/RotherOSS/otobo
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/RotherOSS/otobo
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/RotherOSS/otobo

### OTS

- Slug: ots
- URL: https://www.canagentsuse.com/tools/ots
- Website: https://ots.fyi/
- Docs: https://github.com/Luzifer/ots
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Custom Communication Systems
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - custom communication systems workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go. Source code: https://github.com/Luzifer/ots
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

OTS is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://ots.fyi/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Luzifer/ots
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Luzifer/ots
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Luzifer/ots
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Luzifer/ots

### Otter Wiki

- Slug: otter-wiki
- URL: https://www.canagentsuse.com/tools/otter-wiki
- Website: https://otterwiki.com/
- Docs: https://github.com/redimp/otterwiki
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Wikis
- Use cases: Self-host a tool, Inspect open source, Publish content
- Best for: Self-hosted wikis workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/redimp/otterwiki
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Otter Wiki is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://otterwiki.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/redimp/otterwiki
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/redimp/otterwiki
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/redimp/otterwiki
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/redimp/otterwiki

### Outline

- Slug: outline
- URL: https://www.canagentsuse.com/tools/outline
- Website: https://www.getoutline.com/
- Docs: https://github.com/outline/outline
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Wikis
- Use cases: Self-host a tool, Inspect open source, Publish content
- Best for: Self-hosted wikis workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as BUSL-1.1; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/outline/outline
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Outline is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.getoutline.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/outline/outline
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/outline/outline
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/outline/outline
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/outline/outline

### Overleaf

- Slug: overleaf
- URL: https://www.canagentsuse.com/tools/overleaf
- Website: https://www.overleaf.com/
- Docs: https://github.com/overleaf/overleaf
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Note-taking & Editors
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted note-taking & editors workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Ruby. Source code: https://github.com/overleaf/overleaf
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Overleaf is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.overleaf.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/overleaf/overleaf
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/overleaf/overleaf
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/overleaf/overleaf
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/overleaf/overleaf

### ownCloud

- Slug: owncloud
- URL: https://www.canagentsuse.com/tools/owncloud
- Website: https://owncloud.org/
- Docs: https://github.com/owncloud/core
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, File Transfer & Synchronization
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted file transfer & synchronization workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP, Docker, deb. Source code: https://github.com/owncloud/core
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

ownCloud is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://owncloud.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/owncloud/core
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/owncloud/core
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/owncloud/core
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/owncloud/core

### OwnTracks Recorder

- Slug: owntracks-recorder
- URL: https://www.canagentsuse.com/tools/owntracks-recorder
- Website: https://github.com/owntracks/recorder
- Docs: https://github.com/owntracks/recorder
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Maps and Global Positioning System (GPS)
- Use cases: Self-host a tool, Inspect open source, Triage work
- Best for: Self-hosted maps and global positioning system (gps) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C, Lua, deb, Docker. Source code: https://github.com/owntracks/recorder
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

OwnTracks Recorder is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/owntracks/recorder
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/owntracks/recorder
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/owntracks/recorder
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/owntracks/recorder
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/owntracks/recorder

### paaster

- Slug: paaster
- URL: https://www.canagentsuse.com/tools/paaster
- Website: https://paaster.io
- Docs: https://github.com/WardPearce/paaster
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Pastebins
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted pastebins workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/WardPearce/paaster
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

paaster is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://paaster.io
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/WardPearce/paaster
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/WardPearce/paaster
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/WardPearce/paaster
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/WardPearce/paaster

### Paperless-ngx

- Slug: paperless-ngx
- URL: https://www.canagentsuse.com/tools/paperless-ngx
- Website: https://docs.paperless-ngx.com/
- Docs: https://github.com/paperless-ngx/paperless-ngx
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Document Management, Archiving and Digital Preservation (DP)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content, Triage work
- Best for: Self-hosted document management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python, Docker. Source code: https://github.com/paperless-ngx/paperless-ngx
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Paperless-ngx is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://docs.paperless-ngx.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/paperless-ngx/paperless-ngx
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/paperless-ngx/paperless-ngx
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/paperless-ngx/paperless-ngx
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/paperless-ngx/paperless-ngx

### Papermerge

- Slug: papermerge
- URL: https://www.canagentsuse.com/tools/papermerge
- Website: https://papermerge.com
- Docs: https://github.com/papermerge/papermerge-core
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Document Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content, Triage work
- Best for: Self-hosted document management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, K8S. Source code: https://github.com/papermerge/papermerge-core
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Papermerge is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://papermerge.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/papermerge/papermerge-core
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/papermerge/papermerge-core
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/papermerge/papermerge-core
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/papermerge/papermerge-core

### Papra

- Slug: papra
- URL: https://www.canagentsuse.com/tools/papra
- Website: https://papra.app
- Docs: https://github.com/papra-hq/papra/
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Document Management, Archiving and Digital Preservation (DP)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted document management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/papra-hq/papra/
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Papra is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://papra.app
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/papra-hq/papra/
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/papra-hq/papra/
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/papra-hq/papra/
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/papra-hq/papra/

### Password Pusher

- Slug: password-pusher
- URL: https://www.canagentsuse.com/tools/password-pusher
- Website: https://pwpush.com
- Docs: https://github.com/pglombardo/PasswordPusher
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Pastebins
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted pastebins workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, K8S, Ruby. Source code: https://github.com/pglombardo/PasswordPusher
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Password Pusher is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://pwpush.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/pglombardo/PasswordPusher
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/pglombardo/PasswordPusher
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/pglombardo/PasswordPusher
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/pglombardo/PasswordPusher

### Payload CMS

- Slug: payload-cms
- URL: https://www.canagentsuse.com/tools/payload-cms
- Website: https://payloadcms.com/
- Docs: https://github.com/payloadcms/payload
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Content Management Systems (CMS)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted content management systems (cms) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs. Source code: https://github.com/payloadcms/payload
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Payload CMS is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://payloadcms.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/payloadcms/payload
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/payloadcms/payload
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/payloadcms/payload
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/payloadcms/payload

### PdfDing

- Slug: pdfding
- URL: https://www.canagentsuse.com/tools/pdfding
- Website: https://www.pdfding.com
- Docs: https://github.com/mrmn2/PdfDing
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Document Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted document management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, K8S. Source code: https://github.com/mrmn2/PdfDing
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

PdfDing is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.pdfding.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/mrmn2/PdfDing
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/mrmn2/PdfDing
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/mrmn2/PdfDing
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/mrmn2/PdfDing

### PeerTube

- Slug: peertube
- URL: https://www.canagentsuse.com/tools/peertube
- Website: https://joinpeertube.org/en/
- Docs: https://github.com/Chocobozzz/PeerTube
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Media Streaming - Video Streaming
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted media streaming - video streaming workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs. Source code: https://github.com/Chocobozzz/PeerTube
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

PeerTube is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://joinpeertube.org/en/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Chocobozzz/PeerTube
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Chocobozzz/PeerTube
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Chocobozzz/PeerTube
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Chocobozzz/PeerTube

### penpot

- Slug: penpot
- URL: https://www.canagentsuse.com/tools/penpot
- Website: https://penpot.app/
- Docs: https://github.com/penpot/penpot
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Miscellaneous
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted miscellaneous workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/penpot/penpot
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

penpot is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://penpot.app/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/penpot/penpot
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/penpot/penpot
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/penpot/penpot
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/penpot/penpot

### Personal Management System

- Slug: personal-management-system
- URL: https://www.canagentsuse.com/tools/personal-management-system
- Website: https://volmarg.github.io/
- Docs: https://github.com/Volmarg/personal-management-system
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Personal Dashboards
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted personal dashboards workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/Volmarg/personal-management-system
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Personal Management System is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://volmarg.github.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Volmarg/personal-management-system
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Volmarg/personal-management-system
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Volmarg/personal-management-system
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Volmarg/personal-management-system

### Photofield

- Slug: photofield
- URL: https://www.canagentsuse.com/tools/photofield
- Website: https://github.com/SmilyOrg/photofield
- Docs: https://github.com/SmilyOrg/photofield
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Photo Galleries
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted photo galleries workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Go. Source code: https://github.com/SmilyOrg/photofield
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Photofield is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/SmilyOrg/photofield
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/SmilyOrg/photofield
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/SmilyOrg/photofield
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/SmilyOrg/photofield
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/SmilyOrg/photofield

### PhotoPrism

- Slug: photoprism
- URL: https://www.canagentsuse.com/tools/photoprism
- Website: https://photoprism.org
- Docs: https://github.com/photoprism/photoprism
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Photo Galleries
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Analyze product
- Best for: Self-hosted photo galleries workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker. Source code: https://github.com/photoprism/photoprism
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

PhotoPrism is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://photoprism.org
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/photoprism/photoprism
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/photoprism/photoprism
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/photoprism/photoprism
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/photoprism/photoprism

### phpBB

- Slug: phpbb
- URL: https://www.canagentsuse.com/tools/phpbb
- Website: https://www.phpbb.com/
- Docs: https://github.com/phpbb/phpbb
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Social Networks and Forums
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - social networks and forums workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/phpbb/phpbb
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

phpBB is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.phpbb.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/phpbb/phpbb
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/phpbb/phpbb
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/phpbb/phpbb
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/phpbb/phpbb

### phpList

- Slug: phplist
- URL: https://www.canagentsuse.com/tools/phplist
- Website: https://www.phplist.org
- Docs: https://github.com/phpList/phplist3
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Email - Mailing Lists and Newsletters
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted communication - email - mailing lists and newsletters workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/phpList/phplist3
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

phpList is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.phplist.org
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/phpList/phplist3
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/phpList/phplist3
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/phpList/phplist3
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/phpList/phplist3

### Pi-hole

- Slug: pi-hole
- URL: https://www.canagentsuse.com/tools/pi-hole
- Website: https://pi-hole.net/
- Docs: https://github.com/pi-hole/pi-hole
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, DNS
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Analyze product
- Best for: Self-hosted dns workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as EUPL-1.2; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Shell, PHP, Docker. Source code: https://github.com/pi-hole/pi-hole
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Pi-hole is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://pi-hole.net/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/pi-hole/pi-hole
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/pi-hole/pi-hole
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/pi-hole/pi-hole
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/pi-hole/pi-hole

### Piler

- Slug: piler
- URL: https://www.canagentsuse.com/tools/piler
- Website: https://www.mailpiler.org/
- Docs: https://github.com/jsuto/piler/
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Archiving and Digital Preservation (DP)
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted archiving and digital preservation (dp) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C, Docker, deb. Source code: https://github.com/jsuto/piler/
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Piler is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.mailpiler.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/jsuto/piler/
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/jsuto/piler/
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/jsuto/piler/
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/jsuto/piler/

### Pimcore

- Slug: pimcore
- URL: https://www.canagentsuse.com/tools/pimcore
- Website: http://www.pimcore.com/
- Docs: https://github.com/pimcore/pimcore
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Content Management Systems (CMS)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted content management systems (cms) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP, Docker. Source code: https://github.com/pimcore/pimcore
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Pimcore is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: http://www.pimcore.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/pimcore/pimcore
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/pimcore/pimcore
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/pimcore/pimcore
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/pimcore/pimcore

### Pinchflat

- Slug: pinchflat
- URL: https://www.canagentsuse.com/tools/pinchflat
- Website: https://github.com/kieraneglin/pinchflat
- Docs: https://github.com/kieraneglin/pinchflat
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Media Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted media management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/kieraneglin/pinchflat
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Pinchflat is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/kieraneglin/pinchflat
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/kieraneglin/pinchflat
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/kieraneglin/pinchflat
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/kieraneglin/pinchflat
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/kieraneglin/pinchflat

### Piwigo

- Slug: piwigo
- URL: https://www.canagentsuse.com/tools/piwigo
- Website: https://piwigo.org/
- Docs: https://github.com/Piwigo/Piwigo
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Photo Galleries
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted photo galleries workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/Piwigo/Piwigo
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Piwigo is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://piwigo.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Piwigo/Piwigo
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Piwigo/Piwigo
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Piwigo/Piwigo
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Piwigo/Piwigo

### PixelFed

- Slug: pixelfed
- URL: https://www.canagentsuse.com/tools/pixelfed
- Website: https://pixelfed.social
- Docs: https://github.com/pixelfed/pixelfed
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Social Networks and Forums
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - social networks and forums workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/pixelfed/pixelfed
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

PixelFed is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://pixelfed.social
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/pixelfed/pixelfed
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/pixelfed/pixelfed
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/pixelfed/pixelfed
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/pixelfed/pixelfed

### Plainpad

- Slug: plainpad
- URL: https://www.canagentsuse.com/tools/plainpad
- Website: https://alextselegidis.com/get/plainpad/
- Docs: https://github.com/alextselegidis/plainpad
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Note-taking & Editors
- Use cases: Self-host a tool, Inspect open source, Analyze product
- Best for: Self-hosted note-taking & editors workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/alextselegidis/plainpad
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Plainpad is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://alextselegidis.com/get/plainpad/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/alextselegidis/plainpad
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/alextselegidis/plainpad
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/alextselegidis/plainpad
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/alextselegidis/plainpad

### Plane

- Slug: plane
- URL: https://www.canagentsuse.com/tools/plane
- Website: https://plane.so
- Docs: https://github.com/makeplane/plane
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Software Development - Project Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted software development - project management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/makeplane/plane
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Plane is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://plane.so
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/makeplane/plane
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/makeplane/plane
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/makeplane/plane
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/makeplane/plane

### Planka

- Slug: planka
- URL: https://www.canagentsuse.com/tools/planka
- Website: https://planka.app/
- Docs: https://github.com/plankanban/planka
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Task Management & To-do Lists
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted task management & to-do lists workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as ⊘ Proprietary; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker, K8S. Source code: https://github.com/plankanban/planka
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Planka is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://planka.app/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/plankanban/planka
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/plankanban/planka
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/plankanban/planka
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/plankanban/planka

### Plausible Analytics

- Slug: plausible-analytics
- URL: https://www.canagentsuse.com/tools/plausible-analytics
- Website: https://plausible.io/
- Docs: https://github.com/plausible/analytics/
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Analytics
- Use cases: Self-host a tool, Inspect open source, Analyze product
- Best for: Self-hosted analytics workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Elixir. Source code: https://github.com/plausible/analytics/
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Plausible Analytics is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://plausible.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/plausible/analytics/
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/plausible/analytics/
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/plausible/analytics/
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/plausible/analytics/

### PocketBase

- Slug: pocketbase
- URL: https://www.canagentsuse.com/tools/pocketbase
- Website: https://pocketbase.io/
- Docs: https://github.com/pocketbase/pocketbase
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Software Development - Low Code
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted software development - low code workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker. Source code: https://github.com/pocketbase/pocketbase
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

PocketBase is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://pocketbase.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/pocketbase/pocketbase
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/pocketbase/pocketbase
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/pocketbase/pocketbase
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/pocketbase/pocketbase

### PodFetch

- Slug: podfetch
- URL: https://www.canagentsuse.com/tools/podfetch
- Website: https://samtv12345.github.io/PodFetch
- Docs: https://github.com/SamTV12345/PodFetch
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Media Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted media management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Rust. Source code: https://github.com/SamTV12345/PodFetch
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

PodFetch is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://samtv12345.github.io/PodFetch
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/SamTV12345/PodFetch
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/SamTV12345/PodFetch
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/SamTV12345/PodFetch
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/SamTV12345/PodFetch

### Polaris

- Slug: polaris
- URL: https://www.canagentsuse.com/tools/polaris
- Website: https://github.com/agersant/polaris
- Docs: https://github.com/agersant/polaris
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Media Streaming - Audio Streaming
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted media streaming - audio streaming workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Rust, Docker. Source code: https://github.com/agersant/polaris
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Polaris is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/agersant/polaris
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/agersant/polaris
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/agersant/polaris
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/agersant/polaris
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/agersant/polaris

### Posio

- Slug: posio
- URL: https://www.canagentsuse.com/tools/posio
- Website: https://github.com/abrenaut/posio
- Docs: https://github.com/abrenaut/posio
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Games
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted games workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python. Source code: https://github.com/abrenaut/posio
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Posio is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/abrenaut/posio
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/abrenaut/posio
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/abrenaut/posio
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/abrenaut/posio
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/abrenaut/posio

### Postiz

- Slug: postiz
- URL: https://www.canagentsuse.com/tools/postiz
- Website: https://postiz.com
- Docs: https://github.com/gitroomhq/postiz-app
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Analytics
- Use cases: Self-host a tool, Inspect open source, Analyze product, Publish content
- Best for: Self-hosted analytics workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/gitroomhq/postiz-app
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Postiz is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://postiz.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/gitroomhq/postiz-app
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/gitroomhq/postiz-app
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/gitroomhq/postiz-app
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/gitroomhq/postiz-app

### pretalx

- Slug: pretalx
- URL: https://www.canagentsuse.com/tools/pretalx
- Website: https://pretalx.org
- Docs: https://github.com/pretalx/pretalx
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Conference Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted conference management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python. Source code: https://github.com/pretalx/pretalx
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

pretalx is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://pretalx.org
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/pretalx/pretalx
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/pretalx/pretalx
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/pretalx/pretalx
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/pretalx/pretalx

### Pretix

- Slug: pretix
- URL: https://www.canagentsuse.com/tools/pretix
- Website: https://pretix.eu/
- Docs: https://github.com/pretix/pretix
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, E-commerce
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted e-commerce workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python, Docker. Source code: https://github.com/pretix/pretix
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Pretix is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://pretix.eu/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/pretix/pretix
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/pretix/pretix
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/pretix/pretix
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/pretix/pretix

### Publify

- Slug: publify
- URL: https://www.canagentsuse.com/tools/publify
- Website: https://publify.github.io/
- Docs: https://github.com/publify/publify
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Content Management Systems (CMS)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted content management systems (cms) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Ruby. Source code: https://github.com/publify/publify
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Publify is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://publify.github.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/publify/publify
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/publify/publify
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/publify/publify
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/publify/publify

### Puter

- Slug: puter
- URL: https://www.canagentsuse.com/tools/puter
- Website: https://puter.com/
- Docs: https://github.com/heyputer/puter
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, File Transfer & Synchronization, Remote Access
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted file transfer & synchronization workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/heyputer/puter
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Puter is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://puter.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/heyputer/puter
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/heyputer/puter
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/heyputer/puter
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/heyputer/puter

### QloApps

- Slug: qloapps
- URL: https://www.canagentsuse.com/tools/qloapps
- Website: https://qloapps.com/
- Docs: https://github.com/Qloapps/QloApps
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Booking and Scheduling
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted booking and scheduling workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as OSL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP, Nodejs. Source code: https://github.com/Qloapps/QloApps
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

QloApps is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://qloapps.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Qloapps/QloApps
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Qloapps/QloApps
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Qloapps/QloApps
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Qloapps/QloApps

### qpixel

- Slug: qpixel
- URL: https://www.canagentsuse.com/tools/qpixel
- Website: https://codidact.com/
- Docs: https://github.com/codidact/qpixel
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Social Networks and Forums
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - social networks and forums workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Ruby. Source code: https://github.com/codidact/qpixel
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

qpixel is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://codidact.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/codidact/qpixel
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/codidact/qpixel
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/codidact/qpixel
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/codidact/qpixel

### Radarr

- Slug: radarr
- URL: https://www.canagentsuse.com/tools/radarr
- Website: https://radarr.video/
- Docs: https://github.com/Radarr/Radarr
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Media Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted media management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C#, Docker. Source code: https://github.com/Radarr/Radarr
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Radarr is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://radarr.video/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Radarr/Radarr
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Radarr/Radarr
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Radarr/Radarr
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Radarr/Radarr

### Rallly

- Slug: rallly
- URL: https://www.canagentsuse.com/tools/rallly
- Website: https://rallly.co
- Docs: https://github.com/lukevella/rallly
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Booking and Scheduling, Polls and Events
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted booking and scheduling workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/lukevella/rallly
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Rallly is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://rallly.co
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/lukevella/rallly
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/lukevella/rallly
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/lukevella/rallly
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/lukevella/rallly

### Raneto

- Slug: raneto
- URL: https://www.canagentsuse.com/tools/raneto
- Website: https://raneto.com/
- Docs: https://github.com/ryanlelek/Raneto
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Wikis
- Use cases: Self-host a tool, Inspect open source, Publish content
- Best for: Self-hosted wikis workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs. Source code: https://github.com/ryanlelek/Raneto
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Raneto is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://raneto.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/ryanlelek/Raneto
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/ryanlelek/Raneto
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/ryanlelek/Raneto
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/ryanlelek/Raneto

### Razzia

- Slug: razzia
- URL: https://www.canagentsuse.com/tools/razzia
- Website: https://github.com/Ralex91/Razzia
- Docs: https://github.com/Ralex91/Razzia
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Games
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted games workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/Ralex91/Razzia
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Razzia is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/Ralex91/Razzia
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Ralex91/Razzia
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Ralex91/Razzia
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Ralex91/Razzia
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Ralex91/Razzia

### Reactive Resume

- Slug: reactive-resume
- URL: https://www.canagentsuse.com/tools/reactive-resume
- Website: https://rxresu.me/
- Docs: https://github.com/AmruthPillai/Reactive-Resume
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Miscellaneous
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted miscellaneous workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Nodejs. Source code: https://github.com/AmruthPillai/Reactive-Resume
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Reactive Resume is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://rxresu.me/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/AmruthPillai/Reactive-Resume
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/AmruthPillai/Reactive-Resume
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/AmruthPillai/Reactive-Resume
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/AmruthPillai/Reactive-Resume

### reader

- Slug: reader
- URL: https://www.canagentsuse.com/tools/reader
- Website: https://github.com/lemon24/reader
- Docs: https://github.com/lemon24/reader
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Feed Readers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted feed readers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as BSD-3-Clause; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python. Source code: https://github.com/lemon24/reader
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

reader is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/lemon24/reader
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/lemon24/reader
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/lemon24/reader
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/lemon24/reader
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/lemon24/reader

### Readflow

- Slug: readflow
- URL: https://www.canagentsuse.com/tools/readflow
- Website: https://readflow.app
- Docs: https://github.com/ncarlier/readflow
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Feed Readers
- Use cases: Self-host a tool, Inspect open source, Triage work
- Best for: Self-hosted feed readers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker. Source code: https://github.com/ncarlier/readflow
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Readflow is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://readflow.app
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/ncarlier/readflow
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/ncarlier/readflow
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/ncarlier/readflow
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/ncarlier/readflow

### RecipeSage

- Slug: recipesage
- URL: https://www.canagentsuse.com/tools/recipesage
- Website: https://github.com/julianpoy/recipesage
- Docs: https://github.com/julianpoy/recipesage
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Recipe Management, Inventory Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted recipe management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs. Source code: https://github.com/julianpoy/recipesage
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

RecipeSage is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/julianpoy/recipesage
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/julianpoy/recipesage
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/julianpoy/recipesage
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/julianpoy/recipesage
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/julianpoy/recipesage

### Recipya

- Slug: recipya
- URL: https://www.canagentsuse.com/tools/recipya
- Website: https://recipes.musicavis.ca
- Docs: https://github.com/reaper47/recipya
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Recipe Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted recipe management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Go. Source code: https://github.com/reaper47/recipya
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Recipya is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://recipes.musicavis.ca
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/reaper47/recipya
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/reaper47/recipya
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/reaper47/recipya
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/reaper47/recipya

### Redash

- Slug: redash
- URL: https://www.canagentsuse.com/tools/redash
- Website: http://redash.io
- Docs: https://github.com/getredash/redash
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Analytics
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Analyze product, Triage work
- Best for: Self-hosted analytics workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as BSD-2-Clause; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/getredash/redash
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Redash is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: http://redash.io
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/getredash/redash
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/getredash/redash
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/getredash/redash
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/getredash/redash

### REDAXO

- Slug: redaxo
- URL: https://www.canagentsuse.com/tools/redaxo
- Website: https://www.redaxo.org
- Docs: https://github.com/redaxo/core
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Content Management Systems (CMS)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted content management systems (cms) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP, Docker. Source code: https://github.com/redaxo/core
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

REDAXO is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.redaxo.org
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/redaxo/core
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/redaxo/core
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/redaxo/core
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/redaxo/core

### Redlib

- Slug: redlib
- URL: https://www.canagentsuse.com/tools/redlib
- Website: https://github.com/redlib-org/redlib
- Docs: https://github.com/redlib-org/redlib
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Social Networks and Forums
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - social networks and forums workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Rust. Source code: https://github.com/redlib-org/redlib
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Redlib is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/redlib-org/redlib
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/redlib-org/redlib
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/redlib-org/redlib
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/redlib-org/redlib
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/redlib-org/redlib

### REI3

- Slug: rei3
- URL: https://www.canagentsuse.com/tools/rei3
- Website: https://rei3.de/home_en/
- Docs: https://github.com/r3-team/r3
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Money, Budgeting & Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted money, budgeting & management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go. Source code: https://github.com/r3-team/r3
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

REI3 is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://rei3.de/home_en/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/r3-team/r3
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/r3-team/r3
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/r3-team/r3
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/r3-team/r3

### RELATE

- Slug: relate
- URL: https://www.canagentsuse.com/tools/relate
- Website: https://documen.tician.de/relate/
- Docs: https://github.com/inducer/relate
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Learning and Courses
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted learning and courses workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python. Source code: https://github.com/inducer/relate
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

RELATE is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://documen.tician.de/relate/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/inducer/relate
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/inducer/relate
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/inducer/relate
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/inducer/relate

### remark42

- Slug: remark42
- URL: https://www.canagentsuse.com/tools/remark42
- Website: https://remark42.com/
- Docs: https://github.com/umputun/remark42
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Social Networks and Forums
- Use cases: Self-host a tool, Inspect open source, Analyze product, Publish content
- Best for: Self-hosted communication - social networks and forums workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Go. Source code: https://github.com/umputun/remark42
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

remark42 is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://remark42.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/umputun/remark42
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/umputun/remark42
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/umputun/remark42
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/umputun/remark42

### Request Tracker

- Slug: request-tracker
- URL: https://www.canagentsuse.com/tools/request-tracker
- Website: https://www.bestpractical.com/rt/
- Docs: https://github.com/bestpractical/rt
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Ticketing
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted ticketing workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Perl. Source code: https://github.com/bestpractical/rt
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Request Tracker is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.bestpractical.com/rt/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/bestpractical/rt
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/bestpractical/rt
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/bestpractical/rt
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/bestpractical/rt

### RetroShare

- Slug: retroshare
- URL: https://www.canagentsuse.com/tools/retroshare
- Website: https://retroshare.cc
- Docs: https://github.com/RetroShare/RetroShare
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Custom Communication Systems
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - custom communication systems workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C++. Source code: https://github.com/RetroShare/RetroShare
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

RetroShare is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://retroshare.cc
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/RetroShare/RetroShare
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/RetroShare/RetroShare
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/RetroShare/RetroShare
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/RetroShare/RetroShare

### revealjs

- Slug: revealjs
- URL: https://www.canagentsuse.com/tools/revealjs
- Website: https://revealjs.com
- Docs: https://github.com/hakimel/reveal.js
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Miscellaneous
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted miscellaneous workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Javascript. Source code: https://github.com/hakimel/reveal.js
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

revealjs is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://revealjs.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/hakimel/reveal.js
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/hakimel/reveal.js
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/hakimel/reveal.js
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/hakimel/reveal.js

### Review Board

- Slug: review-board
- URL: https://www.canagentsuse.com/tools/review-board
- Website: https://www.reviewboard.org/
- Docs: https://github.com/reviewboard/reviewboard
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Software Development - Project Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted software development - project management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python, Docker. Source code: https://github.com/reviewboard/reviewboard
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Review Board is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.reviewboard.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/reviewboard/reviewboard
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/reviewboard/reviewboard
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/reviewboard/reviewboard
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/reviewboard/reviewboard

### Rocket.Chat

- Slug: rocket-chat
- URL: https://www.canagentsuse.com/tools/rocket-chat
- Website: https://rocket.chat/
- Docs: https://github.com/RocketChat/Rocket.Chat
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Custom Communication Systems
- Use cases: Self-host a tool, Inspect open source, Triage work
- Best for: Self-hosted communication - custom communication systems workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker, K8S. Source code: https://github.com/RocketChat/Rocket.Chat
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Rocket.Chat is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://rocket.chat/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/RocketChat/Rocket.Chat
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/RocketChat/Rocket.Chat
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/RocketChat/Rocket.Chat
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/RocketChat/Rocket.Chat

### RomM

- Slug: romm
- URL: https://www.canagentsuse.com/tools/romm
- Website: https://romm.app/
- Docs: https://github.com/rommapp/romm
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Games - Administrative Utilities & Control Panels
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted games - administrative utilities & control panels workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/rommapp/romm
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

RomM is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://romm.app/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/rommapp/romm
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/rommapp/romm
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/rommapp/romm
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/rommapp/romm

### RSS-Bridge

- Slug: rss-bridge
- URL: https://www.canagentsuse.com/tools/rss-bridge
- Website: https://github.com/RSS-Bridge/rss-bridge
- Docs: https://github.com/RSS-Bridge/rss-bridge
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Feed Readers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted feed readers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Unlicense; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP, Docker. Source code: https://github.com/RSS-Bridge/rss-bridge
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

RSS-Bridge is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/RSS-Bridge/rss-bridge
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/RSS-Bridge/rss-bridge
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/RSS-Bridge/rss-bridge
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/RSS-Bridge/rss-bridge
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/RSS-Bridge/rss-bridge

### RSS2EMail

- Slug: rss2email
- URL: https://www.canagentsuse.com/tools/rss2email
- Website: https://github.com/rss2email/rss2email
- Docs: https://github.com/rss2email/rss2email
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Feed Readers
- Use cases: Self-host a tool, Inspect open source, Publish content
- Best for: Self-hosted feed readers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python, deb. Source code: https://github.com/rss2email/rss2email
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

RSS2EMail is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/rss2email/rss2email
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/rss2email/rss2email
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/rss2email/rss2email
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/rss2email/rss2email
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/rss2email/rss2email

### RSSHub

- Slug: rsshub
- URL: https://www.canagentsuse.com/tools/rsshub
- Website: https://docs.rsshub.app
- Docs: https://github.com/DIYgod/RSSHub
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Feed Readers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted feed readers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/DIYgod/RSSHub
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

RSSHub is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://docs.rsshub.app
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/DIYgod/RSSHub
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/DIYgod/RSSHub
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/DIYgod/RSSHub
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/DIYgod/RSSHub

### rustypaste

- Slug: rustypaste
- URL: https://www.canagentsuse.com/tools/rustypaste
- Website: https://github.com/orhun/rustypaste
- Docs: https://github.com/orhun/rustypaste
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Pastebins
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted pastebins workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Rust. Source code: https://github.com/orhun/rustypaste
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

rustypaste is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/orhun/rustypaste
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/orhun/rustypaste
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/orhun/rustypaste
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/orhun/rustypaste
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/orhun/rustypaste

### Rybbit

- Slug: rybbit
- URL: https://www.canagentsuse.com/tools/rybbit
- Website: https://rybbit.com/
- Docs: https://github.com/rybbit-io/rybbit
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Analytics
- Use cases: Self-host a tool, Inspect open source, Analyze product
- Best for: Self-hosted analytics workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/rybbit-io/rybbit
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Rybbit is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://rybbit.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/rybbit-io/rybbit
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/rybbit-io/rybbit
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/rybbit-io/rybbit
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/rybbit-io/rybbit

### ryot

- Slug: ryot
- URL: https://www.canagentsuse.com/tools/ryot
- Website: https://github.com/ignisda/ryot
- Docs: https://github.com/ignisda/ryot
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Personal Dashboards
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted personal dashboards workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/ignisda/ryot
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

ryot is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/ignisda/ryot
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/ignisda/ryot
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/ignisda/ryot
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/ignisda/ryot
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/ignisda/ryot

### Saleor

- Slug: saleor
- URL: https://www.canagentsuse.com/tools/saleor
- Website: https://saleor.io
- Docs: https://github.com/saleor/saleor
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, E-commerce
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted e-commerce workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as BSD-3-Clause; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Python. Source code: https://github.com/saleor/saleor
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Saleor is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://saleor.io
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/saleor/saleor
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/saleor/saleor
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/saleor/saleor
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/saleor/saleor

### Scribble.rs

- Slug: scribble-rs
- URL: https://www.canagentsuse.com/tools/scribble-rs
- Website: https://github.com/scribble-rs/scribble.rs
- Docs: https://github.com/scribble-rs/scribble.rs
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Games
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted games workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as BSD-3-Clause; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker. Source code: https://github.com/scribble-rs/scribble.rs
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Scribble.rs is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/scribble-rs/scribble.rs
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/scribble-rs/scribble.rs
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/scribble-rs/scribble.rs
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/scribble-rs/scribble.rs
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/scribble-rs/scribble.rs

### Seafile

- Slug: seafile
- URL: https://www.canagentsuse.com/tools/seafile
- Website: https://www.seafile.com/en/home/
- Docs: https://github.com/haiwen/seafile
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, File Transfer & Synchronization, Groupware
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted file transfer & synchronization workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0, GPL-3.0, AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C. Source code: https://github.com/haiwen/seafile
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Seafile is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.seafile.com/en/home/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/haiwen/seafile
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/haiwen/seafile
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/haiwen/seafile
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/haiwen/seafile

### Seatsurfing

- Slug: seatsurfing
- URL: https://www.canagentsuse.com/tools/seatsurfing
- Website: https://seatsurfing.app/
- Docs: https://github.com/seatsurfing/seatsurfing
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Booking and Scheduling
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted booking and scheduling workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/seatsurfing/seatsurfing
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Seatsurfing is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://seatsurfing.app/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/seatsurfing/seatsurfing
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/seatsurfing/seatsurfing
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/seatsurfing/seatsurfing
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/seatsurfing/seatsurfing

### Selfoss

- Slug: selfoss
- URL: https://www.canagentsuse.com/tools/selfoss
- Website: https://selfoss.aditu.de/
- Docs: https://github.com/fossar/selfoss
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Feed Readers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted feed readers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/fossar/selfoss
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Selfoss is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://selfoss.aditu.de/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/fossar/selfoss
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/fossar/selfoss
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/fossar/selfoss
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/fossar/selfoss

### Send

- Slug: send
- URL: https://www.canagentsuse.com/tools/send
- Website: https://gitlab.com/timvisee/send
- Docs: https://gitlab.com/timvisee/send
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, File Transfer - Peer-to-peer Filesharing
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted file transfer - peer-to-peer filesharing workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://gitlab.com/timvisee/send
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Send is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://gitlab.com/timvisee/send
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://gitlab.com/timvisee/send
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://gitlab.com/timvisee/send
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://gitlab.com/timvisee/send
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://gitlab.com/timvisee/send

### Servas

- Slug: servas
- URL: https://www.canagentsuse.com/tools/servas
- Website: https://github.com/beromir/Servas
- Docs: https://github.com/beromir/Servas
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Bookmarks and Link Sharing
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted bookmarks and link sharing workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Nodejs, PHP. Source code: https://github.com/beromir/Servas
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Servas is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/beromir/Servas
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/beromir/Servas
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/beromir/Servas
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/beromir/Servas
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/beromir/Servas

### Shaper

- Slug: shaper
- URL: https://www.canagentsuse.com/tools/shaper
- Website: https://taleshape.com/shaper/docs
- Docs: https://github.com/taleshape-com/shaper
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Analytics
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Analyze product, Triage work
- Best for: Self-hosted analytics workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Nodejs, Python, Go. Source code: https://github.com/taleshape-com/shaper
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Shaper is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://taleshape.com/shaper/docs
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/taleshape-com/shaper
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/taleshape-com/shaper
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/taleshape-com/shaper
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/taleshape-com/shaper

### Sharetribe

- Slug: sharetribe
- URL: https://www.canagentsuse.com/tools/sharetribe
- Website: https://www.sharetribe.com
- Docs: https://github.com/sharetribe/sharetribe
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, E-commerce
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted e-commerce workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as ⊘ Proprietary; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Ruby. Source code: https://github.com/sharetribe/sharetribe
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Sharetribe is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.sharetribe.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/sharetribe/sharetribe
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/sharetribe/sharetribe
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/sharetribe/sharetribe
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/sharetribe/sharetribe

### Shhh

- Slug: shhh
- URL: https://www.canagentsuse.com/tools/shhh
- Website: https://github.com/smallwat3r/shhh
- Docs: https://github.com/smallwat3r/shhh
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Custom Communication Systems
- Use cases: Self-host a tool, Inspect open source, Analyze product
- Best for: Self-hosted communication - custom communication systems workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python. Source code: https://github.com/smallwat3r/shhh
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Shhh is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/smallwat3r/shhh
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/smallwat3r/shhh
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/smallwat3r/shhh
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/smallwat3r/shhh
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/smallwat3r/shhh

### Shiori

- Slug: shiori
- URL: https://www.canagentsuse.com/tools/shiori
- Website: https://github.com/go-shiori/shiori
- Docs: https://github.com/go-shiori/shiori
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Bookmarks and Link Sharing
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted bookmarks and link sharing workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker. Source code: https://github.com/go-shiori/shiori
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Shiori is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/go-shiori/shiori
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/go-shiori/shiori
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/go-shiori/shiori
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/go-shiori/shiori
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/go-shiori/shiori

### ShipShipShip

- Slug: shipshipship
- URL: https://www.canagentsuse.com/tools/shipshipship
- Website: https://shipshipship.io
- Docs: https://github.com/GauthierNelkinsky/ShipShipShip
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Software Development - Project Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Analyze product
- Best for: Self-hosted software development - project management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/GauthierNelkinsky/ShipShipShip
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

ShipShipShip is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://shipshipship.io
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/GauthierNelkinsky/ShipShipShip
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/GauthierNelkinsky/ShipShipShip
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/GauthierNelkinsky/ShipShipShip
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/GauthierNelkinsky/ShipShipShip

### SHKeeper

- Slug: shkeeper
- URL: https://www.canagentsuse.com/tools/shkeeper
- Website: https://shkeeper.io/
- Docs: https://github.com/vsys-host/shkeeper.io
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Money, Budgeting & Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted money, budgeting & management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python. Source code: https://github.com/vsys-host/shkeeper.io
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

SHKeeper is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://shkeeper.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/vsys-host/shkeeper.io
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/vsys-host/shkeeper.io
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/vsys-host/shkeeper.io
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/vsys-host/shkeeper.io

### Shopware Community Edition

- Slug: shopware-community-edition
- URL: https://www.canagentsuse.com/tools/shopware-community-edition
- Website: https://www.shopware.com/en/community/community-edition/
- Docs: https://github.com/shopware/shopware
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, E-commerce
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted e-commerce workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/shopware/shopware
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Shopware Community Edition is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.shopware.com/en/community/community-edition/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/shopware/shopware
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/shopware/shopware
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/shopware/shopware
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/shopware/shopware

### sigal

- Slug: sigal
- URL: https://www.canagentsuse.com/tools/sigal
- Website: https://github.com/saimn/sigal
- Docs: https://github.com/saimn/sigal
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Photo Galleries
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted photo galleries workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python. Source code: https://github.com/saimn/sigal
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

sigal is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/saimn/sigal
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/saimn/sigal
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/saimn/sigal
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/saimn/sigal
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/saimn/sigal

### Signature PDF

- Slug: signature-pdf
- URL: https://www.canagentsuse.com/tools/signature-pdf
- Website: https://github.com/24eme/signaturepdf
- Docs: https://github.com/24eme/signaturepdf
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Document Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content, Triage work
- Best for: Self-hosted document management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP, deb, Docker. Source code: https://github.com/24eme/signaturepdf
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Signature PDF is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/24eme/signaturepdf
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/24eme/signaturepdf
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/24eme/signaturepdf
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/24eme/signaturepdf
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/24eme/signaturepdf

### SilverBullet

- Slug: silverbullet
- URL: https://www.canagentsuse.com/tools/silverbullet
- Website: https://silverbullet.md/
- Docs: https://github.com/silverbulletmd/silverbullet
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Note-taking & Editors, Pastebins
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted note-taking & editors workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Deno. Source code: https://github.com/silverbulletmd/silverbullet
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

SilverBullet is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://silverbullet.md/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/silverbulletmd/silverbullet
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/silverbulletmd/silverbullet
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/silverbulletmd/silverbullet
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/silverbulletmd/silverbullet

### Simple Machines Forum

- Slug: simple-machines-forum
- URL: https://www.canagentsuse.com/tools/simple-machines-forum
- Website: https://www.simplemachines.org/
- Docs: https://github.com/SimpleMachines/SMF
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Social Networks and Forums
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - social networks and forums workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as BSD-3-Clause; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/SimpleMachines/SMF
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Simple Machines Forum is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.simplemachines.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/SimpleMachines/SMF
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/SimpleMachines/SMF
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/SimpleMachines/SMF
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/SimpleMachines/SMF

### SimpleX Chat

- Slug: simplex-chat
- URL: https://www.canagentsuse.com/tools/simplex-chat
- Website: https://github.com/simplex-chat/simplex-chat
- Docs: https://github.com/simplex-chat/simplex-chat
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Custom Communication Systems
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - custom communication systems workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Haskell. Source code: https://github.com/simplex-chat/simplex-chat
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

SimpleX Chat is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/simplex-chat/simplex-chat
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/simplex-chat/simplex-chat
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/simplex-chat/simplex-chat
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/simplex-chat/simplex-chat
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/simplex-chat/simplex-chat

### SIP Irrigation Control

- Slug: sip-irrigation-control
- URL: https://www.canagentsuse.com/tools/sip-irrigation-control
- Website: https://dan-in-ca.github.io/SIP/
- Docs: https://github.com/Dan-in-CA/SIP
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Internet of Things (IoT)
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted internet of things (iot) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python. Source code: https://github.com/Dan-in-CA/SIP
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

SIP Irrigation Control is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://dan-in-ca.github.io/SIP/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Dan-in-CA/SIP
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Dan-in-CA/SIP
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Dan-in-CA/SIP
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Dan-in-CA/SIP

### SIPCAPTURE Homer

- Slug: sipcapture-homer
- URL: https://www.canagentsuse.com/tools/sipcapture-homer
- Website: https://www.sipcapture.org/
- Docs: https://github.com/sipcapture/homer
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - SIP
- Use cases: Self-host a tool, Inspect open source, Analyze product
- Best for: Self-hosted communication - sip workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Go, Docker. Source code: https://github.com/sipcapture/homer
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

SIPCAPTURE Homer is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.sipcapture.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/sipcapture/homer
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/sipcapture/homer
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/sipcapture/homer
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/sipcapture/homer

### sish

- Slug: sish
- URL: https://www.canagentsuse.com/tools/sish
- Website: https://github.com/antoniomika/sish
- Docs: https://github.com/antoniomika/sish
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Proxy
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted proxy workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker. Source code: https://github.com/antoniomika/sish
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

sish is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/antoniomika/sish
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/antoniomika/sish
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/antoniomika/sish
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/antoniomika/sish
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/antoniomika/sish

### sist2

- Slug: sist2
- URL: https://www.canagentsuse.com/tools/sist2
- Website: https://github.com/sist2app/sist2
- Docs: https://github.com/sist2app/sist2
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Search Engines
- Use cases: Self-host a tool, Inspect open source, Triage work
- Best for: Self-hosted search engines workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C, Docker. Source code: https://github.com/sist2app/sist2
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

sist2 is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/sist2app/sist2
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/sist2app/sist2
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/sist2app/sist2
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/sist2app/sist2
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/sist2app/sist2

### Slash

- Slug: slash
- URL: https://www.canagentsuse.com/tools/slash
- Website: https://github.com/yourselfhosted/slash
- Docs: https://github.com/yourselfhosted/slash
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Bookmarks and Link Sharing
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted bookmarks and link sharing workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/yourselfhosted/slash
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Slash is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/yourselfhosted/slash
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/yourselfhosted/slash
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/yourselfhosted/slash
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/yourselfhosted/slash
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/yourselfhosted/slash

### Socialhome

- Slug: socialhome
- URL: https://www.canagentsuse.com/tools/socialhome
- Website: https://socialhome.network
- Docs: https://github.com/jaywink/socialhome
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Social Networks and Forums
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - social networks and forums workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Python. Source code: https://github.com/jaywink/socialhome
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Socialhome is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://socialhome.network
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/jaywink/socialhome
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/jaywink/socialhome
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/jaywink/socialhome
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/jaywink/socialhome

### Socioboard

- Slug: socioboard
- URL: https://www.canagentsuse.com/tools/socioboard
- Website: https://github.com/socioboard/Socioboard-5.0
- Docs: https://github.com/socioboard/Socioboard-5.0
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Analytics
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Analyze product
- Best for: Self-hosted analytics workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs. Source code: https://github.com/socioboard/Socioboard-5.0
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Socioboard is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/socioboard/Socioboard-5.0
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/socioboard/Socioboard-5.0
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/socioboard/Socioboard-5.0
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/socioboard/Socioboard-5.0
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/socioboard/Socioboard-5.0

### SOGo

- Slug: sogo
- URL: https://www.canagentsuse.com/tools/sogo
- Website: https://www.sogo.nu/
- Docs: https://github.com/Alinto/sogo
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Groupware
- Use cases: Self-host a tool, Inspect open source, Triage work
- Best for: Self-hosted groupware workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as LGPL-2.1; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Objective-C. Source code: https://github.com/Alinto/sogo
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

SOGo is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.sogo.nu/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Alinto/sogo
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Alinto/sogo
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Alinto/sogo
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Alinto/sogo

### SolidInvoice

- Slug: solidinvoice
- URL: https://www.canagentsuse.com/tools/solidinvoice
- Website: https://solidinvoice.co
- Docs: https://github.com/SolidInvoice/SolidInvoice
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Money, Budgeting & Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted money, budgeting & management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/SolidInvoice/SolidInvoice
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

SolidInvoice is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://solidinvoice.co
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/SolidInvoice/SolidInvoice
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/SolidInvoice/SolidInvoice
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/SolidInvoice/SolidInvoice
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/SolidInvoice/SolidInvoice

### solidtime

- Slug: solidtime
- URL: https://www.canagentsuse.com/tools/solidtime
- Website: https://www.solidtime.io
- Docs: https://github.com/solidtime-io/solidtime
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Time Tracking
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted time tracking workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/solidtime-io/solidtime
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

solidtime is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.solidtime.io
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/solidtime-io/solidtime
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/solidtime-io/solidtime
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/solidtime-io/solidtime
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/solidtime-io/solidtime

### Solidus

- Slug: solidus
- URL: https://www.canagentsuse.com/tools/solidus
- Website: https://solidus.io/
- Docs: https://github.com/solidusio/solidus
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, E-commerce
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted e-commerce workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as BSD-3-Clause; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Ruby, Docker. Source code: https://github.com/solidusio/solidus
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Solidus is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://solidus.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/solidusio/solidus
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/solidusio/solidus
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/solidusio/solidus
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/solidusio/solidus

### Sonarr

- Slug: sonarr
- URL: https://www.canagentsuse.com/tools/sonarr
- Website: https://sonarr.tv/
- Docs: https://github.com/Sonarr/Sonarr
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Media Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted media management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C#, Docker. Source code: https://github.com/Sonarr/Sonarr
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Sonarr is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://sonarr.tv/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Sonarr/Sonarr
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Sonarr/Sonarr
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Sonarr/Sonarr
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Sonarr/Sonarr

### SourceBans++

- Slug: sourcebans
- URL: https://www.canagentsuse.com/tools/sourcebans
- Website: https://sbpp.github.io/
- Docs: https://github.com/sbpp/sourcebans-pp
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Games - Administrative Utilities & Control Panels
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted games - administrative utilities & control panels workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as CC-BY-SA-4.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/sbpp/sourcebans-pp
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

SourceBans++ is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://sbpp.github.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/sbpp/sourcebans-pp
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/sbpp/sourcebans-pp
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/sbpp/sourcebans-pp
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/sbpp/sourcebans-pp

### Spectrum 2

- Slug: spectrum-2
- URL: https://www.canagentsuse.com/tools/spectrum-2
- Website: https://spectrum.im/
- Docs: https://github.com/SpectrumIM/spectrum2
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Custom Communication Systems
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - custom communication systems workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C++. Source code: https://github.com/SpectrumIM/spectrum2
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Spectrum 2 is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://spectrum.im/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/SpectrumIM/spectrum2
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/SpectrumIM/spectrum2
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/SpectrumIM/spectrum2
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/SpectrumIM/spectrum2

### Speed Test by OpenSpeedTest™

- Slug: speed-test-by-openspeedtest
- URL: https://www.canagentsuse.com/tools/speed-test-by-openspeedtest
- Website: https://openspeedtest.com/
- Docs: https://github.com/openspeedtest/Speed-Test
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Network Utilities
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted network utilities workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/openspeedtest/Speed-Test
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Speed Test by OpenSpeedTest™ is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://openspeedtest.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/openspeedtest/Speed-Test
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/openspeedtest/Speed-Test
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/openspeedtest/Speed-Test
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/openspeedtest/Speed-Test

### Speedtest Tracker

- Slug: speedtest-tracker
- URL: https://www.canagentsuse.com/tools/speedtest-tracker
- Website: https://docs.speedtest-tracker.dev/
- Docs: https://github.com/alexjustesen/speedtest-tracker
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Network Utilities
- Use cases: Self-host a tool, Inspect open source, Analyze product
- Best for: Self-hosted network utilities workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, K8S. Source code: https://github.com/alexjustesen/speedtest-tracker
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Speedtest Tracker is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://docs.speedtest-tracker.dev/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/alexjustesen/speedtest-tracker
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/alexjustesen/speedtest-tracker
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/alexjustesen/speedtest-tracker
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/alexjustesen/speedtest-tracker

### Spoolman

- Slug: spoolman
- URL: https://www.canagentsuse.com/tools/spoolman
- Website: https://github.com/Donkie/Spoolman
- Docs: https://github.com/Donkie/Spoolman
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Inventory Management, Manufacturing
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted inventory management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Python. Source code: https://github.com/Donkie/Spoolman
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Spoolman is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/Donkie/Spoolman
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Donkie/Spoolman
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Donkie/Spoolman
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Donkie/Spoolman
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Donkie/Spoolman

### SQLPage

- Slug: sqlpage
- URL: https://www.canagentsuse.com/tools/sqlpage
- Website: https://sql-page.com
- Docs: https://github.com/sqlpage/SQLPage
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Software Development - Low Code
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted software development - low code workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Rust, Docker. Source code: https://github.com/sqlpage/SQLPage
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

SQLPage is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://sql-page.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/sqlpage/SQLPage
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/sqlpage/SQLPage
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/sqlpage/SQLPage
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/sqlpage/SQLPage

### Squidex

- Slug: squidex
- URL: https://www.canagentsuse.com/tools/squidex
- Website: https://squidex.io
- Docs: https://github.com/Squidex/squidex
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Content Management Systems (CMS)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted content management systems (cms) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: .NET. Source code: https://github.com/Squidex/squidex
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Squidex is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://squidex.io
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Squidex/squidex
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Squidex/squidex
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Squidex/squidex
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Squidex/squidex

### Sshwifty

- Slug: sshwifty
- URL: https://www.canagentsuse.com/tools/sshwifty
- Website: https://github.com/nirui/sshwifty
- Docs: https://github.com/nirui/sshwifty
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Remote Access
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted remote access workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker. Source code: https://github.com/nirui/sshwifty
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Sshwifty is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/nirui/sshwifty
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/nirui/sshwifty
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/nirui/sshwifty
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/nirui/sshwifty
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/nirui/sshwifty

### Standard Notes

- Slug: standard-notes
- URL: https://www.canagentsuse.com/tools/standard-notes
- Website: https://docs.standardnotes.com/self-hosting/getting-started
- Docs: https://github.com/standardnotes/app
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Note-taking & Editors
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted note-taking & editors workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Ruby. Source code: https://github.com/standardnotes/app
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Standard Notes is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://docs.standardnotes.com/self-hosting/getting-started
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/standardnotes/app
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/standardnotes/app
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/standardnotes/app
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/standardnotes/app

### Statistics for Strava

- Slug: statistics-for-strava
- URL: https://www.canagentsuse.com/tools/statistics-for-strava
- Website: https://github.com/robiningelbrecht/statistics-for-strava
- Docs: https://github.com/robiningelbrecht/statistics-for-strava
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Analytics, Health and Fitness
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Analyze product, Triage work
- Best for: Self-hosted analytics workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/robiningelbrecht/statistics-for-strava
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Statistics for Strava is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/robiningelbrecht/statistics-for-strava
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/robiningelbrecht/statistics-for-strava
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/robiningelbrecht/statistics-for-strava
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/robiningelbrecht/statistics-for-strava
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/robiningelbrecht/statistics-for-strava

### Stirling-PDF

- Slug: stirling-pdf
- URL: https://www.canagentsuse.com/tools/stirling-pdf
- Website: https://github.com/Stirling-Tools/Stirling-PDF
- Docs: https://github.com/Stirling-Tools/Stirling-PDF
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Document Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted document management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Java. Source code: https://github.com/Stirling-Tools/Stirling-PDF
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Stirling-PDF is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/Stirling-Tools/Stirling-PDF
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Stirling-Tools/Stirling-PDF
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Stirling-Tools/Stirling-PDF
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Stirling-Tools/Stirling-PDF
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Stirling-Tools/Stirling-PDF

### Stoat

- Slug: stoat
- URL: https://www.canagentsuse.com/tools/stoat
- Website: https://stoat.chat/
- Docs: https://github.com/stoatchat/self-hosted
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Custom Communication Systems
- Use cases: Self-host a tool, Inspect open source, Analyze product
- Best for: Self-hosted communication - custom communication systems workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0, MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Rust. Source code: https://github.com/stoatchat/self-hosted
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Stoat is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://stoat.chat/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/stoatchat/self-hosted
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/stoatchat/self-hosted
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/stoatchat/self-hosted
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/stoatchat/self-hosted

### Stretto

- Slug: stretto
- URL: https://www.canagentsuse.com/tools/stretto
- Website: https://github.com/benkaiser/stretto
- Docs: https://github.com/benkaiser/stretto
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Media Streaming - Audio Streaming
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted media streaming - audio streaming workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs. Source code: https://github.com/benkaiser/stretto
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Stretto is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/benkaiser/stretto
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/benkaiser/stretto
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/benkaiser/stretto
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/benkaiser/stretto
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/benkaiser/stretto

### string.is

- Slug: string-is
- URL: https://www.canagentsuse.com/tools/string-is
- Website: https://string.is/
- Docs: https://github.com/recurser/string-is
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Miscellaneous
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted miscellaneous workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs. Source code: https://github.com/recurser/string-is
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

string.is is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://string.is/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/recurser/string-is
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/recurser/string-is
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/recurser/string-is
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/recurser/string-is

### Stringer

- Slug: stringer
- URL: https://www.canagentsuse.com/tools/stringer
- Website: https://github.com/stringer-rss/stringer
- Docs: https://github.com/stringer-rss/stringer
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Feed Readers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted feed readers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Ruby. Source code: https://github.com/stringer-rss/stringer
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Stringer is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/stringer-rss/stringer
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/stringer-rss/stringer
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/stringer-rss/stringer
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/stringer-rss/stringer
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/stringer-rss/stringer

### Strix

- Slug: strix
- URL: https://www.canagentsuse.com/tools/strix
- Website: https://github.com/eduard256/Strix
- Docs: https://github.com/eduard256/Strix
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Video Surveillance
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted video surveillance workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker. Source code: https://github.com/eduard256/Strix
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Strix is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/eduard256/Strix
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/eduard256/Strix
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/eduard256/Strix
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/eduard256/Strix
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/eduard256/Strix

### SuiteCRM

- Slug: suitecrm
- URL: https://www.canagentsuse.com/tools/suitecrm
- Website: https://suitecrm.com
- Docs: https://github.com/SuiteCRM/SuiteCRM
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Customer Relationship Management (CRM)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted customer relationship management (crm) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/SuiteCRM/SuiteCRM
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

SuiteCRM is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://suitecrm.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/SuiteCRM/SuiteCRM
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/SuiteCRM/SuiteCRM
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/SuiteCRM/SuiteCRM
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/SuiteCRM/SuiteCRM

### Sunshine

- Slug: sunshine
- URL: https://www.canagentsuse.com/tools/sunshine
- Website: https://app.lizardbyte.dev/Sunshine/
- Docs: https://github.com/LizardByte/Sunshine
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Games - Administrative Utilities & Control Panels
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted games - administrative utilities & control panels workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C++, deb, Docker. Source code: https://github.com/LizardByte/Sunshine
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Sunshine is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://app.lizardbyte.dev/Sunshine/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/LizardByte/Sunshine
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/LizardByte/Sunshine
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/LizardByte/Sunshine
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/LizardByte/Sunshine

### Sup3rS3cretMes5age

- Slug: sup3rs3cretmes5age
- URL: https://www.canagentsuse.com/tools/sup3rs3cretmes5age
- Website: https://github.com/algolia/sup3rS3cretMes5age
- Docs: https://github.com/algolia/sup3rS3cretMes5age
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Pastebins
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted pastebins workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go. Source code: https://github.com/algolia/sup3rS3cretMes5age
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Sup3rS3cretMes5age is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/algolia/sup3rS3cretMes5age
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/algolia/sup3rS3cretMes5age
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/algolia/sup3rS3cretMes5age
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/algolia/sup3rS3cretMes5age
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/algolia/sup3rS3cretMes5age

### Super Productivity

- Slug: super-productivity
- URL: https://www.canagentsuse.com/tools/super-productivity
- Website: https://super-productivity.com
- Docs: https://github.com/super-productivity/super-productivity
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Task Management & To-do Lists
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted task management & to-do lists workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/super-productivity/super-productivity
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Super Productivity is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://super-productivity.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/super-productivity/super-productivity
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/super-productivity/super-productivity
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/super-productivity/super-productivity
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/super-productivity/super-productivity

### Superdesk

- Slug: superdesk
- URL: https://www.canagentsuse.com/tools/superdesk
- Website: https://superdesk.org/
- Docs: https://github.com/superdesk/superdesk
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Content Management Systems (CMS)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted content management systems (cms) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Python, PHP. Source code: https://github.com/superdesk/superdesk
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Superdesk is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://superdesk.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/superdesk/superdesk
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/superdesk/superdesk
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/superdesk/superdesk
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/superdesk/superdesk

### Superset

- Slug: superset
- URL: https://www.canagentsuse.com/tools/superset
- Website: http://superset.apache.org/
- Docs: https://github.com/apache/superset
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Analytics
- Use cases: Self-host a tool, Inspect open source, Analyze product, Triage work
- Best for: Self-hosted analytics workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python. Source code: https://github.com/apache/superset
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Superset is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: http://superset.apache.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/apache/superset
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/apache/superset
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/apache/superset
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/apache/superset

### Sure

- Slug: sure
- URL: https://www.canagentsuse.com/tools/sure
- Website: https://github.com/we-promise/sure
- Docs: https://github.com/we-promise/sure
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Money, Budgeting & Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted money, budgeting & management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/we-promise/sure
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Sure is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/we-promise/sure
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/we-promise/sure
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/we-promise/sure
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/we-promise/sure
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/we-promise/sure

### Suroi

- Slug: suroi
- URL: https://www.canagentsuse.com/tools/suroi
- Website: https://suroi.io/
- Docs: https://github.com/HasangerGames/suroi
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Games
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted games workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs. Source code: https://github.com/HasangerGames/suroi
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Suroi is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://suroi.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/HasangerGames/suroi
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/HasangerGames/suroi
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/HasangerGames/suroi
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/HasangerGames/suroi

### Sylius

- Slug: sylius
- URL: https://www.canagentsuse.com/tools/sylius
- Website: https://sylius.com
- Docs: https://github.com/Sylius/Sylius
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, E-commerce
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted e-commerce workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/Sylius/Sylius
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Sylius is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://sylius.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Sylius/Sylius
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Sylius/Sylius
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Sylius/Sylius
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Sylius/Sylius

### Sympa

- Slug: sympa
- URL: https://www.canagentsuse.com/tools/sympa
- Website: https://www.sympa.community/
- Docs: https://github.com/sympa-community/sympa
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Email - Mailing Lists and Newsletters
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - email - mailing lists and newsletters workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Perl. Source code: https://github.com/sympa-community/sympa
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Sympa is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.sympa.community/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/sympa-community/sympa
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/sympa-community/sympa
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/sympa-community/sympa
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/sympa-community/sympa

### Syncthing

- Slug: syncthing
- URL: https://www.canagentsuse.com/tools/syncthing
- Website: https://syncthing.net/
- Docs: https://github.com/syncthing/syncthing
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, File Transfer & Synchronization
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted file transfer & synchronization workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker, deb. Source code: https://github.com/syncthing/syncthing
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Syncthing is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://syncthing.net/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/syncthing/syncthing
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/syncthing/syncthing
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/syncthing/syncthing
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/syncthing/syncthing

### SyncTube

- Slug: synctube
- URL: https://www.canagentsuse.com/tools/synctube
- Website: https://github.com/RblSb/SyncTube
- Docs: https://github.com/RblSb/SyncTube
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Media Streaming - Video Streaming
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted media streaming - video streaming workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Haxe. Source code: https://github.com/RblSb/SyncTube
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

SyncTube is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/RblSb/SyncTube
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/RblSb/SyncTube
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/RblSb/SyncTube
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/RblSb/SyncTube
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/RblSb/SyncTube

### Talkyard

- Slug: talkyard
- URL: https://www.canagentsuse.com/tools/talkyard
- Website: https://www.talkyard.io/
- Docs: https://github.com/debiki/talkyard
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Social Networks and Forums
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - social networks and forums workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Scala. Source code: https://github.com/debiki/talkyard
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Talkyard is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.talkyard.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/debiki/talkyard
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/debiki/talkyard
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/debiki/talkyard
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/debiki/talkyard

### Tandoor Recipes

- Slug: tandoor-recipes
- URL: https://www.canagentsuse.com/tools/tandoor-recipes
- Website: https://docs.tandoor.dev/
- Docs: https://github.com/TandoorRecipes/recipes
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Recipe Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Triage work
- Best for: Self-hosted recipe management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT, Commons-Clause; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python, Docker, K8S. Source code: https://github.com/TandoorRecipes/recipes
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Tandoor Recipes is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://docs.tandoor.dev/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/TandoorRecipes/recipes
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/TandoorRecipes/recipes
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/TandoorRecipes/recipes
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/TandoorRecipes/recipes

### Tasks.md

- Slug: tasks-md
- URL: https://www.canagentsuse.com/tools/tasks-md
- Website: https://github.com/BaldissaraMatheus/Tasks.md
- Docs: https://github.com/BaldissaraMatheus/Tasks.md
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Task Management & To-do Lists
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted task management & to-do lists workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/BaldissaraMatheus/Tasks.md
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Tasks.md is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/BaldissaraMatheus/Tasks.md
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/BaldissaraMatheus/Tasks.md
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/BaldissaraMatheus/Tasks.md
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/BaldissaraMatheus/Tasks.md
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/BaldissaraMatheus/Tasks.md

### TeamMapper

- Slug: teammapper
- URL: https://www.canagentsuse.com/tools/teammapper
- Website: https://github.com/b310-digital/teammapper
- Docs: https://github.com/b310-digital/teammapper
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Knowledge Management Tools
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted knowledge management tools workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Nodejs. Source code: https://github.com/b310-digital/teammapper
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

TeamMapper is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/b310-digital/teammapper
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/b310-digital/teammapper
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/b310-digital/teammapper
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/b310-digital/teammapper
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/b310-digital/teammapper

### TeslaMate

- Slug: teslamate
- URL: https://www.canagentsuse.com/tools/teslamate
- Website: https://github.com/teslamate-org/teslamate
- Docs: https://github.com/teslamate-org/teslamate
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Miscellaneous
- Use cases: Self-host a tool, Inspect open source, Analyze product, Triage work
- Best for: Self-hosted miscellaneous workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Elixir, Docker. Source code: https://github.com/teslamate-org/teslamate
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

TeslaMate is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/teslamate-org/teslamate
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/teslamate-org/teslamate
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/teslamate-org/teslamate
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/teslamate-org/teslamate
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/teslamate-org/teslamate

### Textpattern

- Slug: textpattern
- URL: https://www.canagentsuse.com/tools/textpattern
- Website: https://textpattern.com/
- Docs: https://github.com/textpattern/textpattern
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Content Management Systems (CMS)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted content management systems (cms) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/textpattern/textpattern
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Textpattern is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://textpattern.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/textpattern/textpattern
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/textpattern/textpattern
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/textpattern/textpattern
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/textpattern/textpattern

### The Battle for Wesnoth

- Slug: the-battle-for-wesnoth
- URL: https://www.canagentsuse.com/tools/the-battle-for-wesnoth
- Website: https://github.com/wesnoth/wesnoth
- Docs: https://github.com/wesnoth/wesnoth
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Games
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted games workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C++, deb. Source code: https://github.com/wesnoth/wesnoth
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

The Battle for Wesnoth is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/wesnoth/wesnoth
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/wesnoth/wesnoth
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/wesnoth/wesnoth
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/wesnoth/wesnoth
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/wesnoth/wesnoth

### Thelia

- Slug: thelia
- URL: https://www.canagentsuse.com/tools/thelia
- Website: https://thelia.net/
- Docs: https://github.com/thelia/thelia
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, E-commerce
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted e-commerce workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as LGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/thelia/thelia
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Thelia is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://thelia.net/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/thelia/thelia
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/thelia/thelia
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/thelia/thelia
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/thelia/thelia

### Thingsboard

- Slug: thingsboard
- URL: https://www.canagentsuse.com/tools/thingsboard
- Website: https://thingsboard.io/
- Docs: https://github.com/thingsboard/thingsboard
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Internet of Things (IoT)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Triage work
- Best for: Self-hosted internet of things (iot) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Java, Docker, K8S. Source code: https://github.com/thingsboard/thingsboard
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Thingsboard is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://thingsboard.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/thingsboard/thingsboard
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/thingsboard/thingsboard
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/thingsboard/thingsboard
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/thingsboard/thingsboard

### Thumbor

- Slug: thumbor
- URL: https://www.canagentsuse.com/tools/thumbor
- Website: http://thumbor.org/
- Docs: https://github.com/thumbor/thumbor
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Photo Galleries
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted photo galleries workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python, Docker. Source code: https://github.com/thumbor/thumbor
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Thumbor is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: http://thumbor.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/thumbor/thumbor
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/thumbor/thumbor
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/thumbor/thumbor
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/thumbor/thumbor

### TiddlyWiki

- Slug: tiddlywiki
- URL: https://www.canagentsuse.com/tools/tiddlywiki
- Website: https://tiddlywiki.com/
- Docs: https://github.com/TiddlyWiki/TiddlyWiki5
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Wikis
- Use cases: Self-host a tool, Inspect open source, Publish content
- Best for: Self-hosted wikis workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as BSD-3-Clause; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs. Source code: https://github.com/TiddlyWiki/TiddlyWiki5
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

TiddlyWiki is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://tiddlywiki.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/TiddlyWiki/TiddlyWiki5
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/TiddlyWiki/TiddlyWiki5
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/TiddlyWiki/TiddlyWiki5
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/TiddlyWiki/TiddlyWiki5

### Tiledesk

- Slug: tiledesk
- URL: https://www.canagentsuse.com/tools/tiledesk
- Website: https://tiledesk.com
- Docs: https://github.com/Tiledesk/tiledesk
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Custom Communication Systems
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - custom communication systems workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, K8S. Source code: https://github.com/Tiledesk/tiledesk
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Tiledesk is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://tiledesk.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Tiledesk/tiledesk
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Tiledesk/tiledesk
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Tiledesk/tiledesk
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Tiledesk/tiledesk

### TimeTagger

- Slug: timetagger
- URL: https://www.canagentsuse.com/tools/timetagger
- Website: https://timetagger.app
- Docs: https://github.com/almarklein/timetagger
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Time Tracking
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted time tracking workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python. Source code: https://github.com/almarklein/timetagger
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

TimeTagger is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://timetagger.app
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/almarklein/timetagger
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/almarklein/timetagger
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/almarklein/timetagger
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/almarklein/timetagger

### Tiny File Manager

- Slug: tiny-file-manager
- URL: https://www.canagentsuse.com/tools/tiny-file-manager
- Website: https://tinyfilemanager.github.io
- Docs: https://github.com/prasathmani/tinyfilemanager
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, File Transfer - Web-based File Managers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted file transfer - web-based file managers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/prasathmani/tinyfilemanager
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Tiny File Manager is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://tinyfilemanager.github.io
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/prasathmani/tinyfilemanager
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/prasathmani/tinyfilemanager
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/prasathmani/tinyfilemanager
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/prasathmani/tinyfilemanager

### Tiny Tiny RSS

- Slug: tiny-tiny-rss
- URL: https://www.canagentsuse.com/tools/tiny-tiny-rss
- Website: https://tt-rss.org
- Docs: https://github.com/tt-rss/tt-rss
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Feed Readers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted feed readers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, PHP. Source code: https://github.com/tt-rss/tt-rss
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Tiny Tiny RSS is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://tt-rss.org
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/tt-rss/tt-rss
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/tt-rss/tt-rss
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/tt-rss/tt-rss
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/tt-rss/tt-rss

### Tinyproxy

- Slug: tinyproxy
- URL: https://www.canagentsuse.com/tools/tinyproxy
- Website: https://tinyproxy.github.io/
- Docs: https://github.com/tinyproxy/tinyproxy
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Proxy
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted proxy workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C, deb. Source code: https://github.com/tinyproxy/tinyproxy
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Tinyproxy is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://tinyproxy.github.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/tinyproxy/tinyproxy
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/tinyproxy/tinyproxy
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/tinyproxy/tinyproxy
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/tinyproxy/tinyproxy

### Titra

- Slug: titra
- URL: https://www.canagentsuse.com/tools/titra
- Website: https://titra.io/
- Docs: https://github.com/titraio/titra
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Software Development - Project Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted software development - project management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Javascript, Docker. Source code: https://github.com/titraio/titra
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Titra is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://titra.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/titraio/titra
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/titraio/titra
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/titraio/titra
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/titraio/titra

### Tolgee

- Slug: tolgee
- URL: https://www.canagentsuse.com/tools/tolgee
- Website: https://tolgee.io
- Docs: https://github.com/tolgee/tolgee-platform
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Software Development - Localization
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted software development - localization workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Java. Source code: https://github.com/tolgee/tolgee-platform
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Tolgee is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://tolgee.io
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/tolgee/tolgee-platform
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/tolgee/tolgee-platform
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/tolgee/tolgee-platform
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/tolgee/tolgee-platform

### ToolJet

- Slug: tooljet
- URL: https://www.canagentsuse.com/tools/tooljet
- Website: https://tooljet.io/
- Docs: https://github.com/ToolJet/ToolJet
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Software Development - Low Code
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted software development - low code workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker, K8S. Source code: https://github.com/ToolJet/ToolJet
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

ToolJet is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://tooljet.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/ToolJet/ToolJet
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/ToolJet/ToolJet
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/ToolJet/ToolJet
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/ToolJet/ToolJet

### Tox

- Slug: tox
- URL: https://www.canagentsuse.com/tools/tox
- Website: https://tox.chat/
- Docs: https://github.com/TokTok/c-toxcore
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Custom Communication Systems
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - custom communication systems workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C. Source code: https://github.com/TokTok/c-toxcore
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Tox is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://tox.chat/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/TokTok/c-toxcore
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/TokTok/c-toxcore
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/TokTok/c-toxcore
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/TokTok/c-toxcore

### Tracim

- Slug: tracim
- URL: https://www.canagentsuse.com/tools/tracim
- Website: https://github.com/tracim/tracim
- Docs: https://github.com/tracim/tracim
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Groupware
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted groupware workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0, LGPL-3.0, MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python. Source code: https://github.com/tracim/tracim
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Tracim is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/tracim/tracim
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/tracim/tracim
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/tracim/tracim
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/tracim/tracim
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/tracim/tracim

### Tracks

- Slug: tracks
- URL: https://www.canagentsuse.com/tools/tracks
- Website: https://www.getontracks.org/
- Docs: https://github.com/TracksApp/tracks
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Task Management & To-do Lists
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Analyze product, Publish content
- Best for: Self-hosted task management & to-do lists workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Ruby. Source code: https://github.com/TracksApp/tracks
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Tracks is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.getontracks.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/TracksApp/tracks
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/TracksApp/tracks
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/TracksApp/tracks
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/TracksApp/tracks

### Traduora

- Slug: traduora
- URL: https://www.canagentsuse.com/tools/traduora
- Website: https://traduora.co
- Docs: https://github.com/ever-co/ever-traduora
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Software Development - Localization
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted software development - localization workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, K8S, Nodejs. Source code: https://github.com/ever-co/ever-traduora
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Traduora is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://traduora.co
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/ever-co/ever-traduora
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/ever-co/ever-traduora
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/ever-co/ever-traduora
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/ever-co/ever-traduora

### TriliumNext Notes

- Slug: triliumnext-notes
- URL: https://www.canagentsuse.com/tools/triliumnext-notes
- Website: https://github.com/TriliumNext/Trilium
- Docs: https://github.com/TriliumNext/Trilium
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Note-taking & Editors
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted note-taking & editors workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker, K8S. Source code: https://github.com/TriliumNext/Trilium
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

TriliumNext Notes is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/TriliumNext/Trilium
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/TriliumNext/Trilium
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/TriliumNext/Trilium
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/TriliumNext/Trilium
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/TriliumNext/Trilium

### TRIP

- Slug: trip
- URL: https://www.canagentsuse.com/tools/trip
- Website: https://itskovacs-trip.netlify.app/
- Docs: https://github.com/itskovacs/trip
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Maps and Global Positioning System (GPS)
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted maps and global positioning system (gps) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/itskovacs/trip
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

TRIP is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://itskovacs-trip.netlify.app/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/itskovacs/trip
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/itskovacs/trip
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/itskovacs/trip
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/itskovacs/trip

### Tube Archivist

- Slug: tube-archivist
- URL: https://www.canagentsuse.com/tools/tube-archivist
- Website: https://tubearchivist.com/
- Docs: https://github.com/tubearchivist/tubearchivist
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Media Streaming - Video Streaming, Archiving and Digital Preservation (DP)
- Use cases: Self-host a tool, Inspect open source, Publish content, Triage work
- Best for: Self-hosted media streaming - video streaming workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/tubearchivist/tubearchivist
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Tube Archivist is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://tubearchivist.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/tubearchivist/tubearchivist
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/tubearchivist/tubearchivist
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/tubearchivist/tubearchivist
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/tubearchivist/tubearchivist

### Twenty

- Slug: twenty
- URL: https://www.canagentsuse.com/tools/twenty
- Website: https://twenty.com
- Docs: https://github.com/twentyhq/twenty
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Customer Relationship Management (CRM)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted customer relationship management (crm) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/twentyhq/twenty
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Twenty is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://twenty.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/twentyhq/twenty
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/twentyhq/twenty
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/twentyhq/twenty
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/twentyhq/twenty

### Typebot

- Slug: typebot
- URL: https://www.canagentsuse.com/tools/typebot
- Website: https://typebot.io
- Docs: https://github.com/baptisteArno/typebot.io
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Custom Communication Systems
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - custom communication systems workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/baptisteArno/typebot.io
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Typebot is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://typebot.io
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/baptisteArno/typebot.io
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/baptisteArno/typebot.io
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/baptisteArno/typebot.io
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/baptisteArno/typebot.io

### Typemill

- Slug: typemill
- URL: https://www.canagentsuse.com/tools/typemill
- Website: https://typemill.net/
- Docs: https://github.com/typemill/typemill
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Content Management Systems (CMS)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted content management systems (cms) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/typemill/typemill
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Typemill is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://typemill.net/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/typemill/typemill
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/typemill/typemill
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/typemill/typemill
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/typemill/typemill

### TYPO3

- Slug: typo3
- URL: https://www.canagentsuse.com/tools/typo3
- Website: https://typo3.org/
- Docs: https://github.com/TYPO3/typo3
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Content Management Systems (CMS)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted content management systems (cms) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/TYPO3/typo3
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

TYPO3 is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://typo3.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/TYPO3/typo3
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/TYPO3/typo3
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/TYPO3/typo3
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/TYPO3/typo3

### Umami

- Slug: umami
- URL: https://www.canagentsuse.com/tools/umami
- Website: https://umami.is/
- Docs: https://github.com/umami-software/umami
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Analytics
- Use cases: Self-host a tool, Inspect open source, Analyze product
- Best for: Self-hosted analytics workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/umami-software/umami
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Umami is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://umami.is/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/umami-software/umami
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/umami-software/umami
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/umami-software/umami
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/umami-software/umami

### Umbraco

- Slug: umbraco
- URL: https://www.canagentsuse.com/tools/umbraco
- Website: https://umbraco.com/
- Docs: https://github.com/umbraco/Umbraco-CMS
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Content Management Systems (CMS)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted content management systems (cms) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: .NET. Source code: https://github.com/umbraco/Umbraco-CMS
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Umbraco is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://umbraco.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/umbraco/Umbraco-CMS
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/umbraco/Umbraco-CMS
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/umbraco/Umbraco-CMS
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/umbraco/Umbraco-CMS

### Unison

- Slug: unison
- URL: https://www.canagentsuse.com/tools/unison
- Website: https://www.cis.upenn.edu/~bcpierce/unison/
- Docs: https://github.com/bcpierce00/unison
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, File Transfer & Synchronization
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted file transfer & synchronization workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: deb, OCaml. Source code: https://github.com/bcpierce00/unison
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Unison is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.cis.upenn.edu/~bcpierce/unison/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/bcpierce00/unison
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/bcpierce00/unison
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/bcpierce00/unison
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/bcpierce00/unison

### untrusted

- Slug: untrusted
- URL: https://www.canagentsuse.com/tools/untrusted
- Website: https://github.com/AlexNisnevich/untrusted
- Docs: https://github.com/AlexNisnevich/untrusted
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Games
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted games workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as CC-BY-NC-SA-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs. Source code: https://github.com/AlexNisnevich/untrusted
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

untrusted is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/AlexNisnevich/untrusted
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/AlexNisnevich/untrusted
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/AlexNisnevich/untrusted
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/AlexNisnevich/untrusted
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/AlexNisnevich/untrusted

### Upsnap

- Slug: upsnap
- URL: https://www.canagentsuse.com/tools/upsnap
- Website: https://github.com/seriousm4x/UpSnap
- Docs: https://github.com/seriousm4x/UpSnap
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Network Utilities
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted network utilities workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker. Source code: https://github.com/seriousm4x/UpSnap
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Upsnap is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/seriousm4x/UpSnap
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/seriousm4x/UpSnap
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/seriousm4x/UpSnap
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/seriousm4x/UpSnap
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/seriousm4x/UpSnap

### Upvote RSS

- Slug: upvote-rss
- URL: https://www.canagentsuse.com/tools/upvote-rss
- Website: https://www.upvote-rss.com/
- Docs: https://github.com/johnwarne/upvote-rss
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Feed Readers
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted feed readers workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, PHP. Source code: https://github.com/johnwarne/upvote-rss
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Upvote RSS is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.upvote-rss.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/johnwarne/upvote-rss
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/johnwarne/upvote-rss
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/johnwarne/upvote-rss
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/johnwarne/upvote-rss

### URL-to-PNG

- Slug: url-to-png
- URL: https://www.canagentsuse.com/tools/url-to-png
- Website: https://github.com/jasonraimondi/url-to-png
- Docs: https://github.com/jasonraimondi/url-to-png
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Miscellaneous
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted miscellaneous workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/jasonraimondi/url-to-png
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

URL-to-PNG is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/jasonraimondi/url-to-png
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/jasonraimondi/url-to-png
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/jasonraimondi/url-to-png
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/jasonraimondi/url-to-png
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/jasonraimondi/url-to-png

### Usertour

- Slug: usertour
- URL: https://www.canagentsuse.com/tools/usertour
- Website: https://www.usertour.io/
- Docs: https://github.com/usertour/usertour/
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Miscellaneous
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted miscellaneous workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/usertour/usertour/
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Usertour is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.usertour.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/usertour/usertour/
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/usertour/usertour/
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/usertour/usertour/
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/usertour/usertour/

### Vane

- Slug: vane
- URL: https://www.canagentsuse.com/tools/vane
- Website: https://github.com/ItzCrazyKns/Vane
- Docs: https://github.com/ItzCrazyKns/Vane
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Generative Artificial Intelligence (GenAI)
- Use cases: Self-host a tool, Inspect open source, Triage work
- Best for: Self-hosted generative artificial intelligence (genai) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/ItzCrazyKns/Vane
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Vane is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/ItzCrazyKns/Vane
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/ItzCrazyKns/Vane
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/ItzCrazyKns/Vane
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/ItzCrazyKns/Vane
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/ItzCrazyKns/Vane

### Veloren

- Slug: veloren
- URL: https://www.canagentsuse.com/tools/veloren
- Website: https://veloren.net/
- Docs: https://gitlab.com/veloren/veloren
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Games
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted games workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Rust. Source code: https://gitlab.com/veloren/veloren
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Veloren is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://veloren.net/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://gitlab.com/veloren/veloren
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://gitlab.com/veloren/veloren
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://gitlab.com/veloren/veloren
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://gitlab.com/veloren/veloren

### Vendure

- Slug: vendure
- URL: https://www.canagentsuse.com/tools/vendure
- Website: https://www.vendure.io
- Docs: https://github.com/vendurehq/vendure
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, E-commerce
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted e-commerce workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs. Source code: https://github.com/vendurehq/vendure
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Vendure is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.vendure.io
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/vendurehq/vendure
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/vendurehq/vendure
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/vendurehq/vendure
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/vendurehq/vendure

### Vikunja

- Slug: vikunja
- URL: https://www.canagentsuse.com/tools/vikunja
- Website: https://vikunja.io/
- Docs: https://github.com/go-vikunja/vikunja
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Task Management & To-do Lists
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted task management & to-do lists workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0, GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go. Source code: https://github.com/go-vikunja/vikunja
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Vikunja is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://vikunja.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/go-vikunja/vikunja
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/go-vikunja/vikunja
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/go-vikunja/vikunja
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/go-vikunja/vikunja

### Vince

- Slug: vince
- URL: https://www.canagentsuse.com/tools/vince
- Website: https://www.vinceanalytics.com/
- Docs: https://github.com/vinceanalytics/vince
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Analytics
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Analyze product
- Best for: Self-hosted analytics workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker, K8S, deb. Source code: https://github.com/vinceanalytics/vince
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Vince is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.vinceanalytics.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/vinceanalytics/vince
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/vinceanalytics/vince
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/vinceanalytics/vince
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/vinceanalytics/vince

### Viseron

- Slug: viseron
- URL: https://www.canagentsuse.com/tools/viseron
- Website: https://viseron.netlify.app/
- Docs: https://github.com/roflcoopter/viseron
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Video Surveillance
- Use cases: Self-host a tool, Inspect open source, Analyze product
- Best for: Self-hosted video surveillance workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/roflcoopter/viseron
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Viseron is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://viseron.netlify.app/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/roflcoopter/viseron
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/roflcoopter/viseron
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/roflcoopter/viseron
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/roflcoopter/viseron

### VoucherVault

- Slug: vouchervault
- URL: https://www.canagentsuse.com/tools/vouchervault
- Website: https://github.com/l4rm4nd/VoucherVault
- Docs: https://github.com/l4rm4nd/VoucherVault
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Money, Budgeting & Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted money, budgeting & management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/l4rm4nd/VoucherVault
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

VoucherVault is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/l4rm4nd/VoucherVault
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/l4rm4nd/VoucherVault
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/l4rm4nd/VoucherVault
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/l4rm4nd/VoucherVault
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/l4rm4nd/VoucherVault

### Vvveb CMS

- Slug: vvveb-cms
- URL: https://www.canagentsuse.com/tools/vvveb-cms
- Website: https://www.vvveb.com
- Docs: https://github.com/givanz/Vvveb
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Content Management Systems (CMS)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Analyze product, Publish content
- Best for: Self-hosted content management systems (cms) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP, Docker. Source code: https://github.com/givanz/Vvveb
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Vvveb CMS is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.vvveb.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/givanz/Vvveb
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/givanz/Vvveb
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/givanz/Vvveb
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/givanz/Vvveb

### Wagtail

- Slug: wagtail
- URL: https://www.canagentsuse.com/tools/wagtail
- Website: https://wagtail.io/
- Docs: https://github.com/wagtail/wagtail
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Content Management Systems (CMS)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted content management systems (cms) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as BSD-3-Clause; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python. Source code: https://github.com/wagtail/wagtail
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Wagtail is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://wagtail.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/wagtail/wagtail
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/wagtail/wagtail
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/wagtail/wagtail
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/wagtail/wagtail

### Wallabag

- Slug: wallabag
- URL: https://www.canagentsuse.com/tools/wallabag
- Website: https://www.wallabag.org
- Docs: https://github.com/wallabag/wallabag
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Archiving and Digital Preservation (DP)
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted archiving and digital preservation (dp) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/wallabag/wallabag
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Wallabag is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.wallabag.org
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/wallabag/wallabag
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/wallabag/wallabag
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/wallabag/wallabag
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/wallabag/wallabag

### Wallos

- Slug: wallos
- URL: https://www.canagentsuse.com/tools/wallos
- Website: https://wallosapp.com
- Docs: https://github.com/ellite/wallos
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Money, Budgeting & Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted money, budgeting & management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP, Docker. Source code: https://github.com/ellite/wallos
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Wallos is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://wallosapp.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/ellite/wallos
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/ellite/wallos
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/ellite/wallos
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/ellite/wallos

### Warracker

- Slug: warracker
- URL: https://www.canagentsuse.com/tools/warracker
- Website: https://warracker.com
- Docs: https://github.com/sassanix/Warracker
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Miscellaneous
- Use cases: Self-host a tool, Inspect open source, Analyze product
- Best for: Self-hosted miscellaneous workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/sassanix/Warracker
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Warracker is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://warracker.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/sassanix/Warracker
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/sassanix/Warracker
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/sassanix/Warracker
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/sassanix/Warracker

### Wastebin

- Slug: wastebin
- URL: https://www.canagentsuse.com/tools/wastebin
- Website: https://github.com/matze/wastebin
- Docs: https://github.com/matze/wastebin
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Pastebins
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted pastebins workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Rust, Docker. Source code: https://github.com/matze/wastebin
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Wastebin is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/matze/wastebin
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/matze/wastebin
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/matze/wastebin
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/matze/wastebin
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/matze/wastebin

### Watcharr

- Slug: watcharr
- URL: https://www.canagentsuse.com/tools/watcharr
- Website: https://github.com/sbondCo/Watcharr
- Docs: https://github.com/sbondCo/Watcharr
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Media Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted media management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/sbondCo/Watcharr
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Watcharr is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/sbondCo/Watcharr
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/sbondCo/Watcharr
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/sbondCo/Watcharr
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/sbondCo/Watcharr
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/sbondCo/Watcharr

### WatchYourLAN

- Slug: watchyourlan
- URL: https://www.canagentsuse.com/tools/watchyourlan
- Website: https://github.com/aceberg/WatchYourLAN
- Docs: https://github.com/aceberg/WatchYourLAN
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Network Utilities
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted network utilities workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Go, deb. Source code: https://github.com/aceberg/WatchYourLAN
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

WatchYourLAN is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/aceberg/WatchYourLAN
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/aceberg/WatchYourLAN
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/aceberg/WatchYourLAN
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/aceberg/WatchYourLAN
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/aceberg/WatchYourLAN

### Wayback

- Slug: wayback
- URL: https://www.canagentsuse.com/tools/wayback
- Website: https://github.com/wabarc/wayback
- Docs: https://github.com/wabarc/wayback
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Archiving and Digital Preservation (DP)
- Use cases: Self-host a tool, Inspect open source, Triage work
- Best for: Self-hosted archiving and digital preservation (dp) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go. Source code: https://github.com/wabarc/wayback
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Wayback is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/wabarc/wayback
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/wabarc/wayback
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/wabarc/wayback
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/wabarc/wayback
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/wabarc/wayback

### WBO

- Slug: wbo
- URL: https://www.canagentsuse.com/tools/wbo
- Website: https://github.com/lovasoa/whitebophir
- Docs: https://github.com/lovasoa/whitebophir
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Custom Communication Systems
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - custom communication systems workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/lovasoa/whitebophir
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

WBO is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/lovasoa/whitebophir
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/lovasoa/whitebophir
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/lovasoa/whitebophir
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/lovasoa/whitebophir
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/lovasoa/whitebophir

### Websurfx

- Slug: websurfx
- URL: https://www.canagentsuse.com/tools/websurfx
- Website: https://github.com/neon-mmd/websurfx
- Docs: https://github.com/neon-mmd/websurfx
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Search Engines
- Use cases: Self-host a tool, Inspect open source, Triage work
- Best for: Self-hosted search engines workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Rust, Docker. Source code: https://github.com/neon-mmd/websurfx
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Websurfx is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/neon-mmd/websurfx
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/neon-mmd/websurfx
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/neon-mmd/websurfx
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/neon-mmd/websurfx
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/neon-mmd/websurfx

### WebThings Gateway

- Slug: webthings-gateway
- URL: https://www.canagentsuse.com/tools/webthings-gateway
- Website: https://webthings.io/gateway/
- Docs: https://github.com/WebThingsIO/gateway
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Internet of Things (IoT)
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted internet of things (iot) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs. Source code: https://github.com/WebThingsIO/gateway
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

WebThings Gateway is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://webthings.io/gateway/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/WebThingsIO/gateway
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/WebThingsIO/gateway
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/WebThingsIO/gateway
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/WebThingsIO/gateway

### WeeWX

- Slug: weewx
- URL: https://www.canagentsuse.com/tools/weewx
- Website: https://weewx.com/
- Docs: https://github.com/weewx/weewx
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Miscellaneous
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted miscellaneous workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python, deb. Source code: https://github.com/weewx/weewx
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

WeeWX is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://weewx.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/weewx/weewx
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/weewx/weewx
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/weewx/weewx
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/weewx/weewx

### Wekan

- Slug: wekan
- URL: https://www.canagentsuse.com/tools/wekan
- Website: https://wekan.github.io/
- Docs: https://github.com/wekan/wekan
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Task Management & To-do Lists
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted task management & to-do lists workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs. Source code: https://github.com/wekan/wekan
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Wekan is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://wekan.github.io/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/wekan/wekan
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/wekan/wekan
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/wekan/wekan
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/wekan/wekan

### Wiki.js

- Slug: wiki-js
- URL: https://www.canagentsuse.com/tools/wiki-js
- Website: https://js.wiki/
- Docs: https://github.com/Requarks/wiki
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Wikis
- Use cases: Self-host a tool, Inspect open source, Publish content
- Best for: Self-hosted wikis workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker, K8S. Source code: https://github.com/Requarks/wiki
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Wiki.js is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://js.wiki/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Requarks/wiki
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Requarks/wiki
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Requarks/wiki
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Requarks/wiki

### Wingfit

- Slug: wingfit
- URL: https://www.canagentsuse.com/tools/wingfit
- Website: https://wingfit.fr
- Docs: https://github.com/itskovacs/wingfit
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Health and Fitness
- Use cases: Self-host a tool, Inspect open source, Triage work
- Best for: Self-hosted health and fitness workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as CC-BY-SA-4.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python, Docker. Source code: https://github.com/itskovacs/wingfit
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Wingfit is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://wingfit.fr
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/itskovacs/wingfit
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/itskovacs/wingfit
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/itskovacs/wingfit
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/itskovacs/wingfit

### WinterCMS

- Slug: wintercms
- URL: https://www.canagentsuse.com/tools/wintercms
- Website: https://wintercms.com/
- Docs: https://github.com/wintercms/winter
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Content Management Systems (CMS)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted content management systems (cms) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/wintercms/winter
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

WinterCMS is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://wintercms.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/wintercms/winter
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/wintercms/winter
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/wintercms/winter
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/wintercms/winter

### Wishlist

- Slug: wishlist
- URL: https://www.canagentsuse.com/tools/wishlist
- Website: https://github.com/cmintey/wishlist
- Docs: https://github.com/cmintey/wishlist
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Miscellaneous
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted miscellaneous workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, K8S. Source code: https://github.com/cmintey/wishlist
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Wishlist is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/cmintey/wishlist
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/cmintey/wishlist
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/cmintey/wishlist
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/cmintey/wishlist
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/cmintey/wishlist

### WonderCMS

- Slug: wondercms
- URL: https://www.canagentsuse.com/tools/wondercms
- Website: https://www.wondercms.com
- Docs: https://github.com/WonderCMS/wondercms
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Content Management Systems (CMS)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted content management systems (cms) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/WonderCMS/wondercms
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

WonderCMS is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.wondercms.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/WonderCMS/wondercms
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/WonderCMS/wondercms
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/WonderCMS/wondercms
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/WonderCMS/wondercms

### WooCommerce

- Slug: woocommerce
- URL: https://www.canagentsuse.com/tools/woocommerce
- Website: https://woocommerce.com/
- Docs: https://github.com/woocommerce/woocommerce
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, E-commerce
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted e-commerce workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/woocommerce/woocommerce
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

WooCommerce is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://woocommerce.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/woocommerce/woocommerce
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/woocommerce/woocommerce
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/woocommerce/woocommerce
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/woocommerce/woocommerce

### WordPress

- Slug: wordpress
- URL: https://www.canagentsuse.com/tools/wordpress
- Website: https://wordpress.org/
- Docs: https://github.com/WordPress/WordPress
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Content Management Systems (CMS)
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Analyze product, Publish content
- Best for: Self-hosted content management systems (cms) workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/WordPress/WordPress
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

WordPress is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://wordpress.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/WordPress/WordPress
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/WordPress/WordPress
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/WordPress/WordPress
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/WordPress/WordPress

### WorkAdventure

- Slug: workadventure
- URL: https://www.canagentsuse.com/tools/workadventure
- Website: https://workadventu.re
- Docs: https://github.com/workadventure/workadventure
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Custom Communication Systems
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - custom communication systems workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0, Commons-Clause; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/workadventure/workadventure
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

WorkAdventure is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://workadventu.re
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/workadventure/workadventure
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/workadventure/workadventure
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/workadventure/workadventure
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/workadventure/workadventure

### Writing

- Slug: writing
- URL: https://www.canagentsuse.com/tools/writing
- Website: https://josephernest.github.io/writing/
- Docs: https://github.com/josephernest/writing
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Note-taking & Editors
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted note-taking & editors workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Javascript. Source code: https://github.com/josephernest/writing
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Writing is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://josephernest.github.io/writing/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/josephernest/writing
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/josephernest/writing
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/josephernest/writing
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/josephernest/writing

### WYGIWYH

- Slug: wygiwyh
- URL: https://www.canagentsuse.com/tools/wygiwyh
- Website: https://github.com/eitchtee/WYGIWYH
- Docs: https://github.com/eitchtee/WYGIWYH
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Money, Budgeting & Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted money, budgeting & management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Python. Source code: https://github.com/eitchtee/WYGIWYH
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

WYGIWYH is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/eitchtee/WYGIWYH
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/eitchtee/WYGIWYH
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/eitchtee/WYGIWYH
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/eitchtee/WYGIWYH
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/eitchtee/WYGIWYH

### XWiki

- Slug: xwiki
- URL: https://www.canagentsuse.com/tools/xwiki
- Website: https://www.xwiki.org
- Docs: https://github.com/xwiki/xwiki-platform
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Wikis
- Use cases: Self-host a tool, Inspect open source, Publish content
- Best for: Self-hosted wikis workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as LGPL-2.1; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Java, Docker, deb. Source code: https://github.com/xwiki/xwiki-platform
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

XWiki is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.xwiki.org
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/xwiki/xwiki-platform
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/xwiki/xwiki-platform
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/xwiki/xwiki-platform
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/xwiki/xwiki-platform

### Yamtrack

- Slug: yamtrack
- URL: https://www.canagentsuse.com/tools/yamtrack
- Website: https://github.com/FuzzyGrim/Yamtrack
- Docs: https://github.com/FuzzyGrim/Yamtrack
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Miscellaneous
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted miscellaneous workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Python. Source code: https://github.com/FuzzyGrim/Yamtrack
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Yamtrack is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/FuzzyGrim/Yamtrack
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/FuzzyGrim/Yamtrack
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/FuzzyGrim/Yamtrack
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/FuzzyGrim/Yamtrack
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/FuzzyGrim/Yamtrack

### Your Spotify

- Slug: your-spotify
- URL: https://www.canagentsuse.com/tools/your-spotify
- Website: https://github.com/Yooooomi/your_spotify
- Docs: https://github.com/Yooooomi/your_spotify
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Personal Dashboards
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted personal dashboards workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MIT; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Nodejs, Docker. Source code: https://github.com/Yooooomi/your_spotify
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Your Spotify is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/Yooooomi/your_spotify
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/Yooooomi/your_spotify
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/Yooooomi/your_spotify
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/Yooooomi/your_spotify
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/Yooooomi/your_spotify

### yt-dlp Web UI

- Slug: yt-dlp-web-ui
- URL: https://www.canagentsuse.com/tools/yt-dlp-web-ui
- Website: https://github.com/marcopiovanello/yt-dlp-web-ui
- Docs: https://github.com/marcopiovanello/yt-dlp-web-ui
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Media Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted media management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as MPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker, Go, Nodejs. Source code: https://github.com/marcopiovanello/yt-dlp-web-ui
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

yt-dlp Web UI is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://github.com/marcopiovanello/yt-dlp-web-ui
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/marcopiovanello/yt-dlp-web-ui
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/marcopiovanello/yt-dlp-web-ui
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/marcopiovanello/yt-dlp-web-ui
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/marcopiovanello/yt-dlp-web-ui

### Zammad

- Slug: zammad
- URL: https://www.canagentsuse.com/tools/zammad
- Website: https://zammad.org/
- Docs: https://github.com/zammad/zammad
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Ticketing
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted ticketing workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Ruby, deb. Source code: https://github.com/zammad/zammad
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Zammad is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://zammad.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/zammad/zammad
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/zammad/zammad
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/zammad/zammad
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/zammad/zammad

### Zenphoto

- Slug: zenphoto
- URL: https://www.canagentsuse.com/tools/zenphoto
- Website: https://www.zenphoto.org/
- Docs: https://github.com/zenphoto/zenphoto
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Photo Galleries
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools, Publish content
- Best for: Self-hosted photo galleries workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/zenphoto/zenphoto
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Zenphoto is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.zenphoto.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/zenphoto/zenphoto
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/zenphoto/zenphoto
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/zenphoto/zenphoto
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/zenphoto/zenphoto

### ZenTao

- Slug: zentao
- URL: https://www.canagentsuse.com/tools/zentao
- Website: https://www.zentao.pm/
- Docs: https://github.com/easysoft/zentaopms
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Software Development - Project Management
- Use cases: Self-host a tool, Inspect open source, Deploy internal tools
- Best for: Self-hosted software development - project management workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/easysoft/zentaopms
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

ZenTao is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.zentao.pm/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/easysoft/zentaopms
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/easysoft/zentaopms
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/easysoft/zentaopms
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/easysoft/zentaopms

### Zero-K

- Slug: zero-k
- URL: https://www.canagentsuse.com/tools/zero-k
- Website: https://zero-k.info/
- Docs: https://github.com/ZeroK-RTS/Zero-K
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Games
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted games workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Lua. Source code: https://github.com/ZeroK-RTS/Zero-K
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Zero-K is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://zero-k.info/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/ZeroK-RTS/Zero-K
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/ZeroK-RTS/Zero-K
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/ZeroK-RTS/Zero-K
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/ZeroK-RTS/Zero-K

### Ziit

- Slug: ziit
- URL: https://www.canagentsuse.com/tools/ziit
- Website: https://ziit.app
- Docs: https://github.com/0pandadev/ziit
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Time Tracking
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted time tracking workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as AGPL-3.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Docker. Source code: https://github.com/0pandadev/ziit
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Ziit is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://ziit.app
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/0pandadev/ziit
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/0pandadev/ziit
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/0pandadev/ziit
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/0pandadev/ziit

### Zim

- Slug: zim
- URL: https://www.canagentsuse.com/tools/zim
- Website: https://zim-wiki.org/
- Docs: https://github.com/zim-desktop-wiki/zim-desktop-wiki
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Wikis
- Use cases: Self-host a tool, Inspect open source, Publish content
- Best for: Self-hosted wikis workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python, deb. Source code: https://github.com/zim-desktop-wiki/zim-desktop-wiki
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Zim is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://zim-wiki.org/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/zim-desktop-wiki/zim-desktop-wiki
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/zim-desktop-wiki/zim-desktop-wiki
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/zim-desktop-wiki/zim-desktop-wiki
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/zim-desktop-wiki/zim-desktop-wiki

### ZincSearch

- Slug: zincsearch
- URL: https://www.canagentsuse.com/tools/zincsearch
- Website: https://zincsearch.com
- Docs: https://github.com/zincsearch/zincsearch
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Search Engines
- Use cases: Self-host a tool, Inspect open source, Triage work
- Best for: Self-hosted search engines workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Go, Docker, K8S. Source code: https://github.com/zincsearch/zincsearch
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

ZincSearch is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://zincsearch.com
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/zincsearch/zincsearch
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/zincsearch/zincsearch
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/zincsearch/zincsearch
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/zincsearch/zincsearch

### ZNC

- Slug: znc
- URL: https://www.canagentsuse.com/tools/znc
- Website: https://wiki.znc.in/ZNC
- Docs: https://github.com/znc/znc
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - IRC
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - irc workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: C++, deb. Source code: https://github.com/znc/znc
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

ZNC is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://wiki.znc.in/ZNC
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/znc/znc
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/znc/znc
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/znc/znc
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/znc/znc

### Zoneminder

- Slug: zoneminder
- URL: https://www.canagentsuse.com/tools/zoneminder
- Website: https://www.zoneminder.com/
- Docs: https://github.com/ZoneMinder/ZoneMinder
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Video Surveillance
- Use cases: Self-host a tool, Inspect open source, Analyze product
- Best for: Self-hosted video surveillance workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as GPL-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP, deb. Source code: https://github.com/ZoneMinder/ZoneMinder
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Zoneminder is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://www.zoneminder.com/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/ZoneMinder/ZoneMinder
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/ZoneMinder/ZoneMinder
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/ZoneMinder/ZoneMinder
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/ZoneMinder/ZoneMinder

### Zulip

- Slug: zulip
- URL: https://www.canagentsuse.com/tools/zulip
- Website: https://zulip.org
- Docs: https://github.com/zulip/zulip
- Agent score: 52
- Agent tier: Browser-assisted
- Categories: Self-hosted, Communication - Custom Communication Systems
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted communication - custom communication systems workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Store credentials outside source control and use least-privilege scopes, short-lived tokens, or restricted keys where the product supports them.
- Pricing: Self-hosted/open-source licensing listed as Apache-2.0; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: Python. Source code: https://github.com/zulip/zulip
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

Zulip is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 19.6/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://zulip.org
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/zulip/zulip
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/zulip/zulip
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/zulip/zulip
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/zulip/zulip

### X API

- Slug: x-api
- URL: https://www.canagentsuse.com/tools/x-api
- Website: https://developer.x.com
- Docs: https://docs.x.com
- Agent score: 51
- Agent tier: Usable with gaps
- Categories: Social media
- Use cases: Publish content, Triage work
- Best for: Social publishing, monitoring public conversations, and account workflow automation.
- Limitations: Key limitations: Posting, DMs, compliance, and changing API access tiers require human review. Posting, moderation, DMs, paid campaigns, platform policy, brand voice, and account reputation should stay human-reviewed for public or customer-facing actions. API automation needs client-side throttling, idempotency where supported, pagination limits, retries, and audit logging. Account setup or elevated access may require vendor, admin, or compliance approval before an agent can operate independently.
- Pricing: Public pay-per-use and enterprise API plans; access differs by endpoint.
- Auth: OAuth 1.0a, OAuth 2.0, bearer tokens, app/user permissions.
- Account creation: Developer account setup and paid access are required for many workflows.
- Browser support: Developer portal and product UI are important for app setup and review.
- CLI: Not listed
- API base: https://api.x.com/2
- MCP server: Not listed

Agents can publish and read social data, but pricing, access levels, and policy compliance make it less automatic.

Score breakdown:
- Machine operability: 14/25
- Agent safety: 9.2/25
- Agent readability: 13.5/20
- Auth and setup: 7.5/15
- Production reliability: 6.4/15

Capabilities:
- API: native. API docs cover posts, users, DMs, spaces, lists, trends, media, and more. Evidence: https://docs.x.com/x-api/overview
- Browser: strong. Developer portal and product UI are important for app setup and review. Evidence: https://developer.x.com
- Account creation: partial. Developer account setup and paid access are required for many workflows. Evidence: https://developer.x.com
- Pricing clarity: partial. Pricing is public, but commercial and enterprise access details vary. Evidence: https://docs.x.com/x-api/getting-started/pricing
- Docs quality: partial. Docs are official, but endpoint access and plan gating can be complex. Evidence: https://docs.x.com/home

### OXID eShop

- Slug: oxid-eshop
- URL: https://www.canagentsuse.com/tools/oxid-eshop
- Website: https://oxidforge.org/en/
- Docs: https://github.com/OXID-eSales/oxideshop_ce
- Agent score: 50
- Agent tier: Browser-assisted
- Categories: Self-hosted, E-commerce
- Use cases: Self-host a tool, Inspect open source
- Best for: Self-hosted e-commerce workflows, internal tools, and controlled deployment experiments.
- Limitations: Key limitations: generated from community metadata, not a full security review. Verify maintenance activity, license, deployment docs, auth model, backup and restore path, update process, API or CLI support, and data exposure before production agent automation. Browser automation can be brittle around UI changes, MFA, captchas, policy prompts, and hidden confirmation states. Account setup or elevated access may require vendor, admin, or compliance approval before an agent can operate independently.
- Pricing: Self-hosted/open-source licensing listed as ⊘ Proprietary; infrastructure costs vary by deployment.
- Auth: Auth and permissions depend on the deployed app configuration; platform metadata: PHP. Source code: https://github.com/OXID-eSales/oxideshop_ce
- Account creation: No vendor signup is required for self-hosted use, but deployment and admin setup are required.
- Browser support: Browser UI can be operated after deployment; exact flows depend on the app configuration.
- CLI: Not listed
- API base: Not listed
- MCP server: Not listed

OXID eShop is self-hostable software from the Awesome Selfhosted data index. Agents can inspect the source, deploy it in a controlled environment, and operate the browser UI; API or CLI support should be verified in project docs.

Score breakdown:
- Machine operability: 4/25
- Agent safety: 18.4/25
- Agent readability: 15/20
- Auth and setup: 10.5/15
- Production reliability: 2.4/15

Capabilities:
- Browser: strong. Self-hosted web app can be operated through a browser once deployed. Evidence: https://oxidforge.org/en/
- Account creation: partial. No vendor signup is required for self-hosted use, but deployment, admin setup, and local auth configuration are usually required. Evidence: https://github.com/OXID-eSales/oxideshop_ce
- Pricing clarity: strong. Self-hosted/open-source licensing makes software cost inspectable; infrastructure cost depends on deployment. Evidence: https://github.com/OXID-eSales/oxideshop_ce
- Docs quality: partial. Project website or source repository is listed for documentation and deployment review. Evidence: https://github.com/OXID-eSales/oxideshop_ce
- Sandbox: strong. Self-hosted deployment supports local, staging, or disposable test environments before production use. Evidence: https://github.com/OXID-eSales/oxideshop_ce