Collaborator(s): Supriti Vijay, Aman Priyanshu, Didier Chapoteau, Arthur Goldblatt, Kimia Majd, Fraser Burch, Jianliang He, Baturay Saglam, Takahiro Matsumoto, Zhuoran Yang

Today, Cisco is introducing Antares, a family of security small language models (SLMs) purpose-built for one of the hardest, most time-consuming and expensive problems in security: pinpointing where known vulnerabilities exist within a codebase.

We are releasing two of these models—Antares-350M and Antares-1B—as open-weight models now available to the broader community on Hugging Face. Benchmark testing shows that these models outperform many powerful closed- and open-weight models in this critical security task at a fraction of the cost. And they’re compact enough to run locally, heading off the need to send sensitive codebases to the cloud.

By combining open-weight models with Antares, open specifications with Foundry Security Spec, secure coding guidance with CodeGuard, and a new benchmark, we are working to define the types of practical, trustworthy AI tools that will help cybersecurity professionals do their job better, as well as cultivating an ecosystem and standards for further enterprise adoption of AI security tools.

Figure 1. The Antares family of small language model outperforms a dozen larger models tested in the new Vulnerability Localization Benchmark. (Antares-3B is coming soon.)

Small Models for a Costly and Sensitive Security Workflow

Software security depends on connecting external vulnerability knowledge like public databases, advisories, and CWEs to internal code. That work is difficult because repositories are large, security signals are noisy, and the relevant evidence is rarely in one obvious place. Analysts often need to search through unfamiliar code, follow naming conventions, inspect call paths, compare candidate files, and decide whether a weakness is actually present.

Additionally, organizations need security tooling that is not only capable, but practical to deploy. Compact models reduce inference costs, support local or on-premises operations, and help teams keep sensitive source code within their own environment. Antares can unlock the power of AI-assisted security for universities, public sector institutions, and smaller security teams that may have lacked the resources to use token-intensive AI models for critical tasks.

Antares is purpose-built to address both problems.

“Software has always shipped with vulnerabilities, and vast bodies of legacy code still carry latent flaws. AI now pushes on the problem from both sides: agents write more of the code, and are growing capable of exploiting it. That makes cheap, continuous verification a control that has to sit close to the loop, checking code before it lands. Small models are especially compelling here: they run locally, so proprietary code never leaves the machine, and they’re fast enough to gate an agent’s output in real time. Antares-1b is a good example: it recognizes vulnerabilities in code it is shown, across several weakness classes and languages. The provided CLI packages the model’s capabilities into a practical workflow, making it easy to scan codebases, inspect findings, and integrate it into automated pipelines. What I found compelling was seeing a model this small navigate a codebase and identify security issues that would otherwise require larger models or more manual analysis.”

— Reza Shokri, Associate Professor of Computer Science at the National University of Singapore (NUS)

“Security can’t be a luxury good, yet advanced AI-based detection has largely belonged to organizations with frontier-scale budgets. Antares’s results change that equation: near-frontier accuracy on secure code reasoning at a fraction of the cost, fast enough to run on every commit. At a moment when attackers are already using AI, that kind of efficiency isn’t a nice-to-have; it’s what makes always-on security scanning possible for every team.”

— Amin Saberi, Professor of Management Science and Engineering and Director of Language, Data, and Reasoning Lab at Stanford University

What Makes Antares Different

Traditional static analysis tools are valuable, but they are often rule-heavy and can produce results that require substantial triage. General-purpose coding models can reason about code, but they may not be optimized for security investigation, terminal navigation, or structured vulnerability localization.

Antares is designed for that middle ground. Antares was inspired by pioneering research by the Cisco Foundation AI team showing that compact models can learn to search, reflect, revise their strategy, and backtrack when a path is unproductive. In other words, useful retrieval behavior can come from learned search strategies, not only from model scale. The next question was whether the same idea could help with an urgent real-world security problem: vulnerable code localization.

