Neo by Amp

Product Introduction

1. Definition: Neo by Amp is a re-engineered Command Line Interface (CLI) specifically designed for the deployment and orchestration of long-running autonomous coding agents. It serves as a high-performance bridge between local terminal environments and remote agent control via ampcode.com, utilizing a "compaction-first" architecture to manage the memory and context requirements of advanced frontier models.

2. Core Value Proposition: Neo exists to eliminate the "handholding" traditionally required when working with AI coding agents. By prioritizing autonomous operations—such as automatic context compaction, message queuing, and remote steering—Neo allows developers to initiate complex, multi-step engineering tasks that run independently of constant user monitoring. It transitions the AI agent from a simple chatbot to a robust, background-capable engineering resource.

Main Features

1. Remote Control & Message Queuing: Neo introduces a synchronized architecture that allows users to monitor and manage terminal-based agent threads through the ampcode.com web interface. The system implements a non-blocking message queue as the default communication protocol. When a user sends a prompt while the agent is processing, the message is queued rather than interrupting the workflow. The "Steering" feature further allows users to fast-track these queued messages to be processed at the next available tool-result interval, providing precise control without forcing agent restarts.

2. Automatic Context Compaction: To solve the limitations of finite token windows in Large Language Models (LLMs), Neo implements an automated compaction engine. When a thread reaches 90% of its context window capacity, the system automatically generates a comprehensive summary of the current state, flushes the window, and initiates a fresh context starting with that summary. This architectural shift replaces the legacy "handoff" method, ensuring that agents can maintain coherence over threads containing thousands of messages without manual intervention.

3. Extensible Plugin API: The platform features a dedicated TypeScript-based Plugin API (@ampcode/plugin) that allows developers to extend the agent's capabilities. Key functionalities of the API include:

• Event Handling: Using amp.on(...) to trigger actions based on tool calls or lifecycle events.
• Tool Registration: Using amp.registerTool(...) to define custom functions the agent can execute (e.g., specific database queries or API integrations).
• UI Integration: Using ctx.ui for custom notifications, inputs, and selection menus directly within the CLI.
• AI Logic: Using amp.ai.ask(...) for internal classification and reasoning tasks within the plugin's logic.

4. High-Efficiency Performance Engine: Rebuilt for massive thread depths, Neo demonstrates significant performance gains over its predecessor. In tests involving threads with over 5,000 messages, Neo reduced mean CPU usage by 79% (from ~84% to ~17%) and idle memory consumption by 70% (from 1814 MB to 540 MB). This optimization ensures that the CLI remains responsive even during months-long development projects where history depth is substantial.

Problems Solved

1. Context Window Fatigue: Previously, developers had to manually track token usage, panic when windows filled up, or manually extract data for new threads. Neo’s auto-compaction solves "Context Window Panic" by making context management an invisible background process.

2. Tool Execution Friction: By moving from a strict, prompt-heavy permission system to a plugin-based security model, Neo solves the bottleneck of constant "Allow/Deny" interruptions. It addresses the reality of 2026-era models that write and execute complex, multi-step scripts where string-based security matching is no longer effective.

3. Target Audience:

• Software Engineers: Needing autonomous agents to handle large-scale refactors or codebase migrations.
• DevOps & Site Reliability Engineers: Utilizing agents for complex system monitoring and script execution.
• AI Tool Builders: Developers looking to create custom agentic workflows via the Amp Plugin API.
• Distributed Teams: Users who need to initiate a task in the terminal and monitor/steer it from a mobile or web browser.

4. Use Cases:

• Large-Scale Codebase Migration: Running an agent for several hours to update syntax across thousands of files, managed via the remote control interface.
• Complex Debugging: Utilizing the steering mechanism to provide hints to an agent while it explores a deep stack trace.
• Custom Tooling: Building a plugin to allow the agent to interact with internal, proprietary company APIs safely and structuredly.

Unique Advantages

1. Differentiation: Unlike traditional AI wrappers or basic terminal agents that rely on "one-shot" interactions, Neo is built for "agents with longer leashes." It abandons features that required heavy babysitting—like manual handoffs and manual bash invocations—in favor of a fully autonomous workflow that mimics a remote human collaborator.

2. Key Innovation: The primary innovation is the "Remote-Controllable Architecture." By decoupling the agent's execution from the local terminal's input/output stream, Neo allows for a "run everywhere, prompt anywhere" experience. This is combined with a shift in security philosophy, moving from basic flags to a sophisticated Plugin API where security policies are defined by the user’s specific organizational needs.

Frequently Asked Questions (FAQ)

1. What is the difference between Neo and the original Amp CLI? Neo is a complete rebuild of the Amp CLI architecture optimized for 2026 frontier models. While the original Amp focused on terminal-bound, supervised chat, Neo focuses on autonomous, remote-controllable agents that can handle massive context through automatic compaction and improved resource efficiency.

2. How does Neo handle AI context window limits? Neo uses a "compaction-first" strategy. Once a thread reaches 90% of the model's context limit, the system automatically summarizes the entire conversation and state, then restarts the context window with that summary. This eliminates the need for manual "handoffs" or starting new threads to save tokens.

3. Does Neo still require manual permission for every tool call? By default, Neo no longer asks for permission for every tool call, reflecting the complexity of modern agent-generated scripts. However, the old permissions system is available as a built-in plugin. Users requiring strict security can use the Plugin API to define custom, granular security policies that match their specific workflow and safety requirements.