wingetCollections
  • Auto
  • Search
  • Awesome Collections
  • Awesome Programs
  • My Favorite Collections
  • My Collections
  • Account / Settings
  • Terms of Service
  • Privacy
  • About

© 2026 winget.ragerworks.com

Loading...
Install ProjectTelescope using Winget - wingetCollections
  1. Go back
  2. Packages
  3. ProjectTelescope
ProjectTelescope logo

ProjectTelescope Microsoft

ai artificial-intelligence artificialintelligence linux macos observability windows
Use this command to install ProjectTelescope:
winget install --id=Microsoft.ProjectTelescope -e

ProjectTelescope is an observability tool designed to provide visibility into the activities of AI coding agents. It captures and analyzes events such as sub-agent spawns, file interactions, network requests, and token usage, enabling users to understand agent behavior without sending data off-machine.

Key Features:

  • tele CLI: Query agent activity, sessions, turns, and side effects directly from the terminal.
  • Dashboard: A desktop application for visual exploration of agent telemetry.
  • Built-in Collectors: Support for Copilot JSONL, Claude Code JSONL, and MCP proxy out-of-the-box.
  • Privacy-Focused: Local-first architecture with all data stored in user-scoped SQLite databases.
  • Collector SDK: Open-source Rust-based SDK to build custom collectors for any AI agent.

Audience & Benefit: Ideal for developers, researchers, and organizations leveraging AI coding agents. ProjectTelescope helps debug agent behavior, audit resource usage, and ensure compliance with local policies—all while maintaining control over data privacy. Its local-first design eliminates the need for cloud dependencies or API keys, providing a secure and cost-effective way to monitor AI activity.

Install on Windows using winget: winget install Microsoft.ProjectTelescope.

README

Project Telescope

Local-first observability for AI coding agents.

AI coding agents are powerful — but opaque. They spawn sub-agents, call tools, read and write files, make network requests, and burn through tokens, all behind the scenes. Project Telescope is a local-first observability layer that gives you visibility into what your agents are doing without sending a single byte off your machine.

Telescope Overview

Read the announcement blog posts: Project Telescope, Seeing Machines Think

> ⚠️ Experimental Release — Project Telescope is in active development. Features, APIs, and data formats may change.

Install

Windows

Install via winget:

winget install Microsoft.ProjectTelescope

Alternatively, download the MSI installer from the latest release.

macOS and Linux

Binaries for macOS and Linux are available in the releases, but these are not officially supported platforms at this time.

To install, download the release archive and run the install script:

# Download the archive for your platform
curl -L https://github.com/microsoft/project-telescope/releases/download/v/telescope--v.zip -o telescope.zip
unzip telescope.zip
cd telescope

# Run the install script
./install.sh

# macOS only: Remove quarantine attribute from installed binaries
xattr -d com.apple.quarantine ~/.telescope/bin/tele

Replace with the latest release version and with your platform:

  • linux-x86_64
  • linux-arm64
  • macos-x86_64
  • macos-arm64

Example: telescope-linux-arm64-v0.6.4.zip

Check releases for available archives for your architecture.

macOS note: After running the install script, you must remove the quarantine attribute that macOS applies to unsigned downloaded binaries. This is required to run the service on macOS.

Note: macOS and Linux builds are provided as-is and may have limited testing compared to the official Windows release.

Versions
0.15.1
0.6.5
0.6.4
0.1.0
Website
github.com
License
Last updated
4/30/2026
Download latest version

Stability and expectations

This project is in early experimental stage. While core functionality is stable, expect:

  • Data format changes — event schemas and database formats may evolve between releases without migration tools
  • API instability — CLI commands and collector APIs may change between releases
  • Breaking changes — no semantic versioning guarantees until 1.0 release
  • Limited platform testing — especially on macOS and Linux

Please open an issue to report bugs or provide feedback.

What you get

  • tele CLI — query agents, sessions, turns, and side-effects from the terminal
  • Dashboard — a desktop app for exploring agent activity visually
  • Built-in collectors — Copilot JSONL, Claude Code JSONL, and MCP proxy ship out of the box
  • Collector SDK — build your own collectors for any AI agent (this repo contains the SDK source)

Token Usage

Side Effect Details

Using the CLI

tele setup                         # instrument MCP configs with the proxy
tele status                        # service overview
tele agents list                   # list known agents
tele sessions list                 # list sessions
tele sessions get      # session details
tele turns list        # list turns in a session
tele collectors list               # list loaded collectors

MCP proxy

Telescope includes an MCP proxy that intercepts JSON-RPC traffic between AI agents and MCP servers. Use tele setup to automatically instrument your existing MCP server configs:

# Instrument all known MCP configs (Copilot, Claude Desktop, Cursor, VS Code)
tele setup

# Undo and restore original configs
tele setup --undo

This replaces each MCP server command in your config files with tele proxy, which transparently forwards traffic while capturing every tool call, resource read, and prompt. You can also use the proxy directly:

# Wrap any stdio-based MCP server
tele proxy stdio -- npx @modelcontextprotocol/server-filesystem /path

Add --json to any command for machine-readable output.

Privacy and data

Project Telescope is local-first by design.

  • All data is user-scoped — SQLite databases live in ~/.telescope.
  • No API keys, no cloud accounts, no third parties.

Building collectors

