OpenAI builds and deploys advanced AI models like GPT-4o for autonomous agents and workflows.
Earshot
0Popularity
About Earshot
Earshot is a terminal-based coding agent designed to listen to user requests and respond with actions rather than assumptions. It begins by understanding the user’s intent before making changes, asking clarifying questions when an ambiguous request could lead to different interpretations. The tool maintains explicit boundaries by declaring the intended files and behavior upfront, ensuring only approved changes are made. Each action is presented as a complete diff for review, requiring explicit permission before execution. Earshot integrates with existing workflows, retaining context across sessions and allowing users to steer the process mid-execution without restarting. It supports multiple model providers, including cloud APIs and local runtimes, and preserves session history for continuity. The agent operates within declared scopes, with deny rules taking precedence over allow rules, and provides verification outputs such as test results to confirm changes.
Key features
- Listens to user requests and asks clarifying questions for ambiguous inputs
- Declares intended scope (files and behavior) before making changes
- Presents complete diffs for review and requires explicit permission
- Supports multiple model providers (cloud APIs, local runtimes, OpenAI-compatible endpoints)
- Retains session history and context for continuity
- Allows steering mid-execution without restarting the process
- Includes verification outputs such as test results
- Integrates with MCP servers, skills, hooks, and subagents
Use cases
- Clarifying ambiguous coding requests to prevent misinterpretation
- Reviewing and approving changes via complete diffs before execution
- Maintaining continuity across sessions with preserved context
Pros
- Asks clarifying questions before making changes to avoid misinterpretation
- Preserves session history and context for continuity across interactions
- Requires explicit permission for each change via complete diff review
- Supports multiple model providers including cloud APIs and local runtimes
- Maintains explicit boundaries through declared scopes and deny rules
Cons
- No free tier or open-source availability mentioned
- Limited to terminal-based interaction; no graphical interface
- Requires Node.js 22+ and specific operating systems (macOS, Linux, Windows)
- Live model availability verification is still in progress
Frequently asked questions about Earshot
What is Earshot and how does it work?
Earshot is a terminal-based coding agent that listens to user requests, clarifies ambiguous instructions, and executes changes only after explicit approval. It begins by understanding intent, declares the intended scope of changes, and presents complete diffs for review before any action is taken.
Who is Earshot designed for?
Earshot is designed for developers and teams who want an AI coding assistant that respects boundaries, asks clarifying questions, and ensures changes align with user intent. It suits workflows where precision and control over automated changes are critical.
Does Earshot integrate with existing workflows?
Yes, Earshot integrates with existing workflows by retaining context across sessions, allowing users to steer the process mid-execution without restarting. It supports multiple interfaces, including terminal, ACP, and headless modes.
Can I use Earshot with different AI models?
Yes, Earshot supports multiple model providers, including cloud APIs like Anthropic and OpenRouter, local runtimes like Ollama, and custom OpenAI-compatible endpoints. Users can switch providers without losing context or permission rules.
How does Earshot handle ambiguous requests?
Earshot asks clarifying questions at the point where an assumption could lead to unintended changes. For example, if a user requests to 'fix the session picker,' Earshot may ask whether the issue is ordering or incorrect session selection before proceeding.
What are the key principles behind Earshot's design?
Earshot operates on principles of explicit boundaries, deny rules taking precedence, and user authority over execution. It ensures trust by requiring explicit permission for every change, showing complete diffs, and maintaining clear verification outputs like test results.
