We're releasing agent-code today under the MIT license.
It's an AI-powered coding agent that lives in your terminal. You give it a task, such as "add input validation to the signup endpoint" or "run the test suite and fix any failures," and it reads your codebase, runs commands, edits files, and handles multi-step engineering work autonomously.
That last part is why this release matters. A tool that executes shell commands and edits your files should be code you can read, not a set of vendor claims you have to trust. We believe agentic coding tools are too important to be captured by any single vendor, and open, inspectable, customizable options only exist if someone ships them. So we're shipping ours.
The ceiling on closed tools
Avala runs lean: a small engineering team augmented heavily by AI tools, our operating model since 2024. Agentic coding tools have reshaped how we ship software. We've used Codex and Claude Code extensively, and they're excellent. But as we pushed them harder, we kept hitting the same ceiling: we wanted to customize behaviors for our workflows, integrate deeply with our internal systems, and understand exactly what was happening under the hood when things went wrong.
So we built our own. Not to replace Codex or Claude Code; we still use them. We wanted a version we could modify freely: custom skills for our annotation pipeline, hooks into our deployment systems, integrations with internal APIs, a permission model tuned to our security requirements. We run agent-code alongside Claude Opus, Codex, Ollama, and other providers depending on the task; different models have different strengths, and one tool that works with all of them has been valuable. It's become central to how we ship code.
Why now: open tools should be inspectable
We've been sitting on a useful tool, keeping it internal, while benefiting enormously from open source. Avala runs on Django, Flutter, Terraform, Rust, Tokio, and ripgrep: layers upon layers of other people's contributions. Codex and Claude Code showed us what agentic coding tools could be. Ollama made local LLMs accessible. Keeping our own implementation private felt increasingly hard to justify.
The practical case is just as strong as the philosophical one. Agentic coding tools sit close to the most sensitive parts of a software organization: source code, deployment scripts, environment configuration, and internal workflows. Teams should have options they can inspect, modify, and run on their own terms. Releasing agent-code is our contribution to that stack.
So here it is: a Rust-based coding agent, MIT licensed, built for teams who want deep customization and multi-provider support.
What makes it different
Fast. This sounds minor until you've used a slow tool for a week. agent-code is a single static binary with no runtime dependencies. It starts in milliseconds, and responses stream as they arrive. When you're in flow, you don't wait.
Private. Your code never leaves your machine except for the LLM API call itself. No telemetry, no analytics, no phone-home behavior. You don't have to take our word for it: the code is right there.
Extensible. Connect external tools via MCP servers, write custom skills as markdown files, build plugins as TOML packages. The architecture is designed to be extended, not just configured.
Safe. Every tool call goes through a permission system. You can lock the agent to read-only mode for safe exploration, and configure rules per tool and per pattern. The defaults are conservative.
Provider-agnostic. Works with Anthropic, OpenAI, Ollama, xAI (Grok), Google Gemini, DeepSeek, Groq, Mistral, Together, AWS Bedrock, Google Vertex, and more. Swap models with a flag or a slash command. Run completely local if your security requirements demand it.
The extensibility model is the point
agent-code ships with 32 built-in tools and 32 slash commands. The core loop is straightforward: receive user input, call the LLM with conversation history and tool definitions, stream the response, execute any tool calls, feed results back, repeat until done. Compaction keeps the context window manageable during long sessions. The tools cover what you'd expect: reading and writing files, shell commands, regex search powered by ripgrep, git operations, web fetching, LSP diagnostics, and Jupyter notebook editing.
None of that is the interesting part. The extensibility model is.
Skills are reusable workflows defined as markdown files with YAML frontmatter. Drop them in .agent/skills/ or ~/.config/agent-code/skills/ and the agent picks them up automatically.
---
description: Run tests and fix failures
userInvocable: true
---
Run the test suite. If any tests fail, read the failing test and the
source code it tests, then fix the issue. Run the tests again to verify.
MCP servers connect any Model Context Protocol server to add tools. We use this internally to integrate with our own systems: annotation queues, deployment pipelines, customer databases. The protocol is becoming a standard; supporting it was obvious.
Hooks run shell commands or HTTP requests at lifecycle points. Auto-format every file the agent writes? That's a three-line config.
Memory persists context across sessions. Project memory lives in AGENTS.md (or .agent/AGENTS.md) and loads automatically; user memory lives in ~/.config/agent-code/memory/MEMORY.md. This is how the agent learns your codebase conventions and your preferences.
Why Rust
If all we needed was a working agent, we could have forked something existing or written a quick Python wrapper. We chose Rust because the properties that matter in a CLI tool are the properties Rust is best at. It produces fast, small binaries with no runtime dependencies: users shouldn't have to install a language runtime, wait for startup, or wonder what's running in the background. And when a tool executes shell commands and edits files, you want every safety guarantee you can get; the type system catches at compile time what would be runtime errors elsewhere.
We also wanted something we could maintain for years. Rust's ecosystem is mature, the language is stable, and the code is readable enough that new team members can contribute quickly. We're not the only ones working on this codebase, so it has to be understandable.
A coding agent is Physical AI infrastructure
Avala is Fleet Learning Infrastructure for Physical AI: the loop that turns a fleet's own sensor data into its next model, for autonomous vehicle and robotics companies. A coding agent might seem tangential to that mission. It's central to it.
agent-code is the harness powering several agentic workflows across the company. On the engineering side: automated test generation, agentic ticket resolution, autonomous software development for our platform. The more interesting applications are on the Physical AI side. We've been experimenting heavily with agentic autolabeling, using LLM-powered agents to accelerate annotation workflows, generate labeling suggestions, and handle quality assurance at scale. Processing 4D sensor data for robotics companies requires tooling that understands your specific ontologies, validation rules, and quality thresholds, and a harness we can customize for those domain-specific tasks has been invaluable.
We've also been using autoresearch from Andrej Karpathy to accelerate model fine-tuning work. Agentic coding tools for infrastructure plus agentic research tools for model iteration have meaningfully compressed our development cycles. All of it runs on one principle: agentic tooling lets a small team operate at the velocity of a much larger one. agent-code is infrastructure we built to make ourselves more effective. Now it's anyone's.
Try it
# One-line install (Linux/macOS)
curl -fsSL https://raw.githubusercontent.com/avala-ai/agent-code/main/install.sh | bash
# Or via cargo
cargo install agent-code
# Or via Homebrew
brew install avala-ai/tap/agent-code
Set your API key, run agent, and start asking. The documentation covers configuration, permissions, MCP integration, and custom skills. The repo has everything you need to contribute.
The way developers write software is fundamentally changing. The tools driving that change should be ones you can read, modify, and run on your own terms. This one is. If you build something interesting with it, tell us.
agent-code is MIT licensed. Contributions welcome. Stars appreciated.
