Everywhere

Everywhere is a context-aware AI desktop assistant that instantly perceives and understands anything on your screen. Without needing to copy text, take screenshots, or switch applications, you invoke it with a global shortcut and get immediate AI assistance right where you are. It extracts structured environment data via accessibility APIs and UI automation, sending rich visual context to the AI model alongside your request.

Built on .NET 10 and Avalonia for native cross-platform performance, Everywhere supports a comprehensive roster of LLM providers — OpenAI, Anthropic (Claude), Google (Gemini), DeepSeek, Moonshot (Kimi), MiniMax, Ollama, and custom API endpoints. A powerful agent system integrates web browsing, file system access, terminal script execution, MCP tools, and multi-agent dispatch, enabling the assistant to take real actions on your behalf.

The Strategy Engine is Everywhere’s most distinctive innovation: it reads your current context (which app you’re in, what’s selected, what process is active) and surfaces pre-configured action shortcuts tailored to that exact situation. A developer looking at browser-rendered code gets different contextual actions than a writer staring at an email draft. This scenario-aware approach eliminates the need to describe your context and keeps you in flow state.

Everywhere targets Windows and macOS with Linux support in development. It ships with a modern frosted-glass overlay UI, rich Markdown and math rendering, full internationalization in 10 languages, and granular per-tool permission controls.

What You Get

• Context-Aware Screen Understanding - Captures structured UI element trees and visible text via accessibility APIs and OCR, so the AI knows what’s on your screen without copy-pasting.
• Multi-LLM Provider Support - Unified access to OpenAI, Anthropic (Claude), Google (Gemini), DeepSeek, Moonshot (Kimi), MiniMax, Ollama, and any custom OpenAI-compatible endpoint with per-assistant model configuration.
• Strategy Engine with Contextual Actions - Detects your active application and selected content to surface pre-configured AI action shortcuts tailored to your exact situation — browser, code editor, file, or text selection.
• Powerful Built-In Agent Tools - Browser automation, local file system access (read, search, write), terminal script execution with ConPTY, and sub-agent dispatch for complex multi-step tasks.
• MCP Tool Integration - Connect to any Model Context Protocol server for extending the assistant with external data sources, custom APIs, and third-party integrations.
• Frosted Glass Overlay UI - A modern translucent interface powered by Avalonia that sits above your current app, with Markdown, math formula, Mermaid diagram, and code block rendering.
• Global Keyboard Shortcuts - Invoke the assistant instantly from any application with customizable hotkeys, with text-selection interaction and zero context switching.
• Permission-Gated Tool Execution - Granular per-tool permission system with auto-approval management; terminal-based tools always require explicit user confirmation for security.

Common Use Cases

• Debugging System Errors - A developer sees a cryptic stack trace in their terminal; they invoke Everywhere next to the error, and it captures the context and suggests precise fixes or commands.
• Reading Long Technical Articles - A researcher browsing a lengthy paper invokes Everywhere over the browser to get a concise summary of key arguments without leaving the tab.
• Real-Time Foreign Language Translation - A designer encounters Japanese UI labels in a third-party app; Everywhere translates them in-place without opening a separate tool.
• Professional Email Rewriting - A manager drafts a casual message and uses Everywhere to transform it into polished business communication, with context drawn directly from the email client.
• Fact-Checking On-Screen Claims - A reader encounters a dubious statistic; they invoke Everywhere and ask “Is this true?” — the web-enabled assistant searches and verifies without switching apps.
• Context-Aware Code Editing - A developer in VS Code highlights a function and invokes Everywhere’s code-editor strategy to get an explanation, refactoring suggestion, or bug analysis grounded in the visible code.

Under The Hood

Architecture

Everywhere is structured as a modular multi-project .NET solution where a shared abstractions layer cleanly separates platform-agnostic contracts from platform-specific implementations. The core application (Windows and macOS) is built on Avalonia, using the MVVM pattern with CommunityToolkit.Mvvm for observable state, DynamicData for reactive collections, and a dependency-injection container that wires platform services at startup. A Strategy Engine layer sits between the context-capture subsystem and the chat pipeline: it collects a snapshot of the active visual environment, evaluates declarative conditions against registered strategy providers, and surfaces prioritized contextual action shortcuts to the user. Chat interactions flow through a Kernel abstraction backed by Microsoft Semantic Kernel, which handles tool-call orchestration, streaming responses, and provider-specific execution settings. A watchdog companion process is built and published as a pre-build target, ensuring the native sidecar is always present before the main application launches.

