SERA-14B

What is SERA-14B?

SERA-14B is a 14-billion-parameter open-weight coding-agent model released by the Allen Institute for AI (Ai2). It belongs to Ai2’s SERA Open Coding Agents family and is designed for software-engineering work that involves understanding and modifying a repository, not merely generating a short function from a prompt.

In practical terms, SERA-14B can be used as the model behind an agent that examines source files, reasons about a requested change, edits code, and uses development tools as part of a larger workflow. Typical tasks include repository-level bug fixing, feature implementation, refactoring, code explanation, and code-review assistance.

The model is based on Qwen3-14B and was fine-tuned specifically for coding-agent behavior. Ai2 positions it as the smaller member of the SERA family, alongside the larger SERA-32B. The 14B size can make deployment more manageable for teams that cannot dedicate as much memory or compute to a coding agent, although the model still has substantial hardware requirements at its full 32K context length.

Where SERA-14B fits in Ai2’s lineup

SERA-14B is not a general-purpose assistant presented as an all-in-one chat product. Its main role is specialized software engineering. It is the 14-billion-parameter option in Ai2’s current SERA Open Coding Agents family, providing a smaller alternative to SERA-32B.

The distinction matters when choosing a deployment. A larger coding model may offer more capability on difficult tasks, but usually requires more memory and can be slower or more expensive to operate. SERA-14B is aimed at the opposite trade-off: a smaller open model that remains focused on repository-level engineering and can be adapted to private codebases.

Because the weights are openly available under the Apache 2.0 license, organizations can manage their own infrastructure, adapt the model, or build a customized coding-agent system around it. This differs from a hosted coding service where the provider controls the runtime and charges according to usage.

How SERA-14B was trained

Ai2 trained SERA-14B with supervised fine-tuning on 25,000 synthetic coding-agent trajectories. These trajectories were generated using a process called Soft Verified Generation, with GLM-4.6 serving as the teacher model.

The data-generation process is designed to produce examples that resemble actual repository work. A proposed repository change is created first, then converted into a pull-request-style description. The teacher is asked to reproduce the change from that description, and the resulting patch is compared with the original using line-level recall. This provides a verification signal without requiring a complete test-suite execution for every generated example.

The training data covers 121 Python codebases. That focus helps explain both the model’s intended strength and an important limitation: the published evaluation and training process are centered on Python repository tasks. Results should therefore not automatically be generalized to every programming language, repository style, or engineering workflow.

What SERA-14B can do

SERA-14B is intended for coding agents that need to work across multiple files and reason about changes in the context of an existing project. Suitable tasks include:

• Investigating and fixing repository-level bugs
• Implementing features across several files
• Refactoring existing code while preserving intended behavior
• Explaining unfamiliar code and repository structure
• Assisting with code review and proposed changes
• Adapting a coding agent to a private software repository
• Research into synthetic training data and software-engineering agents

The model’s 32,768-token maximum sequence length gives an agent room to include substantial code, instructions, tool output, and repository context in one interaction. That does not mean an entire large repository can always fit into the context window. An agent runtime still needs to select relevant files, summarize information, and manage context as work progresses.

SERA-14B is text-based. The supplied specifications identify text input and text output, with no image, audio, or video input or output. It is therefore appropriate for source code, natural-language instructions, terminal results, and other textual development artifacts, but not for directly interpreting screenshots or producing media.

Tool use and deployment

SERA-14B is designed to operate inside an agent runtime rather than as an isolated text generator. Tool-oriented use can provide access to repository files, shell commands, search, patch application, and other development operations. The model can be served with the documented vLLM configuration and used with SERA command-line tooling.

The surrounding runtime remains responsible for important operational behavior. It must decide which tools are available, execute commands, manage repository access, apply or reject edits, and handle the model’s responses. The model card notes that SERA-14B may attempt to call a nonexistent submit tool after editing. The SERA CLI proxy handles this behavior, but a direct deployment may need equivalent handling.

Ai2 documents vLLM serving with automatic tool choice, a 32,768-token maximum model length, tensor parallelism, and the Hermes tool-call parser. These settings are deployment details rather than a hosted API guarantee. Users operating the model directly should validate the exact serving configuration against the current model documentation.

