diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 03520bf4e..3d27630db 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,10 +1,10 @@
-# Contributing to Graph Sitter
+# Contributing to Codegen
-Thank you for your interest in contributing to Graph Sitter! This document outlines the process and guidelines for contributing.
+Thank you for your interest in contributing to Codegen! This document outlines the process and guidelines for contributing.
## Contributor License Agreement
-By contributing to Graph Sitter, you agree that:
+By contributing to Codegen, you agree that:
1. Your contributions will be licensed under the project's license.
2. You have the right to license your contribution under the project's license.
diff --git a/README.md b/README.md
index 456ada1cd..39b117611 100644
--- a/README.md
+++ b/README.md
@@ -1,10 +1,11 @@
# Codegen
[](https://docs.codegen.com)
+[](https://community.codegen.com)
+[](https://twitter.com/codegen)
[Codegen](https://docs.codegen.com) is a python library for manipulating codebases.
-Write code that transforms code. Codegen combines the parsing power of [Tree-sitter](https://tree-sitter.github.io/tree-sitter/) with the graph algorithms of [rustworkx](https://github.com/Qiskit/rustworkx) to enable scriptable, multi-language code manipulation at scale.
```python
from codegen import Codebase
@@ -21,6 +22,8 @@ for function in codebase.functions:
function.move_to_file('deprecated.py')
```
+Write code that transforms code. Codegen combines the parsing power of [Tree-sitter](https://tree-sitter.github.io/tree-sitter/) with the graph algorithms of [rustworkx](https://github.com/Qiskit/rustworkx) to enable scriptable, multi-language code manipulation at scale.
+
## Installation
**This library requires Python 3.12 – 3.13.**
```
@@ -31,6 +34,7 @@ uv pip install codegen
- [Docs](https://docs.codegen.com)
- [Get Started](https://docs.codegen.com/introduction/getting-started)
+- [Contributing](CONTRIBUTING.md)
## Why Codegen?
diff --git a/docs/blog/act-via-code.mdx b/docs/blog/act-via-code.mdx
new file mode 100644
index 000000000..c9400344b
--- /dev/null
+++ b/docs/blog/act-via-code.mdx
@@ -0,0 +1,100 @@
+---
+title: "Act via Code"
+icon: "code"
+iconType: "solid"
+description: "The path to advanced code manipulation agents"
+---
+
+
+ 
+
+
+
+# Act via Code
+
+Two and a half years since the launch of the GPT-3 API, code assistants have emerged as the most powerful and practically useful applications of LLMs. The rapid adoption of AI-powered IDEs and prototype builders isn't surprising — code is structured, deterministic, and rich with patterns, making it an ideal domain for machine learning. As model capabilities continue to scale, we're seeing compounding improvements in code understanding and generation.
+
+Yet there's a striking gap between what AI agents can understand and what they can actually do. While they can reason about complex architectural changes, debug intricate issues, and propose sophisticated refactors, they often can't execute these ideas. The ceiling isn't intelligence or context—it's the ability to manipulate code at scale. Large-scale modifications remain unreliable or impossible, not because agents don't understand what to do, but because they lack the right interfaces to do it.
+
+The bottleneck isn't intelligence — it's tooling. By giving AI models the ability to write and execute code that modifies code, we're about to unlock an entire class of tasks that agents already understand but can't yet perform. Code execution environments represent the most expressive tool we could offer an agent—enabling composition, abstraction, and systematic manipulation of complex systems. When paired with ever-improving language models, this will unlock another step function improvement in AI capabilities.
+
+## Beating Minecraft with Code Execution
+
+In mid-2023, a research project called [Voyager](https://voyager.minedojo.org) made waves: it effectively solved Minecraft, performing several multiples better than the prior SOTA on many important dimensions. This was a massive breakthrough — previous reinforcement learning systems had struggled for years with even basic Minecraft tasks.
+
+While the AI community was focused on scaling intelligence, Voyager demonstrated something more fundamental: the right tools can unlock entirely new tiers of capability. The same GPT-4 model that struggled with Minecraft using traditional frameworks achieved remarkable results when allowed to write and execute code. This wasn't about raw intelligence—it was about giving the agent a more expressive way to act.
+
+
+ 
+
+
+The breakthrough came from a simple yet powerful insight: let the AI write code. Instead of limiting the agent to primitive "tools," Voyager allowed GPT-4 to write and execute [JS programs](https://github.com/MineDojo/Voyager/tree/main/skill_library/trial2/skill/code) that controlled Minecraft actions through a clean API:
+
+```javascript
+async function chopSpruceLogs(bot) {
+ const spruceLogCount = bot.inventory.count(mcData.itemsByName.spruce_log.id);
+ const logsToMine = 3 - spruceLogCount;
+ if (logsToMine > 0) {
+ bot.chat("Chopping down spruce logs...");
+ await mineBlock(bot, "spruce_log", logsToMine);
+ bot.chat("Chopped down 3 spruce logs.");
+ } else {
+ bot.chat("Already have 3 spruce logs in inventory.");
+ }
+}
+```
+
+This approach transformed the agent's capabilities. Rather than being constrained to atomic actions like `equipItem(...)`, it could create higher-level operations like [`craftShieldWithFurnace()`](https://github.com/MineDojo/Voyager/blob/main/skill_library/trial2/skill/code/craftShieldWithFurnace.js) through composing JS APIs. The system also implemented a memory mechanism, storing successful programs for reuse in similar situations—effectively building its own library of proven solutions it could later refer to and adapt to similar circumstances.
+
+
+ 
+
+
+As the Voyager authors noted:
+
+*"We opt to use code as the action space instead of low-level motor commands because programs can naturally represent temporally extended and compositional actions, which are essential for many long-horizon tasks in Minecraft."*
+
+## Code is an Ideal Action Space
+
+The implications of code as an action space extend far beyond gaming. Code provides a uniquely powerful interface between AI and real-world systems. When an agent writes code, it gains several critical advantages over traditional atomic tools.
+
+### Code is Composable
+Code is the ultimate composable medium. Agents can build their own tools by combining simpler operations, wrapping any function as a building block for more complex behaviors. This aligns well with what is perhaps LLMs' premier capability: understanding and interpolating between examples to create new solutions.
+
+### Code Constrains the Action Space
+APIs can enforce guardrails that keep agents on track. By designing interfaces that make invalid operations impossible to express, we can prevent entire classes of errors before they happen. The type system becomes a powerful tool for shaping agent behavior.
+
+### Code Provides Objective Feedback
+Code execution gives immediate, unambiguous feedback. When something goes wrong, you get stack traces and error messages—not just a confidence score. This concrete error signal is invaluable for agents learning to navigate complex systems.
+
+### Code is a Natural Medium for Collaboration
+Programs are a shared language between humans and agents. Code explicitly encodes reasoning in a reviewable format, making agent actions transparent and debuggable. There's no magic—just deterministic execution that can be understood, modified, and improved by both humans and AI.
+
+## For Software Engineering
+
+This brings us to software engineering, where we see a massive gap between AI's theoretical capabilities and practical achievements. Many code modification tasks are fundamentally programmatic—dependency analysis, refactors, control flow analysis—yet we lack the tools to express them properly.
+
+Consider how a developer thinks about refactoring: it's rarely about direct text manipulation. Instead, we think in terms of high-level operations: "move this function," "rename this variable everywhere," "split this module." These operations can be encoded into a powerful Python API:
+
+```python
+# simple access to high-level code constructs
+for component in codebase.jsx_components:
+ # access detailed code structure and relations
+ if len(component.usages) == 0:
+ # powerful edit APIs that handle edge cases
+ component.rename(component.name + 'Page')
+```
+
+This isn't just another code manipulation library—it's a scriptable language server that builds on proven foundations like LSP and codemods, but designed specifically for programmatic analysis and refactoring.
+
+## What does this look like?
+
+At Codegen, we've built exactly this system. Our approach centers on four key principles:
+
+The foundation must be Python, enabling easy composition with existing tools and workflows. Operations must be in-memory for performance, handling large-scale changes efficiently. The system must be open source, allowing developers and AI researchers to extend and enhance it. And perhaps most importantly, it must be thoroughly documented—not just for humans, but for the next generation of AI agents that will build upon it.
+
+## What does this enable?
+
+We've already used this approach to merge hundreds of thousands of lines of code in enterprise codebases. Our tools have automated complex tasks like feature flag deletion, test suite reorganization, import cycle elimination, and dead code removal. But more importantly, we've proven that code-as-action-space isn't just theoretical—it's a practical approach to scaling software engineering.
+
+This is just the beginning. With Codegen, we're providing the foundation for the next generation of code manipulation tools—built for both human developers and AI agents. We believe this approach will fundamentally change how we think about and implement large-scale code changes, making previously impossible tasks not just possible, but routine.
\ No newline at end of file
diff --git a/docs/blog/codemod-frameworks.mdx b/docs/blog/codemod-frameworks.mdx
new file mode 100644
index 000000000..e6abd2171
--- /dev/null
+++ b/docs/blog/codemod-frameworks.mdx
@@ -0,0 +1,223 @@
+---
+title: "Comparing Codemod Frameworks"
+sidebarTitle: "Codemod Frameworks"
+icon: "code-compare"
+iconType: "solid"
+---
+
+Code transformation tools have evolved significantly over the years, each offering unique approaches to programmatic code manipulation. Let's explore the strengths and limitations of major frameworks in this space.
+
+## Python's AST Module
+
+Python's built-in Abstract Syntax Tree (AST) module provides the foundation for Python code manipulation.
+
+### Strengths
+
+- Native Python implementation
+- No external dependencies
+- Full access to Python's syntax tree
+- Great for Python-specific transformations
+
+### Limitations
+
+- Python-only
+- Low-level API requiring deep AST knowledge
+- Manual handling of formatting and comments
+- No cross-file awareness
+
+```python
+import ast
+
+class NameTransformer(ast.NodeTransformer):
+ def visit_Name(self, node):
+ if node.id == 'old_name':
+ return ast.Name(id='new_name', ctx=node.ctx)
+ return node
+```
+
+## LibCST
+
+Meta's Concrete Syntax Tree library offers a more modern approach to Python code modification.
+
+### Strengths
+
+- Preserves formatting and comments
+- Type annotations support
+- Visitor pattern API
+- Excellent documentation
+- Supports codemods at scale
+
+### Limitations
+
+- Python-only
+- Steeper learning curve
+- Slower than raw AST manipulation
+- Memory-intensive for large codebases
+
+```python
+import libcst as cst
+
+class NameTransformer(cst.CSTTransformer):
+ def leave_Name(self, original_node, updated_node):
+ if original_node.value == "old_name":
+ return updated_node.with_changes(value="new_name")
+ return updated_node
+```
+
+## jscodeshift
+
+The pioneer of JavaScript codemods, jscodeshift remains a staple in the JS ecosystem.
+
+### Strengths
+
+- Robust JavaScript/TypeScript support
+- Rich ecosystem of transforms
+- Familiar jQuery-like API
+- Battle-tested at scale
+
+### Limitations
+
+- JavaScript/TypeScript only
+- Limited type information
+- Can be verbose for simple transforms
+- Documentation could be better
+
+```javascript
+export default function transformer(file, api) {
+ const j = api.jscodeshift;
+ return j(file.source)
+ .find(j.Identifier)
+ .filter((path) => path.node.name === "old_name")
+ .replaceWith((path) => j.identifier("new_name"))
+ .toSource();
+}
+```
+
+## ts-morph
+
+A TypeScript-first transformation tool with rich type system integration.
+
+### Strengths
+
+- First-class TypeScript support
+- Excellent type information access
+- High-level, intuitive API
+- Great documentation
+- Project-wide analysis capabilities
+
+### Limitations
+
+- TypeScript/JavaScript only
+- Higher memory usage
+- Can be slower for large projects
+- More complex setup than alternatives
+
+```typescript
+import { Project } from "ts-morph";
+
+const project = new Project();
+project.addSourceFileAtPath("src/**/*.ts");
+project.getSourceFiles().forEach((sourceFile) => {
+ sourceFile
+ .getDescendantsOfKind(SyntaxKind.Identifier)
+ .filter((node) => node.getText() === "old_name")
+ .forEach((node) => node.replaceWithText("new_name"));
+});
+```
+
+## ast-grep
+
+A modern, language-agnostic code searching and rewriting tool.
+
+### Strengths
+
+- Multi-language support
+- Fast pattern matching
+- Simple YAML-based rules
+- Great for quick transformations
+- Excellent performance
+
+### Limitations
+
+- Limited complex transformation support
+- Newer, less battle-tested
+- Smaller ecosystem
+- Less granular control
+
+```yaml
+rules:
+ - pattern: old_name
+ replace: new_name
+```
+
+## tree-sitter
+
+The foundation many modern tools build upon, offering lightning-fast parsing and analysis.
+
+### Strengths
+
+- Incredible performance
+- Multi-language support
+- Incremental parsing
+- Language-agnostic design
+- Growing ecosystem
+
+### Limitations
+
+- Lower-level API
+- Requires language-specific grammars
+- Manual handling of transformations
+- Steeper learning curve
+
+```javascript
+const Parser = require("tree-sitter");
+const JavaScript = require("tree-sitter-javascript");
+
+const parser = new Parser();
+parser.setLanguage(JavaScript);
+const tree = parser.parse('console.log("Hello")');
+```
+
+## Choosing the Right Tool
+
+The choice of codemod framework depends heavily on your specific needs:
+
+- **Single Language Focus**: If you're working exclusively with one language, use its specialized tools:
+
+ - Python → LibCST
+ - TypeScript → ts-morph
+ - JavaScript → jscodeshift
+
+- **Multi-Language Projects**: Consider:
+
+ - ast-grep for simple transformations
+ - tree-sitter for building custom tools
+ - A combination of specialized tools
+
+- **Scale Considerations**:
+ - Small projects → Any tool works
+ - Medium scale → Language-specific tools
+ - Large scale → Need proper tooling support (LibCST, ts-morph)
+
+## The Future of Codemods
+
+As codebases grow and AI becomes more prevalent, we're seeing a shift toward:
+
+1. **More Intelligent Tools**
+
+ - Better type awareness
+ - Improved cross-file analysis
+ - AI-assisted transformations
+
+2. **Universal Approaches**
+
+ - Language-agnostic frameworks
+ - Unified transformation APIs
+ - Better interoperability
+
+3. **Enhanced Developer Experience**
+ - Simpler APIs
+ - Better debugging tools
+ - Richer ecosystems
+
+The ideal codemod framework of the future will likely combine the best aspects of current tools: the type awareness of ts-morph, the simplicity of ast-grep, the performance of tree-sitter, and the reliability of LibCST.
diff --git a/docs/blog/posts.mdx b/docs/blog/posts.mdx
new file mode 100644
index 000000000..f681c1b06
--- /dev/null
+++ b/docs/blog/posts.mdx
@@ -0,0 +1,42 @@
+---
+title: "All Posts"
+icon: "clock"
+iconType: "solid"
+---
+
+
+## Static Analysis in the Age of AI Coding Assistants
+
+Why traditional language servers aren't enough for the future of AI-powered code manipulation
+
+
+
+
+## Codemod Frameworks
+
+Comparing popular tools for programmatic code transformation
+
+
+
+
+
+## Act via Code
+
+Programs are the natural convergence of LLMs and traditional computation.
+
+
+
+
diff --git a/docs/blog/static-analysis-ai.mdx b/docs/blog/static-analysis-ai.mdx
new file mode 100644
index 000000000..a9988e6d2
--- /dev/null
+++ b/docs/blog/static-analysis-ai.mdx
@@ -0,0 +1,67 @@
+---
+title: "Static Analysis in the Age of AI Coding Assistants"
+description: "Why traditional language servers aren't enough for the future of AI-powered code manipulation"
+icon: "magnifying-glass-chart"
+iconType: "solid"
+---
+
+As AI coding assistants like Cursor, Devin, and others become increasingly sophisticated, a common question emerges: "Why don't these tools leverage more sophisticated static analysis?" The answer reveals an important insight about the future of AI-powered code manipulation.
+
+## The Current Landscape
+
+Today's AI coding assistants typically implement static analysis in a limited way:
+
+- **Context Retrieval**: Tools like Cursor use graph-based queries to fetch relevant code context
+- **Basic Refactoring**: Most rely on VSCode's built-in language server for operations like "rename symbol"
+- **Text-Based Manipulation**: Changes are often made through direct text edits rather than semantic operations
+
+This approach works for simple, single-file changes. However, it breaks down when dealing with large-scale code transformations that require deep understanding of code relationships and dependencies.
+
+## The Challenge of Scale
+
+Why don't AI assistants just use existing language servers? The reality is that traditional language server protocols, while excellent for IDE features, have limitations when it comes to bulk code modifications:
+
+1. **Performance**: Processing large-scale changes through standard language servers is inherently slow
+2. **Scope**: Traditional tools focus on file-level operations, not codebase-wide transformations
+3. **Complexity**: Real-world refactors often require understanding complex relationships between code elements
+
+## The Rise of Codemod Frameworks
+
+Tools like `ts-morph`, `jscodeshift`, and others have emerged to fill this gap, offering more powerful code manipulation capabilities. However, they too have limitations:
+
+- Complex APIs that don't match how developers think about code changes
+- Limited cross-language support
+- Insufficient tooling for managing large-scale transformations
+- Lack of integration with modern AI workflows
+
+## The Future: Agent-Native Language Servers
+
+The next evolution in this space is what we call "agent-native language servers" - tools built specifically for AI agents to manipulate code programmatically. These tools need to:
+
+1. **Express Changes as Code**: Enable AI agents to write programs that perform code transformations, rather than generating text patches
+2. **Provide Rich Static Analysis**: Offer deep understanding of code relationships, dependencies, and impact analysis
+3. **Scale Effectively**: Handle large-scale transformations across massive codebases
+4. **Support the Full Lifecycle**: Address aspects beyond just code changes:
+ - Visualization of change impact
+ - PR management and code ownership
+ - Edge case detection and debugging
+ - Regression monitoring and notification
+
+## Beyond Simple Edits
+
+The future of AI-powered code manipulation isn't just about making text changes - it's about enabling AI agents to:
+
+1. **Build Their Own Tools**: Create and maintain their own transformation utilities
+2. **Understand Impact**: Analyze the full implications of code changes
+3. **Manage Complexity**: Handle cross-file, cross-language transformations
+4. **Ensure Reliability**: Maintain correctness across large-scale changes
+
+## The Path Forward
+
+As companies like Grit.io and Codemod.com demonstrate, there's growing recognition that the future of AI-powered code transformation requires sophisticated static analysis. But more importantly, it requires tools that are built for how AI agents actually work - through code itself.
+
+The most powerful AI coding assistants won't just generate patches or suggest edits. They'll write programs that transform code, leveraging rich static analysis to ensure changes are correct, scalable, and maintainable.
+
+This is why we're building Codegen as a programmatic interface for code manipulation - not just another language server, but a foundation for AI agents to express complex code transformations through code itself.
+
+The future of code manipulation isn't just about better language models - it's about giving those models the right tools to act effectively on code. Just as self-driving cars need sophisticated controls to navigate the physical world, AI coding agents need powerful, precise interfaces to manipulate codebases.
diff --git a/docs/building-with-codegen/commit-and-reset.mdx b/docs/building-with-codegen/commit-and-reset.mdx
index 2106554f3..b0aae8309 100644
--- a/docs/building-with-codegen/commit-and-reset.mdx
+++ b/docs/building-with-codegen/commit-and-reset.mdx
@@ -5,14 +5,21 @@ icon: "arrows-rotate"
iconType: "solid"
---
-Codegen keeps changes in memory until explicitly written to disk. Two core APIs manage this state:
+Codegen requires you to explicitly commit changes by calling [codebase.commit()](/api-reference/core/Codebase#commit).
-- [`Codebase.commit()`](/api-reference/core/Codebase#commit) - Commit changes to disk
-- [`Codebase.reset()`](/api-reference/core/Codebase#reset) - Reset the codebase and filesystem to its initial state
+
+ Keeping everything in memory enables fast, large-scale writes. See the [How it
+ Works](/introduction/how-it-works) guide to learn more.
+
+
+You can manage your codebase's state with two core APIs:
+
+- [Codebase.commit()](/api-reference/core/Codebase#commit) - Commit changes to disk
+- [Codebase.reset()](/api-reference/core/Codebase#reset) - Reset the `codebase` and filesystem to its initial state
## Committing Changes
-When you make changes to your codebase through Codegen's APIs, they aren't immediately written to disk. You need to explicitly commit them with [`Codebase.commit()`](/api-reference/core/Codebase#commit):
+When you make changes to your codebase through Codegen's APIs, they aren't immediately written to disk. You need to explicitly commit them with [codebase.commit()](/api-reference/core/Codebase#commit):
```python
from codegen import Codebase
@@ -31,7 +38,7 @@ This transaction-like behavior helps ensure your changes are atomic and consiste
## Resetting State
-The [`Codebase.reset()`](/api-reference/core/Codebase#reset) method allows you to revert the codebase to its initial state:
+The [codebase.reset()](/api-reference/core/Codebase#reset) method allows you to revert the codebase to its initial state:
```python
# Make some changes
@@ -52,6 +59,5 @@ assert codebase.get_file("src/new_file.py", optional=True) is None
`reset()` reverts both the in-memory state and any uncommitted filesystem
- changes. However, it preserves your codemod implementation in
- `.codegen/codemods/`.
+ changes. However, it preserves your codemod implementation in `.codegen/`.
diff --git a/docs/building-with-codegen/function-calls-and-callsites.mdx b/docs/building-with-codegen/function-calls-and-callsites.mdx
index 5511d7530..8066692aa 100644
--- a/docs/building-with-codegen/function-calls-and-callsites.mdx
+++ b/docs/building-with-codegen/function-calls-and-callsites.mdx
@@ -74,10 +74,17 @@ def process_data(input_data: str, debug: bool = False):
process_data("test", debug=True)
```
-You can access the arguments and parameters of the function call:
+You can access and modify the arguments and parameters of the function call with APIs detailed below.
+
+### Finding Arguments
+
+The primary APIs for finding arguments are:
+
+- [FunctionCall.args](/api-reference/core/FunctionCall#args)
+- [FunctionCall.get_arg_by_parameter_name(...)](/api-reference/core/FunctionCall#get-arg-by-parameter-name)
+- [FunctionCall.get_arg_by_index(...)](/api-reference/core/FunctionCall#get-arg-by-index)
```python
-# Manipulation code:
# Get the function call
call = file.function_calls[0]
@@ -98,6 +105,53 @@ debug_arg = call.get_arg_by_parameter_name("debug")
first_arg = call.get_arg_by_index(0)
```
+### Modifying Arguments
+
+There are two ways to modify function call arguments:
+
+1. Using [FunctionCall.set_kwarg(...)](/api-reference/core/FunctionCall#set-kwarg) to add or modify keyword arguments:
+
+```python
+# Modifying keyword arguments
+call.set_kwarg("debug", "False") # Modifies existing kwarg
+call.set_kwarg("new_param", "value", create_on_missing=True) # Adds new kwarg
+call.set_kwarg("input_data", "'new_value'", override_existing=True) # Converts positional to kwarg
+```
+
+2. Using [FuncionCall.args.append(...)](/api-reference/core/FunctionCall#args) to add new arguments:
+
+ [FunctionCall.args](/api-reference/core/FunctionCall#args) is a
+ [Collection](/building-with-codegen/collections) of
+ [Argument](/api-reference/core/Argument) objects, so it supports
+ [.append(...)](/api-reference/core/List#append),
+ [.insert(...)](/api-reference/core/List#insert) and other collection
+ methods.
+
+
+```python
+# Adding new arguments
+call.args.append('cloud="aws"') # Add a new keyword argument
+call.args.append('"value"') # Add a new positional argument
+
+# Real-world example: Adding arguments to a decorator
+@app.function(image=runner_image)
+def my_func():
+ pass
+
+# Add cloud and region if not present
+if "cloud=" not in decorator.call.source:
+ decorator.call.args.append('cloud="aws"')
+if "region=" not in decorator.call.source:
+ decorator.call.args.append('region="us-east-1"')
+```
+
+The `set_kwarg` method provides intelligent argument manipulation:
+
+- If the argument exists and is positional, it converts it to a keyword argument
+- If the argument exists and is already a keyword, it updates its value (if override_existing=True)
+- If the argument doesn't exist, it creates it (if create_on_missing=True)
+- When creating new arguments, it intelligently places them based on parameter order
+
Arguments and parameters support safe edit operations like so:
```python
diff --git a/docs/images/nether-portal.png b/docs/images/nether-portal.png
new file mode 100644
index 000000000..4b8cf6dd5
Binary files /dev/null and b/docs/images/nether-portal.png differ
diff --git a/docs/images/voyager-full.png b/docs/images/voyager-full.png
new file mode 100644
index 000000000..8d03a706b
Binary files /dev/null and b/docs/images/voyager-full.png differ
diff --git a/docs/images/voyager-performance.png b/docs/images/voyager-performance.png
new file mode 100644
index 000000000..4c4d63322
Binary files /dev/null and b/docs/images/voyager-performance.png differ
diff --git a/docs/images/voyager-retrieval.png b/docs/images/voyager-retrieval.png
new file mode 100644
index 000000000..0b6cda12f
Binary files /dev/null and b/docs/images/voyager-retrieval.png differ
diff --git a/docs/images/voyager.png b/docs/images/voyager.png
new file mode 100644
index 000000000..c3475c61f
Binary files /dev/null and b/docs/images/voyager.png differ
diff --git a/docs/introduction/about.mdx b/docs/introduction/about.mdx
index 720a4c9f1..d7ffe80a1 100644
--- a/docs/introduction/about.mdx
+++ b/docs/introduction/about.mdx
@@ -13,9 +13,10 @@ iconType: "solid"
## Our Mission
-Our mission is to build level-5 autonomous software engineering - the equivalent of self-driving cars for code.
+Our mission is to build fully-autonomous software engineering - the equivalent of self-driving cars for code.
+
+We believe the highest leverage path to autonomous development is enabling AI agents to "act via code."
-We believe the highest leverage path to autonomous development is by enabling AI agents to "act via code."
Just as self-driving cars need sophisticated sensors and controls to navigate the physical world, AI agents need powerful, precise tools to manipulate codebases. We're building that foundational layer: a programmatic interface that lets AI agents express complex code transformations through code itself.
This approach creates a shared language that both humans and AI can use to:
diff --git a/docs/mint.json b/docs/mint.json
index 668c81ed1..ae0610cf0 100644
--- a/docs/mint.json
+++ b/docs/mint.json
@@ -46,6 +46,10 @@
{
"name": "Changelog",
"url": "/changelog"
+ },
+ {
+ "name": "Blog",
+ "url": "/blog"
}
],
"navigation": [
@@ -127,6 +131,10 @@
"group": "Changelog",
"pages": ["changelog/changelog"]
},
+ {
+ "group": "Blog",
+ "pages": ["blog/posts", "blog/act-via-code", "blog/codemod-frameworks"]
+ },
{
"group": "API Reference",
"pages": [