Tech Stack

The project runs on .NET 10 with C# throughout, enforced by editorconfig and Roslyn-based analysis. The UI layer uses Avalonia 11 with ElementComposition for hardware-accelerated, code-defined animations and frosted-glass compositing. AI provider integrations are implemented via Microsoft Semantic Kernel and Microsoft.Extensions.AI, with dedicated kernel mixins for OpenAI (including the Responses API), Anthropic, Google, and Ollama. Chat history and configuration are persisted with Entity Framework Core on SQLite. The terminal integration uses ConPTY on Windows and native PTY on macOS/Linux via a custom Terminal project with PowerShell, Bash, and Zsh shell integration scripts. MCP connectivity is handled through a managed MCP client. Telemetry ships via OpenTelemetry and Sentry. The build system uses centrally managed NuGet packages with version-pinned dependencies.

Code Quality

The test suite uses NUnit with NSubstitute for mocking and Avalonia Headless for UI-level component tests, covering AI model definitions, prompt template rendering, file system plugin operations, function call content building, and text-diffing utilities. Nullable reference types are enabled project-wide, contributing to type-safe code throughout. XML documentation comments annotate the most critical public and internal APIs — particularly in the VisualContextBuilder, StrategyEngine, and KernelMixin layers. Error handling distinguishes between user-recoverable exceptions (mapped to typed HandledChatException) and unexpected failures, allowing the UI to present actionable messages rather than raw stack traces. CI is not visible in the shallow clone, but the presence of editorconfig, DotSettings files, and NUnit.Analyzers suggests linting is enforced.

What Makes It Unique

The defining innovation is the combination of deep accessibility-API integration with a declarative Strategy Engine. Most AI desktop tools require users to manually describe their context; Everywhere reads the active process, visible UI tree, and selected elements automatically and matches them against context-aware strategies — pushing relevant shortcut actions to the surface without user input. The get_visual_tree tool exposes this full accessibility tree to the LLM itself, letting the model autonomously reason about on-screen UI structure during agentic tasks. The VisualContextBuilder serialises the live UI element hierarchy into a token-budget-aware XML representation, traversing parent and child nodes with direction constraints to stay within model limits. On Windows, custom shims and ConPTY integration enable a full interactive terminal experience inside the chat window, while the multi-agent dispatch capability in EssentialPlugin allows the assistant to recursively spin up sub-agents for complex, multi-step operations.

Self-Hosting

Everywhere is released under the Business Source License 1.1 (BSL-1.1) with Sylinko Inc. as the licensor. Under BSL-1.1, you can freely use, copy, and modify the source code for any non-competing purpose — including personal use, internal business use, education, and research. The key restriction is that you may not use it as a competing commercial product or resell it as a service. Importantly, the license includes an automatic conversion clause: four years after each version’s public release, that version’s code reverts to the Apache License 2.0, at which point it becomes fully open-source with no commercial restrictions.

Running Everywhere yourself means installing a .NET 10 desktop application on Windows 10 (build 19041+) or macOS Monterey 12.0+. There is no server component to operate — the application runs entirely on the end-user’s machine, calling LLM provider APIs directly from the client. You are responsible for supplying and managing your own API keys for whichever providers you use, and for any costs associated with those API calls. Local model deployment via Ollama is fully supported for fully offline or cost-controlled operation. Updates must be applied manually by downloading new releases from GitHub.

Everywhere Cloud Service is an officially hosted option that provides API access through Sylinko’s own model routing layer, removing the need to manage individual provider API keys. Self-hosters give up this convenience, as well as any SLAs, managed updates, or cloud-synced settings that the commercial offering may provide. The project has an active Discord community and Chinese QQ group for community support, but no enterprise support tier or SLA is currently documented. For organizations evaluating this tool, the key trade-off is full privacy and cost control (self-hosted) versus managed convenience (cloud service).