Performance and coding quality

Ai2 reports a 41.7% ± 0.5% resolve rate on SWE-bench Verified at a 32K context length, calculated across three random seeds. SWE-bench Verified measures whether an agent can resolve real software issues in benchmark repositories, so the result is more relevant to repository-level coding than a score based only on short code-generation prompts.

The score is a provider-reported benchmark result, not a guarantee for an individual project. The evaluation emphasizes Python repositories and SWE-bench-style issues. Results may differ when the repository uses another language, has unusual build tooling, lacks clear tests, or requires domain knowledge that was not represented in the model’s training and evaluation setup.

For this page, coding capability is given an editorial assessment of 9 out of 10 because repository-level software engineering is the model’s primary purpose and the published benchmark supports that positioning. This is an editorial evaluation, not an Ai2 rating. Reasoning is assessed editorially at 6 out of 10: the model is trained for multi-step coding-agent workflows, but the supplied research does not provide a standalone reasoning benchmark or evidence that it is optimized for broad mathematical or general-purpose reasoning.

Hardware, speed, and cost trade-offs

The SERA-14B model card lists one 80GB GPU, such as an NVIDIA A100 or H100, as a minimum configuration for 32K-context inference, with an H100 recommended. Quantization formats such as AWQ or GPTQ may reduce memory requirements, although the practical effect depends on the selected quantization and serving setup.

Its 14B parameter count makes SERA-14B more approachable than a larger sibling such as SERA-32B, but it is not a lightweight model that can be assumed to run efficiently on ordinary consumer hardware at the documented context length. The smaller size can improve deployment cost and potentially response speed compared with a larger model, but the supplied research does not publish a standardized latency figure or throughput comparison.

There is no official per-token hosted price specified in the supplied research. SERA-14B is primarily a self-hosted or user-managed endpoint model, so the actual cost depends on GPU rental or ownership, quantization, serving utilization, and the number of concurrent users. Editorial cost and speed assessments for this page are approximate: cost is rated 8 out of 10 and speed 7 out of 10 relative to larger coding-agent deployments, not as provider-published measurements.

Limitations and safety considerations

SERA-14B has several limitations that should be considered before it is placed in an automated development pipeline. First, its training and public evaluation focus heavily on Python and SWE-bench-style repository tasks. Strong performance on those tasks does not establish equal performance across other languages, large monorepos, specialized frameworks, or production systems with complex operational constraints.

Second, the model may produce incorrect patches, misunderstand requirements, or make changes that appear plausible but fail under real tests. The 32K context window is useful but finite, and an agent must still retrieve and prioritize relevant repository information.

Third, the model is released without safety filtering or safety tuning. Generated code may contain bugs, insecure patterns, or harmful behavior. Human review, automated tests, dependency checks, and security validation should be required before generated changes are merged or deployed.

Finally, direct users must account for agent-specific behavior such as unsupported tool calls. Using the documented SERA tooling can reduce integration work, while a custom runtime needs to reproduce the necessary parsing, tool handling, error recovery, and repository controls.

When to choose SERA-14B

Choose SERA-14B when you want an open-weight model specifically oriented toward repository-level software engineering and are prepared to operate the infrastructure yourself. It is a strong candidate for organizations that need to keep source code within their own environment, researchers studying coding agents, and developers building customized workflows for private repositories.

Its 14B size is especially relevant when SERA-32B or another larger coding model would impose too much memory or compute cost. SERA-14B may also be preferable when Apache 2.0 licensing and access to model weights are more important than the convenience of a managed hosted API.

Another option may be more appropriate when the primary need is multimodal input, web-grounded assistance, a guaranteed hosted service with published token pricing, broad non-Python coding coverage, or minimal infrastructure management. A larger coding model may be preferable for especially difficult repository changes if the additional hardware cost is justified. Conversely, a smaller code model may be a better fit for short completion tasks where repository-level planning and tool orchestration are unnecessary.

SERA-14B specifications

SERA-14B is best understood as a specialized, openly available foundation for coding agents. Its value comes from combining repository-level training with the flexibility to run and adapt the model yourself. The main trade-off is that users must supply the infrastructure and quality controls that a managed coding service might otherwise provide.