Ai2 introduces SERA, an open AI agent

Ai2 has introduced SERA, a family of open-source agents that can learn the rules and quirks of any repository, including a company's private code. Its core proposition: training a specialized agent no longer requires million-dollar budgets or a large research infrastructure.

SERA can generate code, review changes, find bugs, explain functions, and maintain projects. It is available in versions ranging from 8 billion to 32 billion parameters, based on Qwen3, along with the models, data, code, and recipes needed to reproduce the training.

An agent that learns your code

Commercial models do not natively know your organization's internal APIs, conventions, or architecture. You can give them context with every query, but that is not the same as training them to work with your repository.

Ai2 proposes fine-tuning SERA with data generated from the code itself. The process can produce examples of bugs, fixes, and workflows so the agent learns how problems are solved in a specific project.

This could help an agent understand, for example, that your company uses an internal library, that certain changes require an additional review, or that an older part of the system can only be modified according to specific conventions.

The adaptation was tested with Django, SymPy, and Sphinx, three of the largest repositories in SWE-Bench. With 8,000 synthetic trajectories per repository, the specialized models matched or outperformed general models with more than 100 billion parameters used as teachers.

In Django, the specialized model scored 52.23%, compared with 51.20% for the teacher model. In SymPy, it reached 51.11%, compared with 48.89% for the teacher. These results do not guarantee the same performance on every private codebase, but they point to a clear advantage in training the agent for a specific project.

More performance at a lower cost

The SERA-32B model solved 54.2% of SWE-Bench Verified problems with a context window of 64,000 tokens. The benchmark measures whether an agent can solve real tasks in software repositories, such as fixing bugs or implementing changes.

In a comparison with aligned conditions and 32,000 tokens of context, SERA-32B scored 49.5%, compared with 50.0% for Devstral Small 2 and 50.5% for GLM-4.5-Air. In other words, it comes close to leading open models without relying on complex reinforcement-based training.

The training is also designed to be accessible:

• Reproducing the previous best open model's result costs approximately 400 dollars in computing.
• Reaching performance comparable to some open industrial models costs around 12,000 dollars.
• SERA-32B required about 40 GPU days using a cluster with two NVIDIA Hopper GPUs or RTX PRO 6000 Blackwell Server Edition GPUs.

Ai2 reduces costs with a technique called flexible verification generation. Instead of exhaustively checking that every synthetic patch is fully correct, the system also uses partially correct patches when they reflect a useful process for solving the problem.

The method combines this approach with a catalog of 51 common error types. This lets it create many different scenarios from a repository's functions without having to wait for real bugs to appear in every part of the code.

What changes for developers

The entire package is open: models, generated data, integration with Claude Code, and training recipes. Ai2 says deployment can start with a few lines of code, even without prior experience training language models.

It also worked with NVIDIA to accelerate execution. In internal tests, SERA reached approximately 1,950 output tokens per second with four H100 GPUs at BF16 precision, and about 3,700 with FP8. On Blackwell systems with four B200 GPUs, it reached about 8,600 tokens per second using NVFP4. These are peak performance figures, not a guarantee for every device or configuration.

For an independent developer or a small company, the practical difference is being able to adapt an agent to its own codebase without sending all its internal knowledge to a closed provider or building a specialized training system. The result could be a more useful assistant for reviewing changes, debugging older modules, or following a team's rules.

SERA does not eliminate the need to review generated code. Its results depend on the quality of the data, the repository, and the available tests. But it significantly reduces the cost of experimenting with specialized agents and makes that possibility available beyond the best-funded labs.

The next point to watch will be whether this recipe maintains its results on large private repositories with incomplete documentation and few automated tests. If it does, the most significant development will not simply be another coding model, but the ability to build agents tailored to each project with resources available to small teams.