Collaborators: Supriti Vijay, Aman Priyanshu, Didier Chapoteau, Arthur Goldblatt, Kimia Majd, Fraser Burch, Jianliang He, Baturay Saglam, Takahiro Matsumoto, Zhuoran Yang
Today Cisco introduces Antares, a family of security small language models (SLMs) designed specifically to address one of the most difficult, time-consuming, and expensive security problems: locating known vulnerabilities within a code base.
We are releasing two of these models – Antares-350M and Antares-1B – as open models, now available to the broader community on Hugging Face. Benchmark testing shows that these models outperform many high-performance closed and open models in this critical security task at a fraction of the cost. And they’re compact enough to run locally, eliminating the need to send sensitive code bases to the cloud.
Combining open models with Antares, open specifications with Foundry Security Spec, secure coding guides with CodeGuard, and a new benchmark, we are working to define the types of practical, trustworthy AI tools that help cybersecurity professionals do their jobs better, and nurturing an ecosystem and standards for further adoption of AI security tools across enterprises.
Figure 1. The Antares family of small language models outperforms a dozen larger models tested in the new Vulnerability Localization Benchmark. (Antares-3B is coming soon.)
Table of Contents
Small models for a costly and sensitive security workflow
Software security depends on linking external vulnerability knowledge, such as public databases, notices and CWEs, to internal code. This work is difficult because repositories are large, security signals are noisy, and relevant evidence is rarely in an obvious location. Analysts often have to sift through unknown code, follow naming conventions, review call paths, compare candidate files, and decide whether a vulnerability actually exists.
In addition, companies need security tools that are not only powerful but also practical to use. Compact models reduce inference costs, support local or local operations, and help teams keep sensitive source code within their own environment. Antares can unlock the power of AI-powered 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 was specifically designed to address both issues.
“Software has always been riddled with security vulnerabilities, and large amounts of legacy code still have latent bugs. AI is now attacking the problem from both sides: Agents are writing more code and becoming increasingly capable of exploiting it. That makes low-cost, continuous verification a control that must sit close to the loop and check code before it lands. Small models are particularly compelling here: they run locally, so proprietary code never leaves the machine, and they are fast enough to get an agent’s output in Real-time control Antares-1b is a good example: it detects vulnerabilities in the displayed code across multiple vulnerability classes and languages. The provided CLI bundles the model’s functions into a convenient workflow, making it easy to scan codebases, review results, and integrate them into automated pipelines.
— Reza Shokri, Associate Professor of Computer Science at the National University of Singapore (NUS)“Security can’t be a luxury item, but advanced AI-based detection largely belongs to organizations with borderline budgets. Antares’ results change that equation: near-borderline accuracy in reasoning about secure code at a fraction of the cost, fast enough to run on every commit. In an age where attackers are already using AI, this kind of efficiency isn’t a nice-to-have; it allows any team to constantly run security scans.”
— Amin Saberi, professor of management science and engineering and director of the Language, Data, and Reasoning Lab at Stanford University
What makes Antares different
Traditional static analysis tools are valuable but often rule-heavy and can produce results that require extensive triage. General-purpose coding models can reason about code, but may not be optimized for security investigations, terminal navigation, or structured vulnerability location.
Antares is designed for this middle ground. Antares was inspired by groundbreaking research from the Cisco Foundation AI team showing that compact models can learn to search, reflect, restrategize, and backtrack when a path is unproductive. In other words, useful search behavior can arise from learned search strategies, not just from model scale. The next question was whether the same idea could help with an urgent security problem in the real world: Locating vulnerable codes.
Antares follows an iterative search pattern similar to how a human researcher works through a repository. Each model starts with a vulnerability description, looks for relevant code patterns, reads candidate files, integrates new evidence, changes direction if a path is unhelpful, and narrows down to the files most likely to be significant. The goal is not to replace expert judgment, but rather to help make the initial phases of source code vulnerability triage faster, more repeatable, and easier to review.
In practice, Antares can support workflows such as:
- Find files related to a CWE category in a repository snapshot
- Triaging consultation-based security investigations
- Extending static analysis with model-driven repository exploration
- Support CI/CD triage workflows that require early review of files that are likely to be at risk
- Enables local security analysis in environments with strict privacy or compliance requirements
Antares outputs a ranked list of source files that are likely to contain a relevant vulnerability, along with the terminal exploration trail that led to that finding. Security teams can use these findings to prioritize analyst review during advisory triage, targeted CWE investigations, or CI/CD security reviews. Antares is not intended to replace the broader application security toolchain. Security teams still need dependency and software composition analysis, classified scanning, dynamic testing, infrastructure and container audits, threat modeling, remediation workflows, and expert assessments.
Why we needed a new benchmark
Building a model for locating vulnerable code created an immediate measurement problem. We couldn’t rely solely on general coding benchmarks because Antares doesn’t target general problem solving, patch generation, or comprehensive code searching. It is tailored to security-specific localization tasks: in a limited security context, it identifies source files that are most likely to contain a vulnerability.
The closest related work is CodeScout, which evaluates terminal-based code search agents against software engineering benchmarks such as SWE-Bench Verified, Pro and Lite. CodeScout shows that code localization can be trained and measured using a standard Unix terminal. However, these benchmarks typically measure whether an agent can find code relevant to a software problem or development task, rather than whether it can locate vulnerable files using security descriptors, security advisories, or CWE-style vulnerability classes.
This gap inspired the Vulnerability Localization Benchmark, a 500-task benchmark that requires models to simultaneously efficiently navigate unknown codebases and detect 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
Vulnerability triage is expensive. It requires expertise, time, infrastructure and access to sensitive code. These costs are felt most acutely by organizations that already operate with limited security resources: universities, research institutions, nonprofit organizations, and public sector teams that still manage critical software.
A targeted step forward
Antares is part of a broader Cisco effort to advance the way security organizations use AI responsibly, measurably, and in service of defenders. With Foundry Security Spec, Cisco has released a model-agnostic blueprint for building agent security assessment systems with clear roles, guardrails, and verifiable outputs. With CodeGuard, Cisco has helped provide secure rules and capabilities by default that can guide AI coding agents to safer software development. With Antares, we add compact security models and a benchmark focused on locating vulnerabilities at the repository level.
Cisco’s efforts are united by a shared belief: AI in security must go beyond impressive one-off demos and result in systems that practitioners can evaluate, manage, and improve. The Foundry Security Spec helps define the framework for agent security work. CodeGuard helps level the ground for prevention by capturing secure coding practices in a reusable corpus of rules. Antares helps with the expensive localization step by isolating vulnerability information into source files that can be reviewed by human reviewers.
Taken together, this work can help the community build a more durable foundation for AI-powered defense: open specifications, reusable security knowledge, compact deployable models, and benchmarks that make progress measurable. The goal is to build a system in which all security professionals, regardless of site or resource limitations, can effectively integrate AI into everyday security operations.
Visit our Hugging Face page to explore the Antares models and view the model map. To learn more about the benchmark and evaluation methodology, read the technical document or contact Cisco Foundation AI.
https://blogs.cisco.com/ai/introducing-antares-the-most-efficient-open-weight-ai-models-for-vulnerability-localization