This repository contains the open-source Collector SDK — the API for building out-of-process collectors that feed structured telemetry into the Telescope service.

The key design principle: every collector uses the exact same SDK interface. There is no privileged native path — a collector you write has identical capabilities to a built-in one.

Collector SDK

A collector is a standalone binary that implements the Collector trait. The SDK provides two APIs:

  • Rust API — implement the Collector trait and call run(). The SDK handles IPC connection, registration, collect loops, batching, backpressure, reconnection, and graceful shutdown.
  • C-ABI — link against the cdylib and call telescope_sdk_init / telescope_sdk_submit / telescope_sdk_shutdown for non-Rust collectors (C, Python, Go, etc.).

You implement four required methods:

MethodPurpose
manifest()Return collector metadata (name, version, description)
agent()Declare which agent this collector serves (AgentConfig)
collect()Gather and return events — called every interval()
interval()How often to call collect()

Minimal example

use telescope_collector_sdk::{AgentConfig, Collector, CollectorManifest, run};
use telescope_collector_sdk::EventKind;
use std::time::Duration;

struct MyCollector;

#[async_trait::async_trait]
impl Collector for MyCollector {
    fn manifest(&self) -> CollectorManifest {
        CollectorManifest {
            name: "my-collector".into(),
            version: "0.1.0".into(),
            description: "My custom collector".into(),
        }
    }

    fn agent(&self) -> AgentConfig {
        AgentConfig {
            agent_id: "my-agent".into(),
            name: "My Agent".into(),
            agent_type: "ai-assistant".into(),
            version: None,
        }
    }

    async fn collect(&mut self) -> anyhow::Result> {
        Ok(vec![])
    }

    fn interval(&self) -> Duration {
        Duration::from_secs(15)
    }
}

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    run(MyCollector).await
}

For a complete step-by-step walkthrough, see the Collector Authoring Guide. For a working starter template, see the Hello World example.

Building the SDK from source

git clone https://github.com/microsoft/project-telescope.git
cd project-telescope
cargo build --release

Built-in collectors

These ship with Telescope and serve as reference implementations for building your own.

CollectorTypeWhat it captures
GitHub Copilot JSONLFile-basedScans Copilot events.jsonl session logs
Claude Code JSONLFile-basedImports Claude Code CLI session exports
MCP ProxyLive interceptWraps MCP servers to capture JSON-RPC traffic in real time

Source code is in src/collectors/.

The Heartbeat collector in src/collectors/heartbeat/ is an example/test collector that emits periodic events — useful as a starting point alongside the Hello World example.

Canonical event types

Collectors emit events using a shared canonical schema. The event types span these categories:

CategoryExamples
AgentAgentDiscovered, AgentHeartbeat
SessionSessionStarted, SessionEnded, SessionResumed, SessionMetadataUpdated, SessionModeChanged
TurnUserMessage, TurnStarted, TurnCompleted, TurnStreaming
ToolToolCallStarted, ToolCallCompleted
FileFileRead, FileWritten, FileCreated, FileDeleted
ShellShellCommandStarted, ShellCommandCompleted
Sub-AgentSubAgentSpawned, SubAgentCompleted
PlanningPlanCreated, PlanStepCompleted, ThinkingBlock
ContextContextWindowSnapshot, ContextPruned
Human-in-LoopApprovalRequested, ApprovalGranted, ApprovalDenied, UserFeedback
Self-ReportIntentDeclared, DecisionMade, ThoughtLogged, FrustrationReported, OutcomeReported, ObservationLogged, ConfidenceAssessed, AssumptionMade
RecipesRecipeFollowed, PathNotTaken, SkillInvoked
ModelModelUsed, ModelSwitched
ErrorErrorOccurred, RetryAttempted
CodeSearchPerformed, CodeChangeApplied
NetworkWebRequestMade, McpServerConnected
CostTokenUsageReported, RateLimitHit
GitGitCommitCreated, GitBranchCreated, PullRequestCreated
HooksHookStarted, HookCompleted
MaintenanceCompactionStarted, CompactionCompleted
Catch-allCustom { event_type, data }

Events are serialized as internally-tagged JSON: { "type": "agent_discovered", "agent_id": "...", ... }. See events.rs for the full schema.

IPC protocol

Collectors communicate with the Telescope service over local named pipes (Windows) or Unix domain sockets (macOS/Linux). The protocol is JSON-RPC style:

  1. Connect — the collector connects to the service's local IPC endpoint.
  2. Register — sends its CollectorManifest and AgentConfig.
  3. Collect loop — the SDK calls your collect() method at the configured interval, batches the returned events, and submits them over the pipe.
  4. Shutdown — on SIGTERM/Ctrl-C the SDK calls your stop() hook and disconnects cleanly.

The SDK handles all protocol details — retries with exponential backoff, batching (max 500 events per submit), backpressure compliance, heartbeats, and automatic reconnection.

Platform support

FeatureWindowsmacOSLinux
CLI (tele)✅✅✅
Service✅✅✅
Dashboard✅✅✅
Collectors✅✅✅
IPCNamed pipesUnix socketsUnix sockets

Contributing

This project is provided as-is. We are not currently accepting external contributions via pull requests. If you find a bug or have a feature request, please open an issue.

This project has adopted the Microsoft Open Source Code of Conduct.

License

The code in this repository is licensed under the MIT License.