Antares follows an iterative search pattern that resembles how a human investigator works through a repository. Each model starts from a vulnerability description, searches for relevant code patterns, reads candidate files, incorporates new evidence, changes direction when a path is unhelpful, and narrows toward the files most likely to matter. The goal is not to replace expert judgment, but rather to help make the first stages of source-code vulnerability triage faster, more repeatable, and easier to review.

In practice, Antares can support workflows such as:

• locating files related to a CWE category in a repository snapshot
• triaging advisory-driven security investigations
• augmenting static analysis with model-driven repository exploration
• supporting CI/CD triage workflows where likely vulnerable files need early review
• enabling local security analysis in environments with strict privacy or compliance requirements

Antares outputs a ranked list of source files likely to contain a relevant vulnerability, along with the terminal exploration trace that led to that result. Security teams can use that output to prioritize analyst review during advisory triage, focused CWE investigations, or CI/CD security checks. Antares is not meant to replace the broader application security toolchain. Security teams still need dependency and software composition analysis, secret scanning, dynamic testing, infrastructure and container checks, threat modeling, remediation workflows, and expert review.

Why We Needed a New Benchmark

Building a model for vulnerable code localization raised an immediate measurement problem. We could not rely only on general coding benchmarks, because Antares does not target general issue resolution, patch generation, or broad code search. It is tailored for security-specific localization tasks: given limited security context, it identifies source files most likely to contain a vulnerability.

The closest adjacent work is CodeScout, which evaluates terminal-based code-search agents on software-engineering benchmarks such as SWE-Bench Verified, Pro, and Lite. CodeScout shows that code localization can be trained and measured with a standard Unix terminal. But these benchmarks typically measure whether an agent can find code relevant to a software issue or development task, not whether it can localize vulnerable files from CWE-style security descriptions, security advisories, or vulnerability classes.

This gap inspired the Vulnerability Localization Benchmark, a 500-task benchmark requiring models to simultaneously navigate unfamiliar codebases efficiently and recognize vulnerability patterns associated with specific CWE categories.

Why Open-Weight

We are releasing Antares as open-weight because the security community needs more accessible building blocks for practical, repository-level defense.

Figure 2. On the vulnerability localization benchmark, the Antares model family completes runs at substantially lower estimated cost and runtime than larger comparison models. 

Vulnerability triage is expensive. It requires expertise, time, infrastructure, and access to sensitive code. Those costs are felt most sharply by organizations that already operate with constrained security resources: universities, research institutions, nonprofits, and public-sector teams that still maintain important software.

A Focused Step Forward

Antares is part of a broader Cisco effort to advance how security organizations use AI responsibly, measurably, and in service of defenders. With Foundry Security Spec, Cisco shared a model-agnostic blueprint for building agentic security evaluation systems with clear roles, guardrails, and reviewable outputs. With CodeGuard, Cisco helped contribute secure-by-default rules and skills that can guide AI coding agents toward safer software development. With Antares, we are adding compact security models and a benchmark focused on repository-level vulnerability localization.

Cisco’s efforts are connected by a common belief: AI in security has to move beyond impressive one-off demos and toward systems that practitioners can evaluate, govern, and improve. Foundry Security Spec helps define the harness around agentic security work. CodeGuard helps raise the floor for prevention by capturing secure coding practices in a reusable rules corpus. Antares helps with the expensive localization step, narrowing vulnerability intelligence into source files that human reviewers can inspect.

Taken together, this work can help the community build a more durable foundation for AI-assisted defense: open specifications, reusable security knowledge, compact deployable models, and benchmarks that make progress measurable. The goal is to build toward a system where all security practitioners, regardless of on-prem or resource constraints, can effectively incorporate AI in everyday security operations.

Visit our Hugging Face page to explore the Antares models and review the model card. To learn more about the benchmark and evaluation methodology, read the technical paper, or contact Cisco Foundation AI.