Ampcode Release Notes

Amp has a new tool: the Librarian.

It's a subagent built for searching remote codebases. It allows Amp to search all public code on GitHub as well as your private GitHub repositories.

Tell Amp to summon the Librarian when you need to find code in multiple repositories, or, for example, when you want it to read the code of the frameworks and libraries you're using. Or when you want it to find examples of what you're trying to do in open-source code. Or when you want it to connect the dots between your code and its dependencies. Or... well, anytime you want it to find and look up code on GitHub.

Here are some example prompts that lead Amp to use the Librarian:

• "Use the Librarian to lookup how React's useEffect cleanup function is implemented."
• "Explain how new versions of our documentation are deployed when we release. Search our docs and infra repositories to see how they get to X.Y.sourcegraph.com."
• "Ask the Librarian to explain why we're getting this error from Zod and show me the validation logic causing it."

In order to use the Librarian, all you need to do is configure a GitHub connection in your Amp settings and then tell Amp to use it.

The Librarian at work

(Update 4: Amp Free is paused. We don't intend to bring it back, but you never know.)

(Update 3: Amp Free no longer has ads. See the latest update.)

(Update 2: Amp Free now supports the full Amp experience, including the smart agent powered by Opus 4.5.)

(Update 1: You can use Amp Free at work! Amp Free no longer requires you to share your data for training. We changed this one week after launch because ads alone cover our costs.)

Amp has a new mode: free. It's free of charge and supported by ads.

Like our default mode in Amp (which is now called smart), Amp Free is a unique combination of system prompt, tools, and a selection of top OSS and frontier models.

Models have changed tremendously in the last six months. Many are now great at being agents, and they’re cheaper too. All this means Amp Free is now possible—plenty of good tokens at a discount, a coding agent that knows how to use them, and the Internet’s best business model: advertisements.

In turn, we’re now going to make agentic programming accessible to everyone and start exploring what’s possible when good tokens become cheap.

Try it: sign in & install Amp, then use /mode free in the Amp CLI, or select free in the prompt field in the Amp editor extension.

Ads …

Today we've launched the Amp TypeScript SDK. It allows you to programmatically use the Amp agent in your TypeScript programs.

Here is a program, for example, that instructs the Amp agent to find and list specific files in a folder using a custom toolbox tool:

import { AmpOptions, execute } from '@ampcode/sdk'
import path from 'path'

const prompt = `
	What files use authentication in this directory?
	Go through all the files and folders.
	Use the format_file_tree tool to format results.
	Only output the file tree.
`

const options: AmpOptions = {
	cwd: path.join(process.cwd(), 'src'), // Run in `./src` folder
	dangerouslyAllowAll: true, // Allow all tools, trust in Amp
	toolbox: path.join(process.cwd(), 'toolbox'), // Location of custom toolbox
}

// execute starts the agent and streams messages
const messages = execute({ prompt, options })

for await (const message of messages) {
	// A system message contains information about the current session
	if (message.type === 'system') {
		console.log(`Started thread: ${message.session_id}`)

		// For example, the custom tools that were found in the toolbox
		console.log(
			'Available tools in Toolbox: ',
			message.tools.filter((tool) => tool.startsWith('tb__')).join(', '),
		)
	} else if (message.type === 'assistant') {
		// An assistant message contains the assistants text replies
		// or tool uses
		console.log('Assistant:', message)
	} else if (message.type === 'result') { …

The --try-gpt5 experiment is over. GPT-5 is here to stay as the new model for the oracle, replacing o3, but no longer as an experimental primary model in Amp.

We found GPT-5 to be surprisingly good in certain contexts, when planning or debugging, for example, which makes it a great model to take on the role of the oracle. But it's also less proactive, less likely to jump over that last hurdle, compared to Sonnet, and these are qualities we look for in the main agent model. Then again, its reasoning capabilities, its different training lineage, and the absence of certain idiosyncracies make it a great partner for Sonnet.

Now GPT-5 is the oracle in Amp. That means you can summon it at any point in an Amp thread to help with complex plans and bugs:

• "Look at the DB query calls and ask the oracle to provide a plan for how to refactor that reduces code duplication"
• "Use the oracle to figure out when createSupervisor threads can throw an uncaught error based on the debug log output in @log.txt"
• "I don't like that architecture. Use the oracle to analyze the callers and design a better architecture with clearer separation of concerns and pluggable storage."
• "Ask the oracle to review the code we just wrote"

(You can find more examples in the manual.)

Thanks to everybody for testing and evaluating GPT-5 and sharing their experiences with us! …

You can now connect the Amp CLI to VS Code and Neovim.

This allows Amp to access your current file, selected text, and diagnostics. It also enables Amp to edit files directly through your IDE.

All that's required is the latest version of the Amp CLI, and either the Neovim plugin or the Amp VS Code extension. Then you can run amp --ide from your project root and the CLI will connect to the IDE in the current workspace.

Here, for example, is the Amp CLI connected to Neovim:

And here is the Amp CLI connected to VS Code:

Learn more about the new integration in the manual.

Your AGENTS.md files can now include other context files dynamically, with glob mentions and filters, so you can give more granular guidance to the agent.

For example, to apply language-specific coding rules:

1. Put See @docs/*.md anywhere in your AGENTS.md file.

2. Create a file docs/typescript-conventions.md with:

   ---
   globs:
     - '**/*.ts'
   ---
   
   Follow these TypeScript conventions:
   
   - Never use the `any` type
   - ...
   

3. Repeat for other languages.

There's nothing special about @docs/*.md; you could instead mention @.agent/rules/*.md or @.cursor/rules/*.mdc or anywhere else you want these rules to live.

These @-mentioned files with globs will only be included if Amp has read a file matching any of the globs (in the example above, any TypeScript file). Use /agent-files (CLI) or hover over X% of 968k (editor extension) to see the guidance files in use.

The Amp CLI has two new flags: --stream-json and --stream-json-input.

They can be used together with the --execute flag to turn on structured JSON output and input, respectively.

Here is an example:

$ amp --execute "what is 2+2?" --stream-json

This would print something like the following on stdout:

{"type":"system","subtype":"init","cwd":"/Users/mrnugget/work/amp","session_id":"T-2775dc92-90ed-4f85-8b73-8f9766029e83","tools":["oracle","..."],"mcp_servers":[]}
{"type":"user","message":{"role":"user","content":[{"type":"text","text":"what is 2+2?"}]},"parent_tool_use_id":null,"session_id":"T-2775dc92-90ed-4f85-8b73-8f9766029e83"}
{"type":"assistant","message":{"type":"message","role":"assistant","content":[{"type":"text","text":"2 + 2 equals 4."}],"stop_reason":"end_turn","usage":{"input_tokens":12783,"cache_creation_input_tokens":367,"cache_read_input_tokens":12416,"output_tokens":8,"max_tokens":224000,"service_tier":"standard"}},"parent_tool_use_id":null,"session_id":"T-2775dc92-90ed-4f85-8b73-8f9766029e83"}
{"type":"result","subtype":"success","duration_ms":2906,"is_error":false,"num_turns":1,"result":"2 + 2 equals 4.","session_id":"T-2775dc92-90ed-4f85-8b73-8f9766029e83"}

Structured input can be provided on stdin with the --stream-json-input flag:

$ echo '{
  "type": "user",
  "message": {
    "role": "user",
    "content": [
      {
        "type": "text",
        "text": "what is 2+2?"
      }
    ]
  } …

You can now provide tools to Amp in the form of executable files.

If the environment variable AMP_TOOLBOX is set and contains the path to a directory, Amp will look in that directory for executables to be used as tools.

On start, Amp will invoke each executable it found, with the environment variable TOOLBOX_ACTION set to describe. The tool is then expected to write its description (which is what will end up in the system prompt that's sent to the agent) to stdout.

Here is an example:

#!/usr/bin/env bun
import fs from 'node:fs'
const action = process.env.TOOLBOX_ACTION

if (action === 'describe') showDescription()
else if (action === 'execute') runTests()

function showDescription() {
	process.stdout.write(
		JSON.stringify({
			name: 'run-tests',
			description: 'use this tool instead of Bash to run tests in a workspace',
			args: { dir: ['string', 'the workspace directory'] },
		}),
	)
}

When the agent then decides to invoke your tool, Amp runs the executable again, this time setting TOOLBOX_ACTION to execute. Amp passes the tool call arguments on stdin and the executable can then execute the tool call:

function runTests() {
	let dir = JSON.parse(fs.readFileSync(0, 'utf-8'))['dir']
	dir = dir && dir.length > 0 ? dir : '.'
	Bun.spawn(['pnpm', '-C', dir, 'run', 'test', '--no-color', '--run'], {
		stdio: ['inherit', 'inherit', 'inherit'],
	})
}
``` …

Amp can now use 1 million tokens of context with Claude Sonnet 4, up from 432,000 tokens two weeks ago.

You should not use the full context window for most tasks in Amp. Instead, use small threads that are scoped to a single task. Amp is better, faster, and cheaper when used this way. A notice will appear when you hit 20% of the context window to remind you of this.

Longer threads are more expensive, both because each iteration of the agentic loop sends more and more tokens, and because requests with more than 200k tokens are roughly twice as expensive per token in Anthropic's API pricing.

Amp thread with 1,000,000 tokens of context

Note: the screenshot shows 968k tokens because the context window is composed of 968k input tokens and 32k output tokens.

Amp now allows system administrators to configure organization-wide settings that override individual settings for Enterprise Amp customers. These settings can help ensure security, standardization, and best practices across an organization. Managed settings can be used, for example, to do the following:

• Set MCP servers to those that work well in your organization (amp.mcpServers)
• Allow or block MCP servers (amp.mcpPermissions)
• Allow or block Bash commands that match specified patterns (amp.permissions)
• Override any other Amp setting

To use managed settings, system administrators should ensure the settings are defined in the following files:

• macOS: /Library/Application Support/ampcode/managed-settings.json
• Linux: /etc/ampcode/managed-settings.json
• Windows: %ProgramData%\ampcode\managed-settings.json

Settings in these files use the same schema as individual settings.

You can read more about managed settings in the manual.

The setting amp.mcpPermissions defines rules that block or allow MCP servers.

MCP permissions are evaluated using a rule-based system with the same pattern matching syntax that is used for tool permissions. The first matching rule determines the action. If no rules match, the MCP server is allowed by default.

The following configuration would block all MCP servers except locally-executed servers from the @modelcontextprotocol npm organization and remote servers from trusted-service.com:

{
	"amp.mcpPermissions": [
		{
			"matches": { "command": "npx @modelcontextprotocol/server-*" },
			"action": "allow"
		},
		{
			"matches": { "url": "https://trusted-service.com/mcp/*" },
			"action": "allow"
		},
		{
			"matches": { "url": "*" },
			"action": "reject"
		}
		{
			"matches": { "command": "*" },
			"action": "reject"
		}
	]
}

Read more about amp.mcpPermissions in the manual.

Finally: the Amp CLI now also lets you execute shell commands, right there in the prompt input.

It's called shell mode. You activate it by starting a message with $. Everything you type after that will be executed as a shell command. The command and its output will be included in the context window the next time you send a message to the agent.

It's a good way to show the agent the output of a command without the agent having to execute it.

Type $$ and you'll activate the incognito version of shell mode in which the commands are executed in the same way, but not included in the context.

That, in turn, is handy when you want to run noisy commands to check on something, or fire off a quick command that you'd otherwise run in a separate terminal.

In May we added support for AGENT.md files to Amp. Not long after, OpenAI picked AGENTS.md (plural) for their agent and, instead of insisting on what we came up with, we decided that we'd prefer one standard.

Our condition: if OpenAI can get the agents.md domain, we'll switch. And that condition has now been met.

True to our word, and as of today, Amp will look for AGENTS.md files (while staying backwards compatible with existing AGENT.md files, of course)

AGENTS.md standard

Amp Tab now uses an updated custom model to provide better completions.

In order to train this model, we rebuilt our training dataset to include synthetically generated examples to improve the model's performance in specific scenarios in which the previous model produced poor or missing suggestions, such as follow-up edits.

The new model also uses DPO (Direct Preference Optimization) post-training on top of our SFT (Supervised Fine-Tuning) base. To do that, we used the model's previous bad outputs as negative examples alongside the new synthetic ground truth as positive examples, teaching it to avoid common failure patterns.

Here, see how follow-up edits work much better now. In this video, deleting a proxy variable triggers a chain of completions, including fixes to the constructor and updates to the header.