Harness AI Blogs

Harness AI is starting 2026 by doubling down on what it does best: applying intelligent automation to the hardest “after code” problems, incidents, security, and test setup, with three new AI-powered capabilities. These updates continue the same theme as December: move faster, keep control, and let AI handle more of the tedious, error-prone work in your delivery and security pipelines.

What’s New in Harness AI:

• Human-aware incident analysis that correlates conversations with changes
• AI-driven API naming that reduces security noise
• Natural-language auth script generation for faster AST onboarding
• AppSec agent for querying security data and generating policies

Human-Aware Change Agent for AI SRE

Harness AI SRE now includes the Human-Aware Change Agent, an AI system that treats human insight as first-class operational data and connects it to the changes that actually break production. Instead of relying only on logs and metrics, it listens to real incident conversations in tools like Slack, Teams, and Zoom and turns those clues into structured signals.​

• The AI Scribe captures key decisions, timestamps, symptoms, and “right before this happened…” moments from live conversations, filtering out unrelated chatter.​
• The Change Agent uses these human signals to drive a change-centric investigation across deployments, feature flags, config, infra changes, and ITSM records, then produces evidence-backed hypotheses such as, “This checkout deployment changed retry behavior 12 minutes before the incident, and latency spiked immediately after.”​​

By unifying human observations with the software delivery knowledge graph and change intelligence, teams get a much faster path from “what are we seeing?” to “what changed?” to “what should we roll back or fix safely?” The result is shorter incidents, clearer ownership, and a teammate-like AI that reasons about both people and systems in real time.​ Learn more in the announcement blog post.

AI-Powered API Naming for Cleaner Security Signals

Effective application security starts with knowing what you actually have in production. Traditional API naming based on regex heuristics often leads to over-merged or under-merged API groups, noisy inventories, and false positives across detection workflows.​

This month, API naming in our Traceable product gets a major upgrade with AI-powered API semantics:

• API naming is now powered by LLMs that understand intent, behavior, and functional semantics, not just URL or path similarity. The result is more stable, meaningful API groupings that reflect how your services actually behave.​
• The LLM-driven results were baselined against custom naming rules from advanced users and achieved >98.7% average match in internal benchmarking.​
• With cleaner API groupings, teams see reduced false positives across vulnerability detection, AST, and runtime protection, and a less noisy API inventory that’s easier for security and platform teams to act on.​

For security leaders trying to tame API sprawl, this is a foundational improvement that boosts signal quality across the entire platform.​

AI-Based Auth Script Generation: Faster, Safer API Security Testing Setup

Authentication setup has been one of the most consistent sources of friction for application security testing. Manual scripting, validation cycles, and back-and-forths often create bottlenecks — and a broken auth script can quietly invalidate an entire scan run.​

To solve this, all API Security Testing customers now get AI-based Authentication Script Generation:

• Generate auth scripts by simply describing the scenario in natural language; AI produces a ready-to-use script in a few seconds, which you can refine, edit, or use as a base for existing scripts.​
• The feature works alongside existing flows, so teams can keep using form-based or code-based auth with identical behavior while layering in AI where it helps most.​​

The result is less time lost to brittle auth setup, faster onboarding for new apps, and fewer failed scans due to script errors.​

You can find implementation details and examples in the docs. 

Chat with AppSec Agent: Security Data, in Plain Language

Security and platform teams often know the question they want to ask: “Where is this component used?” “Which exemptions are still pending?” , but answering it requires hopping across dashboards and stitching together filters by hand.​

The new AppSec Agent makes this dramatically easier by letting you query AppSec data using natural language.

Here's what it does:

• In Harness STO, you can ask about security issues and exemptions, then drill into issue-level insights from STO results without manually navigating views or composing complex filters. Questions like “Approve all valid pending exemptions in this project of issue type secret” become a single prompt instead of a multi-step workflow.​
• In Harness SCS, you can query for artifacts, code repos, SBOMs, chain-of-custody, and compliance results, then even generate OPA policies with a single prompt to block components based on license risk or vulnerable packages. For example, “Create an OPA policy to block the deployment of components licensed under the GPL-3.0 license” or “Help me identify whether the chalk and xz-utils components are present in any of the artifacts in this project” are fully supported.​
• The AppSec Agent is available across all production environments and integrates directly with Harness Security Testing Orchestration (STO) and Software Supply Chain Assurance (SCS).

This is a big step toward making AppSec data as queryable and collaborative as the rest of your engineering stack. Learn more in the docs.​

How This Fits the Harness AI Vision

Harness AI is focused on everything after code is written — building, testing, deploying, securing, and optimizing software through intelligent automation and agentic workflows. January’s updates extend that vision across:

• Security and AppSec: higher-fidelity API grouping, fewer false positives, and faster AST onboarding with AI-generated auth.
• SRE and Operations: human-aware incident response that unifies human and machine signals into a single, change-driven flow.
• Governance and Compliance: consistent with December’s AI governance updates, all of these capabilities inherit Harness’s approach of policy-aware AI, auditability, and RBAC-aligned actions.

Teams adopting these features can ship changes faster, investigate less, and focus more of their time on the work that actually moves the business — while Harness AI quietly handles the complexity in the background.

Our December Harness AI updates focus specifically on enhancements to Harness AI governance. You can review our Harness AI November updates here.

The Governance Paradox

Every platform engineering team faces the same tension: developers want to move fast, while security and compliance teams need guardrails. Too much friction slows delivery. Too little creates risk.

What if AI could help you have both?

With Harness AI, you can accelerate pipeline creation while automatically enforcing your organization's policies. Every AI-generated resource is traceable, auditable, and compliant—by design.

AI-Powered Policy Generation

Open Policy Agent (OPA) policies are the backbone of governance in Harness. They enforce rules across:

• Pipeline governance: Who can deploy what, where, and when
• Entity governance: Standards for services, environments, and connectors
• Cost governance: Spend limits and resource constraints
• Security scan governance: Required scans before promotion

The challenge? Writing Rego policies requires specialized knowledge. Most teams have a handful of people who understand OPA, and they're constantly backlogged.

Harness AI changes this.

Now, anyone can describe a policy in plain English and let AI generate the Rego code:

"Create a policy that requires approval from the security team for any deployment to production that hasn't passed a SAST scan."

Harness AI generates the policy. Your experts review and approve. Governance scales without bottlenecks.

Build Compliant Pipelines from the Start

Here's where governance and productivity intersect.

Your organization has invested in "golden" pipeline templates - battle-tested, approved configurations that encode your best practices. The problem: developers don't always know they exist, or they take shortcuts to avoid the complexity.

With Harness AI, developers simply ask:

"Build me a deployment pipeline that references our golden Java microservices template."

Harness AI:

1. Searches your template library to find the right template
2. Constructs a pipeline that properly references it
3. Inherits all the governance baked into that template

The result? Developers get pipelines in seconds. Platform teams get compliance by default. Learn more about referencing templates here.

What Can Harness AI Generate?

Any AI-generated resource can be saved as a template for others to reuse, thereby compounding your investment in standards.

Built-In Guardrails: OPA Enforcement on Every Action

What happens when AI generates something that doesn't meet your policies?

It gets caught immediately.

When a user saves or runs an AI-generated pipeline, Harness evaluates it against your OPA policies in real-time. If there's a violation:

1. The action is blocked (save or run fails)
2. Clear feedback is provided explaining why
3. The user can fix it in the AI chat by describing the needed changes

For example:

Policy Violation: "Production deployments require a manual approval stage. Your pipeline is missing this step."

User prompt: "Add a manual approval stage before the production deployment."

Harness AI: Updates the pipeline to comply.

This feedback loop turns policy violations into learning moments, without leaving the AI experience. Learn more about Harness AI and OPA policies here.

Full Auditability: Every AI Action is Traced

In regulated industries, "an AI built it" isn't an acceptable audit response. You need traceability.

Harness AI provides it:

AI-Generated Label

Every resource created by Harness AI is automatically labeled:

ai_generated: true

‍This label persists through the resource lifecycle. You always know what was created by humans versus AI-assisted.

Audit Trail Integration

All AI-generated entities appear in the Harness Audit Trail with:

• Who prompted the creation (the user)
• What was created
• When it was created
• How it was created (AI-assisted)

Execution Evidence

For AI-generated pipelines, you can:

• View execution history to see how the pipeline performed
• Download execution logs for compliance documentation
• Validate outputs to confirm the pipeline meets requirements

This gives auditors and compliance teams the evidence they need—without manual documentation overhead.

Security by Design: AI Operates Within User RBAC

A common concern with AI assistants: "What if it does something the user shouldn't be able to do?"

Harness AI eliminates this risk with a fundamental design principle:

Harness AI can only do what the user can do.

The AI operates on behalf of the authenticated user, inheriting their exact Role-Based Access Control (RBAC) permissions:

There's no privilege escalation. No backdoors. No "AI admin" account. The AI is an extension of the user—bound by the same rules.

The Governance + AI Workflow

Here's how it all comes together:

‍

Why This Matters

For Platform Engineering Teams

• Scale governance without becoming a bottleneck
• Ensure template adoption by making it the easy path
• Reduce policy violations with real-time feedback
• Maintain audit trails automatically

For Developers

• Build pipelines faster with natural language
• Stay compliant without memorizing policies
• Learn from violations instead of getting blocked
• Use templates without hunting for documentation

For Security & Compliance Teams

• Enforce policies consistently across all pipelines
• Trace AI-generated resources with clear labels
• Audit with confidence using execution evidence
• Trust the access model with RBAC inheritance

Get Started with Harness AI + Governance

Already a Harness customer? Harness AI is available across the platform. Start by:

1. Enabling Harness AI in your account settings
2. Creating OPA policies for your key governance requirements
3. Building pipeline templates that encode your standards
4. Letting developers prompt their way to compliant pipelines

New to Harness? Request a demo to see AI-powered governance in action.

‍

Knowledge graphs and RAG (Retrieval-Augmented Generation) are complementary techniques for enhancing large language models with external knowledge, and each brings unique strengths for DevOps use cases. While they are often mentioned together, they are fundamentally different systems, and combining them delivers far better outcomes than relying on either approach alone.

Core Differences

A knowledge graph is a semantic model composed of entities and relationships that reflect how systems, services, code, environments, and people connect. These entities may come from Harness or from third-party DevOps tools. Retrieval from a knowledge graph can be:

• Structured: via graph queries that traverse relationships
• Unstructured: via semantic indexing of graph-connected content

The foundation of the knowledge graph is its semantic layer, which serves as the source of truth for the structure and meaning of the data. This semantic layer defines what an “application,” “pipeline,” “service,” “environment,” “deployment,” or “policy” means - not just how it is stored. This enforces consistent definitions across tools, eliminates ambiguity, and grounds all reasoning in shared meaning.

Because the semantic layer governs how data flows into the graph, it ensures the graph scales cleanly, remains governable, and can incorporate new tools, relationships, and metadata without becoming chaotic.

RAG, by contrast, retrieves unstructured text (documents, runbooks, incident notes, commit messages, architecture diagrams) using embedding similarity and feeds the retrieved content to an LLM. RAG does not model structure or relationships; it retrieves relevant fragments of text.

The fundamental distinction lies in structure:

• A knowledge graph encodes explicit, machine-interpretable relationships.
  
  
• RAG retrieves text based on semantic similarity, without understanding how the connections work.
  
  

This is why the two approaches excel at different types of problems.

Strengths and Limitations

Knowledge Graph Strengths

Knowledge graphs excel at multi-hop reasoning, where answering a question requires walking multiple relationships — linking a failing service to its owning team, its CI pipeline, the associated environment, and the policies governing that environment.

They offer:

• strong explainability
  
  
• traceable reasoning
  
  
• lineage and dependency analysis
  
  
• organizational context awareness
  
  
• consistent governance enforced by the semantic layer
  
  

The primary limitation is that a knowledge graph is limited by the data it models.

RAG Strengths

RAG systems shine when working with unstructured information at scale. They are excellent for:

• documentation search
  
  
• incident history retrieval
  
  
• architecture and API references
  
  
• runbook guidance
  
  
• open-ended queries
  
  

However, RAG struggles with questions that require:

• relationship reasoning
  
  
• ownership inference
  
  
• dependency mapping
  
  
• policy or environment constraints
  
  
• multi-step chains of logic
  
  

RAG retrieves text. It does not understand structure.

‍

Hybrid Approaches

Modern DevOps AI systems increasingly combine both approaches:

• RAG provides breadth — rich unstructured context.
  
  
• The knowledge graph provides depth — structured reasoning and grounding.
  
  
• The semantic layer provides stability — consistent meaning and scalable governance.
  
  

The result is retrieval and reasoning that are not only relevant but also organized, contextualized, and aligned with the real structure of the software delivery environment.

Why Knowledge Graphs Excel in DevOps

DevOps environments are inherently relationship-heavy: pipelines, services, environments, teams, approvals, policies, artifacts, and dependencies all interact tightly.

A knowledge graph captures these interactions explicitly.

The semantic layer ensures that as systems evolve, definitions remain consistent.

This gives AI agents true organizational context — not just textual familiarity.

With a graph-backed semantic model, agents can reason about:

• ownership
  
  
• dependency chains
  
  
• deployment pathways
  
  
• policy enforcement
  
  
• environment behavior
  
  
• compliance boundaries

This is essential for generating pipelines, validating changes, automating deployments, and performing impact analysis.

‍

Limitations of RAG for DevOps

RAG is excellent for retrieving documentation, API references, runbooks, and historical incidents. But it cannot reliably infer:

• which team owns a service
  
  
• which pipeline deploys that service
  
  
• which environments are impacted
  
  
• which policies apply
  
  
• what dependencies exist and how they cascade
  
  

RAG retrieves text; it does not reason across structured relationships.

This limits RAG-only approaches to “chatbots over docs,” which is useful but insufficient for deeper automation.

Hybrid Approaches Emerging

A hybrid system uses both unstructured retrieval (RAG) and structured context (knowledge graph) to produce highly accurate, domain-aware answers. The semantic layer ensures that the graph remains consistent and scalable even as the organization grows.

This combination enables:

• context-aware pipeline generation
  
  
• graph-grounded debugging
  
  
• multi-step orchestration
  
  
• data-driven governance
  
  
• safe automation across tools
  
  

Knowledge Graphs Benefit More Than AI

Knowledge graphs — and especially the semantic layer behind them — benefit the entire engineering ecosystem, not just AI.

They provide:

• a unified, shared set of definitions across the SDLC
  
  
• governance and data quality enforcement
  
  
• lineage and dependency mapping
  
  
• centralized metadata consistency
  
  
• better observability and reporting
  
  
• clean integration across tools
  
  

AI simply leverages this foundation to become more grounded, less error-prone, and deeply contextual.

‍

Harness’s Hybrid Implementation

Harness uses a Software Delivery Knowledge Graph built on a semantic model that continuously synchronizes entities and relationships across Harness modules and third-party DevOps tools. The semantic layer defines meaning and ensures structure, while RAG enriches the system with unstructured context.

This enables AI agents to:

• generate pipelines aligned with org standards
  
  
• automatically debug issues with traceable reasoning
  
  
• execute root-cause analysis across dependencies
  
  
• perform safe rollbacks constrained by policies
  
  

Results include:

• 85% faster pipeline onboarding
  
  
• 7x faster issue resolution
  
  
• 50% less debugging time
  
  

This is possible because the system blends semantic structure (knowledge graph), meaning (semantic layer), and breadth of context (RAG), producing far more reliable DevOps automation than any single method alone. We'll be writing more about Knowledge Graph in upcoming blog posts.

‍

November was another big month for Harness AI, with new capabilities that deepen our work with AWS, bring AI-native automation to the database, and keep our model stack on the cutting edge across the SDLC.​

Harness + Amazon: AI-Powered DevOps

We are expanding our partnership with Amazon to connect AI-powered development directly to intelligent delivery. As AI tools like Amazon Q and Kiro accelerate code development, this integration focuses on safely moving that code into production with built-in governance, security, cost controls, and delivery intelligence. Together, Harness SaaS on AWS and Harness’s Software Delivery Knowledge Graph provide teams with a single, trusted path from code to cloud, eliminating the need to stitch together point tools.​

For developers, this shows up as AI-infused workflows in the IDE and CI/CD pipelines that understand context across 160+ tools exposed via the Harness MCP server. Teams can see faster pipeline onboarding, dramatically reduced debugging time, and safer rollouts, while platform and security leaders get unified governance across AWS environments without sacrificing velocity.​ Learn more about the partnership in this blog post.

AI-Powered Database Migration Authoring

Application delivery has become highly automated, but databases have historically lagged behind. Schema changes are still often managed with manual SQL scripts, spreadsheets, and late-night deployments. That gap makes databases one of the most common sources of release friction and risk, turning them into a bottleneck even when CI/CD is mature. Database DevOps matters because it applies the same discipline used for applications—Git, policy-as-code, governed pipelines, automated rollback—to the systems that hold your most critical data.​

Harness Database DevOps tackles this directly by treating database changes like application code: versioned, tested, governed, and observable across environments. As one of the fastest-growing modules in the Harness platform, it helps teams ship safely without waiting on a small group of DBAs or accepting 2 a.m. change windows as normal.​

We have introduced AI-powered database migration authoring inside our Database DevOps product. Developers can now describe the change they want in natural language, and Harness generates production-ready migrations that are backward-compatible, validated against policies, wired into Git, and paired with rollback scripts. Every migration is governed and auditable, so DBAs maintain control through policy-as-code and approvals while the AI handles the heavy lifting.​

Under the hood, this capability is powered by the Software Delivery Knowledge Graph and the Harness MCP server, which bring awareness of schemas, pipelines, and best practices into each suggestion. The result is a database layer that finally moves at DevOps speed, with fewer incidents, stronger governance, and far less manual toil for both developers and database teams.​ Learn more about AI-powered database migration authoring here.

Improved Pipeline Error Analyzer

Error Analyzer is a great example of how Harness AI applies deep context, not just raw model power, to real DevOps problems. When a pipeline fails, our improved Error Analyzer automatically correlates recent changes, checks dependencies, identifies historical patterns, and pinpoints the most likely root cause, allowing teams to skip scrolling through logs and jump straight to fixes. The analysis view highlights which commits or configuration edits are likely to have triggered the regression, whether an external service or infrastructure dependency is unhealthy, and how similar this failure is to previous incidents across your organization.​

From there, Harness AI turns insights into concrete action. Error Analyzer presents prioritized recommendations with clear justifications, and in many cases, can generate and apply YAML fixes on your behalf, with a before-and-after diff, so you stay in control. With built-in impact assessment and an audit trail of pipeline changes, teams can diagnose issues more quickly, understand the blast radius, and continuously harden their pipelines and dramatically reducing debugging time while maintaining high reliability.

Always-On Model Optimization

Behind these experiences, Harness AI continually evaluates and upgrades its underlying model stack, including the latest generations, such as Claude 4.5, Sonnet 4.5, and GPT-5. Instead of betting on a single LLM, Harness runs internal evaluations and real-world tests to benchmark performance, reliability, and safety for specific software delivery jobs, such as pipeline generation, error analysis, and database migration authoring. The platform then dynamically selects the best model for each task, with guardrails and fallbacks built in, so customers achieve the strongest results without having to manage model churn themselves.​

Closing the AI Velocity Gap

Taken together, November’s updates are another step toward Harness’s vision of AI-native software delivery: where agents understand intent, enforce policy, and automate work from code to cloud to database. Deep AWS integrations remove friction between AI-powered development and production, Database DevOps eliminates the last major manual bottleneck, and continuous model optimization keeps Harness AI ahead of the curve for real-world DevOps use cases. As AI continues to increase code velocity, these capabilities make sure your pipelines, databases, and platforms can keep up with confidence.

‍

Today, we’re excited to announce our expanded partnership with Amazon, bringing together the power of Amazon Kiro, Amazon Q Developer, and Harness SaaS on AWS to revolutionize how your team builds, troubleshoots, secures, and deploys software. This collaboration is designed to deliver a seamless, intelligent, and scalable software delivery experience for all AWS customers.

Harness SaaS on AWS: Powering Cloud-Native Delivery

Harness SaaS on AWS empowers engineering and DevOps teams to deliver software faster, safer, and more efficiently across cloud-native environments. By leveraging the robust infrastructure of AWS, Harness provides an AI platform that scales with your business needs. With Harness SaaS on AWS, you get:

• Accelerated, Reliable Deployments: Build and execute complex pipelines in minutes, supporting advanced deployment strategies like blue/green, canary, and rolling updates for AWS services such as EKS, ECS, Lambda, and Auto Scaling Groups.
• Smart Automation & Continuous Verification: Harness leverages AI to run only tests affected by code changes and detect anomalies and automatically roll back failed deployments, minimizing downtime and risk.
• Automated Security & Compliance: Built-in secret management, audit trails, granular RBAC, and continuous vulnerability scanning ensure every deployment is secure and compliant.
• Cloud Cost Optimization: Harness Cloud Cost Management gives FinOps and engineering teams granular visibility and automated orchestration to maximize savings and optimize AWS consumption.

‍

AI-Powered Software Delivery, Right in Your IDE

The Harness Platform is now even more powerful with the integration of Amazon Kiro and Q Developer. This agentic IDE revolution enables developers to manage, optimize, and resolve CI/CD pipeline, security, and testing issues directly from their development environment using natural language. No more switching between Kiro and the Harness platform. Now, you can ask Kiro for your AWS infrastructure information, along with Harness pipeline executions, in the context of your IDE. Learn more about the different use cases in this blog post.

Context is the key for any AI to be effective. Harness’s Software Delivery Knowledge Graph ensures that this automation is tailored to your AWS environment, providing actionable insights rather than generic recommendations. Whether you’re a seasoned expert or a new team member, this integration makes shipping code faster and more intuitive. Learn more about the Knowledge Graph.

Real Value, Real Results

Harness is already helping customers achieve accelerated build and deployment using AI-powered features such as Test Intelligence and Continuous Verification. Organizations such as United Airlines and Trust Bank have enhanced their software delivery experience with Harness and AWS.

Specifically, for Trust Bank, Harness's cloud-first capabilities enable Trust Bank to efficiently deploy changes across its containerized applications on AWS, utilizing Amazon EKS. Trust Bank also leverages AWS services such as Amazon Athena, Amazon RDS, and Amazon Aurora, resulting in a resilient, secure, and optimized infrastructure that scales with its growth. Trust Bank sought a solution to integrate with its AWS environment, reduce developer workload, and prioritize innovation, aiming to offload the onerous supply delivery chain lifecycle. By integrating Harness with AWS and automating compliance, security, and risk checks in the CI/CD pipeline, Trust Bank cut its deployment lead time from two weeks to just 24 hours. Automated compliance ensures all industry-standard controls are met, maintaining high security. This automation enables Trust Bank to focus on delivering innovative products, rather than being hindered by manual processes.

Built for Shipping Software with Confidence

This partnership delivers enterprise-grade automation, contextual intelligence, and seamless cloud-native delivery, all backed by the reliability of AWS. Harness SaaS on AWS is available for purchase through the AWS Marketplace, making it easy for your organization to get started and scale as your needs grow. Together with Amazon Kiro, Q, and Harness SaaS on AWS, Harness and Amazon are committed to removing bottlenecks and empowering teams to ship software with confidence. 

Register for the “Securing AI Velocity” webinar to learn more about how Harness and AWS can make software delivery better.

‍

The AI Velocity Paradox is real. While teams are writing code faster than ever, they're hitting a wall downstream. Deployments are failing. Security vulnerabilities are slipping through. Manual toil is eating up whatever time developers saved with AI-assisted coding. The speed boost from one part of the software delivery lifecycle is being strangled by legacy processes in another.

Harness is solving this the only way that works: by bringing intelligent AI deeper into the delivery process itself.

Last quarter, we introduced transformative updates to Harness AI that address the exact problem plaguing most organizations: understanding complex pipelines, troubleshooting failures in seconds instead of hours, and building persistent AI memory to evolve alongside your team's workflows.

The Problem We're Solving: When Code Moves Faster Than Your Pipeline

Here's what we're seeing in the field: teams adopting AI for coding are experiencing a 25% increase in adoption, but Google's DORA research tells us the uncomfortable truth — that AI adoption is actually decreasing delivery stability by 7.2% and throughput by 1.5%. Why? Because the downstream bottleneck is real.

Developers can generate code in minutes. But when that code hits a pipeline, they run into walls:

• Complex pipelines that nobody fully understands, documented only in institutional memory
• Deployment failures that require hours of digging to understand what actually went wrong
• No continuity between troubleshooting sessions, forcing teams to restart their investigation each time

October has been a busy month for us as we released a bunch of updates to bring intelligent automation to everything after the code is written, exactly where teams need it most.

‍

Pipeline Understanding: AI That Actually Knows What Your Pipelines Do

Harness AI now automatically analyzes your most complex pipelines and summarizes what they do, why they exist, what stages matter, and how they're connected. No more hunting through YAML. No more waiting for the one person who understands the legacy pipeline configuration.

This is about velocity without the toil. When a new developer joins, they can understand pipeline design in minutes, rather than days. When you're troubleshooting a failure, you immediately know which stages are relevant and why. When you optimize your delivery process, you gain clarity on what each pipeline actually does.

The impact: Faster comprehension of pipeline design and intent without digging through multiple configurations. Teams spend less time context-switching and more time shipping.

‍

Conversational Troubleshooting: Chat Your Way Out of Failures

Ask Harness AI why your deployment failed. Not a generic error code. An actual conversation.

"Why did this deployment fail?"
"How do I fix it?"
"What changed between the last successful deployment and this one?"

The enhanced Error Analyzer now supports natural language interactions across more stage types. Instead of squinting at logs and error messages, you're having a dialogue with an AI that understands your pipeline, your errors, and how to resolve them. The AI provides instant, contextual explanations that get to the root cause.

The impact: Root-cause analysis that takes hours becomes a conversation that takes minutes. Time-to-resolution drops dramatically. Teams spending 40%+ of their time on toil suddenly have hours back to focus on actual innovation.

‍

Chat History and Memory: AI That Remembers, So You Don't Have To

Harness AI now supports chat history, enabling teams to organize conversations, revisit past troubleshooting sessions, and maintain context between interactions. This is similar to the AI IDE experience, but for DevOps. It's the difference between a helpful chatbot that forgets everything and an AI teammate that learns alongside you.

The impact: Continuous context, smarter collaboration, and evolving intelligence that gets better the more your team uses it. Teams aren't restarting investigations from scratch. Memory compounds over time.

‍

Harness CD Update: AI Verification and Rollback Gets Smarter

We've also enhanced Harness Continuous Delivery with AI verification and rollback capabilities. New integration with Dynatrace Grail, an increasingly popular logs platform, means teams using Grail can now connect it directly to Harness, triggering automatic rollback on abnormal log telemetry after a deployment.

This closes the loop on the Velocity Paradox. Code moves fast. Verification is intelligent and automated. When something goes wrong, the system acts before customers notice.

‍

MCP Updates: Building the Foundation for Agentic Automation

Our Model Context Protocol (MCP) server is evolving with expanded Feature Management and Experimentation (FME) toolset capabilities, laying the groundwork for even deeper agentic automation across the platform. This is how AI teams get integrated into your existing workflows, not as replacements, but as force multipliers. Learn more about using this toolset with Claude Code.

‍

Harness IDP Update: Smarter Worklows

In case you missed it, we also announced the IDP Knowledge Agent at our Unscripted conference. The Knowledge Agent is now available and resides within the Harness IDP, serving as an AI-powered teammate. It helps developers find the information they need, understand how systems work, and take action faster. You can ask questions like, “Who owns the authentication service?” or “How can I improve my score?” and get relevant, trustworthy answers in seconds. Learn more about the Knowledge Agent in this blog post.

‍

Why This Matters: AI Isn't Just About Speed

The worst trap organizations fall into is measuring AI by how fast developers can code. That's missing the entire point.

AI's real value is in the systems. It's in understanding complexity that humans can't easily parse. It's in eliminating repetitive troubleshooting. It's in the memory that builds over time, making teams smarter with every deployment.

Harness AI for DevOps addresses the real problem: the downstream bottleneck that's choking velocity gains from upstream AI adoption.

By bringing intelligent automation to pipeline understanding, instant troubleshooting, and persistent context, we're not just making deployments faster. We're making them safer, smarter, and more resilient. We're turning the Velocity Paradox on its head—ensuring that when code moves fast, everything downstream can keep up.

This is what AI-native software delivery looks like. Not faster chaos. Faster, safer, smarter execution.

‍

What's Next

These updates represent a shift in how Harness approaches AI. We're not adding features. We're solving a fundamental problem in modern software delivery: the gap between upstream speed (code generation) and downstream automation (testing, security, deployment).

The teams winning today aren't the ones with the fastest developers. They're the ones with the most intelligent pipelines. The most resilient deployments. The deepest context about what's actually happening in production.

For everything after the code is written, Harness AI makes that possible.

‍

Picture this: your QA team just rolled out a comprehensive new test suite ; polished, precise, and built to catch every bug. Yet soon after, half the tests fail. Not because the code is broken, but because the design team shifted a button slightly. And even when the tests pass, users still find issues in production. A familiar story?

End-to-end testing was meant to bridge that gap. This is how teams verify that complete user workflows actually work the way users expect them to. It's testing from the user's perspective; can they log in, complete a transaction, see their data?​

‍

The Real Problem Isn't Maintenance. It's Misplaced Focus.

Maintaining traditional UI tests often feels endless. Hard-coded selectors break with every UI tweak, which happens nearly every sprint. A clean, well-structured test suite quickly turns into a maintenance marathon. Then come the flaky tests:  scripts that fail because a button isn’t visible yet or an overlay momentarily blocks it. The application might work perfectly, yet the test still fails, creating unpredictable false alarms and eroding trust in test results.

The real issue lies in what’s being validated. Conventional assertions often focus on technical details- like whether a div.class-name-xy exists or a CSS selector returns a value, rather than confirming that the user experience actually works.

The problem with this approach is that it tests how something is implemented, not whether it works for the user. As a result, a test might pass even when the actual experience is broken, giving teams a false sense of confidence and wasting valuable debugging time.

Some common solutions attempt to bridge that gap. Teams experiment with smarter locators, dynamic waits, self-healing scripts, or visual validation tools to reduce flakiness. Others lean on behavior-driven frameworks such as Cucumber, SpecFlow, or Gauge to describe tests in plain, human-readable language. These approaches make progress, but they still rely on predefined selectors and rigid code structures that don’t always adapt when the UI or business logic changes.

What’s really needed is a shift in perspective : one that focuses on intent rather than implementation. Testing should understand what you’re trying to validate, not just how the test is written.

That’s exactly where Harness builds on these foundations. By combining AI understanding with intent-driven, natural language assertions, it goes beyond behavior-driven testing, actually turning human intent directly into executable validation.

‍

What Are Intent-Driven Natural Language Assertions?

‍

Harness AI Test Automation reimagines testing from the ground up. Instead of writing brittle scripts tied to UI selectors, it allows testers to describe what they actually want to verify, in plain, human language.

Think of it as moving from technical validation to intent validation. Rather than writing code to confirm whether a button exists, you can simply ask:

• “Did the login succeed?” or 
• “Is the latest transaction a deposit?”. 

Behind the scenes, Harness AI interprets these statements dynamically, understanding both the context and the intent of the test. It evaluates the live state of the application to ensure assertions reflect real business logic, not just surface-level UI details.

This shift is more than a technical improvement; it’s a cultural one. It democratizes testing, empowering anyone on the team, from developers to product managers, to contribute meaningful, resilient checks. The result is faster test creation, easier maintenance, and validations that truly align with what users care about: a working, seamless experience.

Harness describes this as "Intent-based Testing", where tests express what matters rather than how to check it, enabling developers and QA teams to focus on outcomes, not implementation details.

‍

Harness AI Test Automation Solving Traditional Testing Issues

‍

Traditional automation for end-to-end testing/UI testing often breaks when UIs change, leading to high maintenance overhead and flaky results. Playwright, Selenium, or Cypress scripts frequently fail because they depend on exact element paths or hardcoded data, which makes CI/CD pipelines brittle.

Industry statistics reveal that 70-80% of organizations still rely heavily on manual testing methods, creating significant bottlenecks in otherwise automated DevOps toolchains. Source

Harness AI Test Automation addresses these issues by leveraging AI-powered assertions that dynamically adapt to the live page or API context. Benefits include:

• Reduced flakiness: Tests automatically handle UI changes without manual intervention
• Lower maintenance costs: AI-generated selectors eliminate constant rewriting of selectors or brittle logic
• Focus on business logic: Teams concentrate on verifying user-centric outcomes rather than technical details
• Faster and No-Code test creation: Organizations report 10x faster test creation and the ability to cut test creation time by up to 90%

Organizations using AI Test Automation see up to 70% less maintenance effort and significant improvements in release velocity.

‍

How Harness AI Test Understands and Validates Your Intent

‍

Harness uses large language models (LLMs) optimized for testing contexts. The AI:

‍

• Understands Your Intent: The AI parses your natural language assertion to grasp what you're trying to verify, for example, “Did the login succeed?" or “Is the button visible after submission?"
  
• Analyzes Real Application Context:  It evaluates the live state of your application by analyzing the HTML DOM and the rendered viewport. This provides the AI with a comprehensive understanding of the app's current behavior, structure, and visual presentation.
  
• Maintains Context History: it keeps a record of previous steps and results, so the AI can use historical context when validating new assertions.
  
• Learns from Past Runs: Outputs from prior test executions are stored and referenced, allowing future assertions to become more accurate and context-aware over time.
  
• Provides Detailed Reasoning: Instead of just marking a test as “pass” or “fail,” the AI explains why, offering insights backed by both visual and structural evidence.
  
  

Together, these layers of intelligence make Harness AI Assertions not just smarter but contextually aware, giving you a more human-like and reliable testing experience every time you run your pipeline.

This context-aware approach identifies subtle bugs that are often missed by traditional tests and reduces the risks associated with AI “hallucinations.” Hybrid verification techniques cross-check outputs against real-time data, ensuring reliability.

For example, when testing a dynamic transaction table, an assertion like “Verify the latest transaction is a deposit over $500” will succeed even if the table order changes or new rows are added. Harness adapts automatically without requiring code changes
‍Harness Blog on AI Test Automation.

‍

Crucially, we are not asking the AI to generate code (although for some math questions it might) and then never consult it again; we actually ask the AI this question with the context of the webpage every time you run the test.

‍

Successful or not, the assertion will also give you back reasoning as to why it is true:

‍

‍

How Teams Use Harness AI Assertions

‍

Organizations across fintech, SaaS, and e-commerce are using Harness AI to simplify complex testing scenarios:

• Financial services: Validating transaction tables and workflows with natural language assertions.
• SaaS platforms: Checking onboarding flows and dynamic permission rules.
• E-commerce: Confirming discount logic and inventory updates dynamically.
• Healthcare: Transforming test creation from days to minutes
  
  

Even less-technical users can author and maintain robust tests. Auto-suggested assertions and natural language prompts accelerate collaboration across QA, developers, and product teams.

‍

‍

‍

‍

You can also perform assertions based on parameters.

‍

An early adopter reported that after integrating Harness AI Assertions, release verification time dropped by more than 50%, freeing QA teams to focus on higher-value work. DevOpsDigest coverage

‍

Transforming QA with Harness AI: Faster, Smarter, Reliable

‍

Harness AI Test Automation empowers teams to move faster with confidence. Key benefits include:

• Faster test creation: Write robust assertions in minutes rather than hours.
  
  
• Reduced test maintenance: Fewer broken scripts and less manual debugging.
  
  
• Improved collaboration: Align developers, testers, and product managers around shared intent.
  
  
• Future-ready QA: Supports modern DevOps practices and continuous delivery pipelines.
  
  

Harness AI Test Automation turns traditional QA challenges into opportunities for smarter, more reliable automation, enabling organizations to release software faster while maintaining high quality.

Harness AI is to test what intelligent assistants are to coding: it allows humans to focus on strategy, intent, and value, while the AI handles repetitive validation (Harness AI Test Automation).

‍

Harness AI Test Automation represents a paradigm shift in testing. By combining intent-driven natural language assertions, AI-powered context awareness, and self-adapting validation, it empowers teams to deliver reliable software faster and with less friction.

‍

‍

If you are excited about and want to simplify maintenance while improving test reliability, contact us to learn more about how intent-driven, natural-language assertions can transform your testing experience.

‍

‍

Teams have always been under pressure to deliver software faster. But here's what we've learned from working with thousands of engineering teams: writing the code has never been the real bottleneck. It's everything that happens after - the testing, security scans, deployments, and optimizations that determine whether your innovations actually reach customers quickly and reliably. Even in the era of AI, the speed boost is uneven, creating the AI Velocity Paradox.

That's why we're excited to share how our collaboration with Google Cloud changes the game for your team. This isn't just about new technology - it's about solving the daily challenges that prevent you from shipping with confidence.​

What This Means for Your DevSecOps Workflows

You might have experienced the frustration of watching perfectly good code sit in limbo while your CI/CD pipelines break, tests fail, or security scans slow everything down. Nearly 45% of all deployments linked to AI-generated code lead to problems.​

With Harness AI enabled by Google Cloud's Vertex AI platform, you get intelligent automation across every stage after code. Your team can now create enterprise-grade pipelines in seconds using natural language, automatically generate and maintain tests that adapt to changes, and deploy with confidence knowing AI is detecting issues in real time.​

The results speak for themselves. Teams using Harness AI are already seeing test cycle times slashed by up to 80%, pipeline onboarding accelerated by 85%, and issue resolution that's 7 times faster. That's not just incremental improvement - it's getting back hours of your day to focus on innovation instead of toil.​

Security and Compliance You Can Actually Trust

We know what keeps you up at night. You need speed, but you can't compromise on security or compliance. This is where our partnership with Google Cloud becomes critical for your peace of mind.​

Harness AI is enabled by Vertex AI, Google Cloud’s advanced AI platform that provides private, dedicated access to cutting-edge models like the Gemini 2.5 series. Your data is never stored or used for training. Every insight and recommendation is generated using only your organization's context through our Software Delivery Knowledge Graph, which remains completely isolated.​

You get built-in privacy, governance, scalability, and compliance guardrails, ensuring you can adopt AI without risk. Security scanning happens in real time, vulnerabilities get detected and remediated automatically, and every change is tracked for full auditability.​

The Power of Context-Aware Intelligence - The Software Delivery Knowledge Graph

Powering Harness AI is our Software Delivery Knowledge Graph, which helps it understand your entire software delivery environment. Our Knowledge Graph is purpose-built exclusively for the software delivery lifecycle, capturing relationships across every stage from code to production in a secure, privacy-first manner.

Unlike generic knowledge graphs, it continuously ingests and connects a wide range of data from builds, tests, deployments, incidents, infrastructure changes, security scans, feature flags, rollbacks, test results, cloud spend, and database changes into a unified, real-time intelligence layer. This comprehensive mapping enables Harness AI to understand not just individual components, but the causal relationships between code changes, deployment outcomes, system behavior, and business impact. We also plan to integrate data from Google Cloud Platform into our knowledge graph, enhancing the AI's understanding of your GCP workloads.

Need to troubleshoot a broken pipeline? AI-powered error analysis translates cryptic error messages and provides actionable next steps based on your environment, saving you hours of debugging time. Want to optimize your cloud costs? You get smart recommendations tailored to your actual usage patterns, not generic best practices.​

Harness AI: Built Into The Platform, Not Bolted On

You don't need to install anything new, manage external credentials, or lose control of your workflows. Harness AI works directly within the Harness Platform you already use, integrating seamlessly with your CI/CD pipelines, Feature Flags, Cloud Cost Management, and Security Testing. Behind the scenes, specialized AI agents work together to automate tasks intelligently.​

Your engineers can simply describe what they need in natural language through a chat interface, and Harness AI handles the complexity. Whether it's onboarding new team members who can now deploy with confidence in minutes instead of days, or automatically rolling back deployments when regressions are detected, the intelligence adapts to your workflows.​

Deeper Integrations with Google Cloud

Recently, we were the launch partner for Gemini CLI extensions, which enables AI to seamlessly interact with Harness tools and GCP services using the Model Context Protocol (MCP) standard. This allows engineers to leverage powerful CLI capabilities that effortlessly reach multiple tools through standardized communication.

Our collaboration with Google Cloud goes beyond today's capabilities. We're investing in Google Cloud's Agent2Agent (A2A) protocol for enhanced interoperability, and customers already have expanded access to Harness through Google Cloud Marketplace. This shared foundation means tighter integration and more powerful automation for your team as we continue building together.​

The partnership reflects a shared commitment: helping you move at the speed of innovation while ensuring the enterprise safety and compliance your business depends on. With roots in Google Cloud, Harness AI gives you the scale and resilience global enterprises demand.​

Harness AI is available now for all Harness customers. Your team no longer has to choose between speed and trust - with our Google Cloud collaboration, you get both.

‍

The modern software development landscape moves fast, with AI-powered coding assistants generating code at unprecedented speeds. However, even the most sophisticated code generation is only half the battle. The real challenge lies in ensuring that code successfully navigates through CI/CD pipelines to reach production. Pipeline failures remain one of the most frustrating bottlenecks in software delivery, often requiring manual investigation and complex debugging processes. This blog post describes how the powerful combination of Amazon Kiro and Harness’s MCP server helps you fix CI/CD issues, right from your IDE.

Amazon Kiro: The Agentic IDE Revolution

Amazon Kiro represents a new category of development tools: an agentic IDE that helps developers move from prototype to production with the structure that production-ready code requires. Unlike traditional AI coding assistants that focus primarily on code generation, Kiro uses an agentic reasoning loop of planning, reasoning, taking actions, and evaluating results to handle multi-step tasks.

What sets Kiro apart is its context awareness and integration capabilities through the Model Context Protocol (MCP) framework. This allows Kiro to run locally while connecting to specialized tools and services through standardized MCP servers. The platform includes features like specs for defining project requirements, steering rules to guide AI behavior across projects, and agent hooks that automate repetitive tasks using smart triggers.

Harness: Intelligence After Code Generation

Harness is the AI platform for everything after code, focusing on testing, security, deployment, and optimization. Built on eight years of AI innovation in software delivery, Harness has evolved from pioneering AI-driven Continuous Verification in 2017 to today's agentic AI capabilities that autonomously perceive, reason, act, and learn across the entire software delivery lifecycle.

The platform delivers measurable improvements in software delivery performance. Organizations using Harness AI have seen 85% faster pipeline onboarding, 7x faster issue resolution through AI-powered troubleshooting, and 50% reduction in pipeline debugging time. At its core lies the Software Delivery Knowledge Graph: a continuously updated intelligence layer that captures and connects data from every stage of the SDLC, enabling contextual automation and decision-making.

Seamless Integration: Where AI Meets DevOps Excellence

Harness's MCP Server provides a unified interface for AI agents to interact with Harness's comprehensive suite of DevOps tools and services. The integration of Harness MCP server and Amazon Kiro brings the power of Harness's 161 DevOps tools directly into Kiro's development environment, creating a high level of automation for CI/CD pipeline management and troubleshooting. This integration enables developers to seamlessly understand and fix pipeline failures without leaving their coding environment.

Consider a real-world scenario where a developer makes changes to a code repository, triggering a build that fails during the compile step. Traditionally, this would require manually navigating to the CI/CD platform, examining logs, identifying the root cause, and then returning to the code editor to implement fixes. With the Kiro-Harness integration, this entire workflow becomes streamlined and intelligent.

The developer simply configures the Harness MCP server within Kiro, providing access to all Harness tools through standardized protocols. Using natural language, they can ask Kiro to list all pipelines in their organization. Behind the scenes, Kiro calls the appropriate Harness API through the MCP server, retrieving and presenting pipeline information in a conversational format.

When investigating a specific pipeline with build and deploy failures, the developer can request a detailed description directly through Kiro. The AI agent automatically calls the GET pipeline tool, providing a comprehensive breakdown that immediately surfaces the last execution status. Upon discovering the failure, the developer can simply ask, "Why did the last execution fail?".

Kiro then orchestrates a sophisticated investigation process: it retrieves the last execution details using the get execution tool, downloads the complete execution logs, analyzes them for error patterns, and presents a clear diagnosis. 

In the demonstrated use case, the AI identified that the pipeline failed in the compile step due to an incorrect package name: a simple typo where "platformm" should have been "platform".

Most remarkably, Kiro doesn't just identify the issue…it takes action. The AI agent can directly modify the problematic file, correcting the package.json entry with the proper package name. The developer can then review the change, commit it, and push upstream, with the confidence that the pipeline will succeed on the next run.

Expanding Use Cases for Streamlined DevOps

Beyond basic troubleshooting, the Kiro-Harness integration unlocks numerous advanced use cases that transform how development teams interact with their CI/CD infrastructure.

Pipeline Creation and Optimization: Developers can describe their deployment intent in natural language within Kiro, and the integration will generate enterprise-grade pipelines that automatically adhere to organizational policies and standards. This eliminates the learning curve for new team members and ensures consistency across projects.

Proactive Issue Detection: The integration leverages Harness's AI-powered continuous verification capabilities to detect anomalies in deployment metrics and logs. When issues are identified, Kiro can automatically suggest code-level fixes or configuration changes, creating a feedback loop between production monitoring and development practices.

Security and Compliance Automation: Real-time vulnerability detection and remediation become seamlessly integrated into the development workflow. Kiro can automatically generate security fixes as pull requests, ensuring that security doesn't become a bottleneck in the development process while maintaining compliance with organizational standards.

Conclusion

The integration of Amazon Kiro and Harness represents a fundamental shift in how developers interact with their CI/CD process. By bringing the full power of Harness's DevOps intelligence directly into the development environment, this collaboration eliminates the traditional barriers between coding and deployment operations. As the software industry continues to accelerate, such intelligent integrations will become essential for maintaining both development velocity and DevOps excellence.

Read more: Effective strategies to optimize your Amazon Cloud Services costs

Also learn about Eight deployment model frameworks to enhance your CI/CD

The widespread adoption of AI coding assistants is transforming software engineering. According to our recently published State of AI in Software Engineering report, 63% of organizations now ship code faster, and nearly three-quarters of developers say AI is already “part of the engine,” not just a sidecar.

But this acceleration has uncovered a critical bottleneck. While AI-powered tools supercharge code creation, downstream processes, such as testing, security, deployment, and compliance, still rely on manual workflows and fragmented point solutions. The result is the AI Velocity Paradox: teams move code faster than ever, but they risk shipping unverified, insecure, and unreliable software into production.

Key Trends and Challenges

• Tool Proliferation and Complexity: The average team juggles eight to ten AI tools, lengthening onboarding and increasing context switching.
• Uneven Automation: Only 51% of coding workflows are automated, dropping to 43% for CI/build pipelines and 6% for continuous delivery, leaving most CD processes manual and brittle.
• Security and Quality Risks: 45% of deployments involving AI-generated code cause problems, and nearly half of teams worry about increased vulnerabilities and compliance risks.
• Cost Spiral: 70% of organizations fear AI will drive up cloud spend as inefficient code is easier than ever to deploy.
• Manual Cleanup: Any speed gains in coding are often offset by increased manual downstream work, especially in QA, security, and incident response.

Most organizations find themselves in the “Danger Zone”: high AI adoption for coding, but low automation and intelligence downstream. This creates a fragile, high-risk environment where velocity is a mirage, and technical debt compounds.

Becoming a Velocity Leader

Velocity Leaders, i.e., organizations that have automated and instrumented their entire software delivery lifecycle with AI, aren’t just fast; they’re resilient. They use AI not just for coding, but for testing, security, deployment, and observability. This end-to-end approach transforms AI from a productivity boost into a true competitive advantage.

How Harness Bridges the Gap

Harness is built for the era of AI-driven software delivery and specifically to help organizations escape the AI Velocity Paradox.

• Intelligent Automation, End-to-End: 83% survey participants say that AI must extend across the entire software delivery lifecycle to unlock its full potential. That’s why we built Harness to extend AI beyond code creation. That’s why we built Harness to extend AI beyond code creation. Its AI platform automates building, testing, securing, deploying, and optimizing software, applying agentic AI to every phase after code is written.‍
• Consolidation, Not Sprawl: Instead of stitching together dozens of point tools, Harness delivers a unified platform, simplifying governance, reducing onboarding time, and eliminating manual handoffs that slow delivery and create risk.‍
• Automated Governance and Guardrails: Only 41% of the survey participants are confident that their current governance process can reliably catch issues before release.Harness enables organizations to define, enforce, and audit policies across the entire SDLC. This reduces the risk of bad code reaching production, prevents cost overruns, and ensures compliance automatically.‍
• Proactive Observability and Incident Response: Harness AI agents analyze observability data, detect anomalies, and automatically roll back problematic deployments. This reduces the mean time to resolution and eliminates release “war rooms”.‍
• Feature Flags and Progressive Delivery: Built-in feature management and experimentation lets teams safely roll out and roll back changes, minimizing the blast radius of any failed deployment, especially critical as AI-generated code becomes more common.‍
• Cloud Cost Optimization: Harness monitors and optimizes cloud spend in real time, preventing runaway costs from inefficient AI-generated deployments.‍
• Developer Experience: By automating repetitive tasks and reducing toil, Harness lets developers focus on innovation and not just cleanup and maintenance tasks.

Conclusion

AI-powered coding is table stakes. But true velocity comes from unifying speed with safety and resilience across the entire software delivery lifecycle. Harness brings intelligent automation to the critical, often overlooked phases of delivery, turning the AI Velocity Paradox into a sustainable advantage. Organizations that embrace a platform approach - where AI powers everything after code - will be the Velocity Leaders of the next decade.

Here’s a quote from the report:

“Purpose-built platforms that automate the end-to-end SDLC will be far more valuable than solutions that target just one specific task in the future.”
— 81% of engineering leaders surveyed

Harness doesn’t just help you move fast. It helps you move fast and not break things.

Learn more about the State of AI in Software Engineering.

Explore more resources: 3 Ways to Optimize Software Delivery and Operational Efficiency

This year at Unscripted 2025, the energy has been unmistakable as we’ve visited cities across the United States and Europe. The conversations in the hallways and on stage all pointed to a single, powerful truth: AI is fundamentally reshaping how we build and deliver software. We’ve all seen the explosion of AI-powered coding assistants that accelerate writing code. But a massive bottleneck remains. Getting that code from a developer’s laptop to a happy customer in production is still a complex, high-friction process.

Coding has sped up, but software delivery hasn't.

At Harness, our vision for AI extends beyond coding. AI needs to be applied to the entire software delivery lifecycle: automating toil, eliminating risk, and freeing engineers to solve the problems that matter. 

Today, we’re excited to share a preview of the next wave of Harness AI capabilities revealed at Unscripted, which will make autonomous software delivery a reality.

Reclaim Developer Productivity: Intent-driven Code Maintenance

Nothing drains developer productivity like codebase maintenance. The endless cycle of dependency upgrades, bug fixes, refactoring, and paying down technical debt is tedious, error-prone work that pulls engineers away from building new features.

Harness Autonomous Code Maintenance (ACM) turns these manual chores into automated, intent-driven workflows. Developers can now state their intent in plain English, with prompts like, "Upgrade the front end from React 15.6 to 16.4". From there, the Harness AI agent drives the workflow: branching, coding, testing, and working iteratively with the engineer until it delivers a build that not just compiles, but runs through your pipelines passing security and functional testing as well. While the AI is doing the heavy lifting, developers are always in the loop and in control.

Some other use cases that Autonomous Code Maintenance supports are 

• Cleaning up stale feature flags: Stale feature flags often result in dead code paths, bugs, and thus, high tech debt. ACM detects these stale feature flags, removes the references, and opens pull requests for developers to approve. This helps achieve safer experiments with faster feedback.
• Self-healing CI build failures with AI Autofix: If a build failure happens after a developer opens a pull request, Harness AI analyzes the issue, generates a potential fix, creates a new branch, and submits a pull request with the suggested remediation. This process is repeated until the build is successful, thus dramatically reducing the mean time to resolution (MTTR) for build failures.
• Improving unit test coverage: For every pull request, the CI process tries to improve the unit test coverage by creating new unit tests and then also verifying them iteratively.

Ship with Confidence: AI Verification and Rollback

Our first AI/ML capability, Continuous Verification, made Harness the first Continuous Delivery tool to understand observability telemetry and trigger rollbacks when deployments caused trouble. We knew we could do more to eliminate the friction involved in its setup. Deploying with confidence shouldn't require a coordination meeting between DevOps, SREs, and developers just to configure the right health checks.

That’s why we’re introducing the next generation: AI Verification and Rollback.

We’ve moved beyond just AI-powered analysis to AI-powered setup. The Harness AI Agent now bridges the knowledge gap between application and SRE teams. It autonomously connects to your observability platforms, discovers the relevant metrics and log queries for the service you're deploying, and builds a comprehensive health verification profile. If it detects a problem, it triggers an automatic rollback to the last known good version, providing the ultimate safety net. This eliminates the trade-off between speed and safety, making verification a zero-effort, default part of every deployment.

Embedding Intelligence Everywhere: From Portal to Production

AI assistance needs to be at every stage of the software delivery process, providing contextual help and proactive solutions.

• Pipeline Creation with “Architect Mode”: A few months ago, we showed how teams can create DevOps workflows that comply with your organization’s standards. We’re now taking that capability a step further with Architect Mode. Many software engineers are experts in application code but not in the nuances of creating a production-ready delivery pipeline. Architect Mode acts as a seasoned DevOps expert, engaging the user in a conversation to design a pipeline that incorporates organizational best practices for security, quality, and compliance from the very beginning. It’s like having a personal DevOps architect as a partner.

• IDP Knowledge Agent: We're making Internal Developer Platforms (IDPs) more accessible with a natural language assistant. Developers can ask questions like, "What are the failing checks for my service's scorecard?" or "Who is the owner of a service?" to find metadata instantly. The agent also bridges the gap to action by suggesting and executing self-service workflows, like creating a new repo or onboarding a new engineer. It can even assist in generating new workflows, turning complex processes into simple conversational tasks.

• Release Orchestration: For organizations managing complex release trains, especially in regulated industries, Harness Release Orchestration provides the governance and visibility needed to deliver with confidence. And with AI-powered assistance, you can even model new release processes using natural language, which Harness then translates into structured YAML.

The Future is Autonomous

These are just a few of the new capabilities we’re rolling out. Want to learn more? Join us at the Unscripted 2025 Virtual Conference.

Software development has changed forever. With AI-assisted coding, features that once took weeks can be written in hours. But generating the code is only the beginning. Testing, securing, deploying, and optimizing software remain the real bottlenecks. These steps determine whether innovation reaches customers quickly and reliably. According to the 2024 DORA report, software delivery stability and throughput have gone down significantly.

Harness AI is engineered to eliminate these bottlenecks.

Starting today, Harness AI is generally available (GA) for all Harness customers. Harness AI is the platform for everything after code, combining intelligence and automation to make software delivery faster, safer, and more efficient than ever before.

But Harness AI is more than a solution for today’s delivery challenges; it’s the foundation for the next generation of software delivery - a generation that delivers software not just for today’s applications but also for AI-powered applications with the same speed, reliability, and security.

A Vision for Software Delivery in the AI Era

AI has transformed how code is written, but software delivery remains stuck in the past. Only a small fraction of engineering time is spent coding. The rest is eaten up by repetitive, time-consuming tasks: managing pipelines, maintaining tests, running security scans, tracking deployments, and analyzing costs.

Even when AI is applied to these later stages, it often makes things worse. Different tools handle different parts of the lifecycle, creating tool sprawl without shared context. Pipelines become fragile, policy enforcement becomes inconsistent, and production failures become more frequent.

In a recent Harness survey, we found that nearly 80% of SDLC failures occur after coding, with CI/CD as the most common breaking point. The result isn’t just instability. It’s burnout. Developers are stuck balancing speed with safety, and the tools meant to help are often part of the problem.

Harness AI is here to change that.

We believe every stage after code – DevOps, AppSec, Testing, and FinOps – should be just as fast, intelligent, and automated as modern code generation. That’s the next frontier of software delivery.

Harness AI delivers on this vision by unifying intelligence across the entire delivery lifecycle. It transforms software delivery from a fragmented, failure-prone pipeline into a single, cohesive, adaptive system - built for scale, speed, and trust.

Not Just Features: A Unified Platform

Harness has spent the last eight years pushing the boundaries of AI in software delivery, from pioneering innovations like Continuous Verification to introducing Test Intelligence. With Harness AI, we’re extending that leadership by delivering a truly unified AI platform that brings intelligence to every step after code.

Users typically interact with Harness AI through a simple chat interface. Behind the scenes, a network of intelligent agents handles the heavy lifting. These agents—specialized in DevOps, SRE, Release, AppSec, Test, and FinOps—work together silently to deliver faster, safer, and more automated software delivery. You don’t see them, but you feel their impact across every workflow.

Imagine a world where:

• Pipelines are created in seconds: Simply describe your intent in natural language, and Harness AI builds and deploys enterprise-grade pipelines that adhere to your organization’s policies and standards, without manual intervention.

• Testing is automated, adaptive, and resilient: No more fragile scripts or manual rework. Harness AI intelligently creates, updates, and maintains tests and chaos experiments, dramatically reducing maintenance overhead and risk.

• Security and compliance are embedded, not bolted on: Vulnerabilities are detected and remediated in real time, with all changes tracked, so you can trust your software supply chain at every stage.

• Cloud spend is optimized in real time: Get actionable insights into cost anomalies and recommendations for savings, so your innovation doesn’t come with runaway cloud bills.

This is the power of Harness AI. These are not just promises. They are measurable outcomes that mean faster time-to-market, lower risk, and a team that can focus on innovation.

With Harness AI, enterprises have already seen:

• Test cycle times reduced by 80%
• Downtime slashed by over 50%
• Test maintenance effort cut by 70%
• 50% reduction in pipeline debugging time

The Software Delivery Knowledge Graph: Context That Powers Intelligence

At the heart of Harness AI is the Software Delivery Knowledge Graph—a continuously updated intelligence layer that brings full context to how your organization delivers software.

It captures and connects data from every stage of the SDLC: builds, tests, deployments, incidents, infrastructure changes, and cloud spend. This allows Harness AI to automate tasks, surface better insights, and make decisions that reflect your unique environment.

The knowledge graph pulls from both Harness and your existing DevOps tools, mapping relationships across people, pipelines, services, incidents, and policies. It’s how Harness AI understands not just what’s happening—but why.

Security and privacy are built in. Your data remains isolated and is never used to train shared models. Every insight and recommendation is generated using your own context, making Harness AI more precise, more secure, and more aligned with your standards.

The knowledge graph powers the AI agents across Harness—enabling everything from pipeline generation and one-click rollbacks to cost anomaly detection and automated root-cause analysis.

In short, the Software Delivery Knowledge Graph:

• Understands your environments, builds, deployments, and policies
  
• Reflects the security posture of your applications and infrastructure
  
• Ensures your data is used responsibly to deliver safer, smarter automation
  

This is what makes Harness AI truly intelligent—software delivery decisions grounded in your reality, not someone else’s.

Built With the Best

Harness AI is developed in close collaboration with Anthropic, OpenAI, Google Gemini, AWS, Windsurf, and Cursor. These partnerships ensure our AI is not just cutting-edge but deeply embedded into the developer workflow—whether you’re coding, testing, or monitoring production.

Available Now

Software delivery has been a bottleneck for too long. With Harness AI, we’re removing the friction, reducing the risk, and allowing teams to innovate without compromise. This is the future of software delivery, and it starts today.

Harness AI is here, and it’s already transforming how teams deliver software.

Join us at Harness Unscripted on September 30th to see Harness AI in action.

Checkout Harness AI Code Agent

AI-assisted coding tools have dramatically increased the speed and quantity of code generation, yet software delivery remains a key bottleneck. While AI accelerates development, the real challenge lies in integrating, validating, and deploying code reliably. Without end-to-end automation, from code creation through delivery, the true impact of AI-generated code is delayed, highlighting the need for platforms that streamline the entire software lifecycle. That’s the problem we’re solving every day while building Harness AI.

That is why, today, we’re thrilled to announce that Harness AI’s code agent has climbed to #4 on the SWE‑Bench Verified leaderboard, one of the most rigorous benchmarks for autonomous software engineering, taking us one step closer to building AI that is designed for everything after code generation.

What is SWE‑bench Verified?

SWE-bench is a benchmark for evaluating LLMs on real-world software issues collected from GitHub. SWE-bench Verified is its human-validated version. It tests AI’s real-world agentic coding skills, the kind required for coding tools like Cursor or Claude Code. Here’s the actual scenario:

500 real GitHub issues across production-grade Python repos. No hints. No scaffolding. Just raw code, and a single attempt.

To solve a task, an agent must:

• Understand the repository
• Apply a working code fix
• And validate it autonomously

Harness AI did exactly that, and it did it better than almost every other AI out there! 

‍

Engineering Harness AI

At the heart of Harness AI is a clean, modular architecture that mimics how real developers work, but with the speed and precision of AI.

Claude 4 Sonnet (Thinking)

We use Claude 4 in Thinking Mode, letting it reason deeply, generate step-by-step strategies, and revise plans on the fly. Unlike traditional prompting, “Thinking Mode” creates an internal monologue (a scratchpad), where the agent can brainstorm ideas, evaluate outcomes, and course-correct before taking action. This drastically reduces hallucinations and brittle plans.

Multi-Agent System

1. Build & Test Agent
   
   • The unsung hero. Before writing a single line of code, this agent explores the repo to identify the right build and test commands, intelligently reading READMEs, CI configurations, and scripts.
   • This ensures the agent never hallucinates test commands, and only validates fixes against real test suites that actually run.
2. Fixing Agent
   
   • Dynamically plans, edits, and validates fixes using real-time feedback.
   • It never guesses, it adapts. If a test fails, it reflects and replans using the sequential thinking tool, and Claude 4 Sonnet (Thinking)
     
     

Tools Used Under the Hood

SWE‑Bench doesn’t require fancy or complex tools. In most cases, simple file editing, shell execution, and structured planning are enough to solve tasks effectively.

‍

All tool usage is guarded with better error handling, intelligent fallbacks, and timeouts. If a tool fails (e.g., a test command hangs or a grep query returns nothing), the agent doesn’t break; it adapts.

This Is More Than Being on the Leaderboard

While we are proud of the results, we see it more as a signal. AI agents are no longer limited to toy coding problems or compiler tricks. They can now read real codebases, understand architecture, fix bugs, and prove it works.

We built Harness AI to tackle SWE‑Bench with precision, using just a few well-defined tools and sub-agents. That’s all the benchmark needed.

But enterprise-grade engineering problems go far beyond that. In real-world environments, AI agents must reason across systems, interact with external services, and collaborate with developers in dynamic workflows. That’s where Harness AI truly excels, with a scalable architecture, intelligent sub-agents, and advanced tools built for the complexity of modern software delivery.

Lookout for more such awesome work from our engineering team. Speaking about the team, special shoutout to the team that made this happen
Srikar Mannepalli
‍Himanshu Agrawal
‍Hang Zhang ‍
‍Harshit Mahajan
‍Vistaar Juneja
‍‍Raj Patel
‍Gurashish Brar

Learn more about Harness AI’s capabilities across the SDLC.

‍

Addressing vulnerabilities at each stage of the software delivery process is essential to prevent security issues from escalating into active threats. For DevOps and security teams, minimising time-to-remediation (TTR) is critical to delivering more secure applications without degrading velocity. With Harness’s Security Testing Orchestration (STO) module, teams can quickly identify and assess application security risks. At the same time, remediation often becomes a delivery bottleneck due to the time, expertise, and coordination needed to fix vulnerabilities.

With Harness AI integrated into STO, the remediation process advances significantly. Harness AI leverages generative AI to provide effective remediation guidance, reduce developer toil, manage security backlogs, address critical vulnerabilities, and even allow teams to make direct code suggestions or create pull requests from STO. This approach improves TTR and enhances security responsiveness throughout the software lifecycle without compromising speed.

How does Harness AI remediation LLM work?

Security scans for container images, code repositories, and IaC can be initiated by triggering the configured pipelines through automation based on events or on a set schedule, and you do not need to make any changes to your pipeline to use Harness AI. Once scans are complete, Harness AI in STO integrates seamlessly with the scan results for analyzing and providing a clear, context-driven remediation for vulnerabilities identified throughout the software delivery lifecycle. Here's what the complete process looks like.

The results from each successful scan—detailing specific security issues—are examined and processed to generate a structured prompt. This prompt is then passed to Harness ML infrastructure, invoking the LLM APIs built on top of foundational LLMs from Google & OpenAI. Also, Harness allows developers to raise pull requests and make code suggestions directly to the source code from STO.

The following sections dive into specific aspects of this workflow, detailing how Harness AI processes scan data and delivers targeted remediation guidance.

Model inputs for vulnerability processing

Effective interactions with LLMs rely heavily on prompt quality. For LLMs to generate precise, contextually accurate responses, they must receive well-structured, comprehensive prompts that cover all relevant details of the task. In the context of security vulnerability remediation, a high-quality prompt ensures that LLMs can interpret the issue accurately and provide actionable, reliable solutions that align with the needs.

In Harness STO, the prompt creation process involves gathering and structuring detailed data from each scan. For every identified security issue, STO collects key information, including 

1. Vulnerable code snippet
2. Vulnerability details
3. Scanner-suggested remediation

Also, when scanner results lack remediation steps or specific vulnerable code snippets, STO attempts to locate the vulnerable code using contextual clues provided by the scanner, such as file names, line numbers, or other indicators, it will then retrieve the relevant code snippet from the source code (to which it has access) and incorporates this into the prompt, ensuring our AI has all the information it needs to provide appropriate fixes. All this information is formatted into a structured prompt and sent to the Harness ML infrastructure for magic to happen.

After generation, the LLM’s response is standardised for display within the STO scan results, providing developers with consistent and relevant remediation insights across various scan types and stages of the software delivery lifecycle.

Model response with structured output

The remediation suggestions generated by the LLM are carefully structured and presented in a clear, user-friendly format with detailed, actionable steps. For greater contextualisation and accuracy, these suggestions can also be edited and reprocessed. Importantly, the AI-generated code suggestions maintain the code's functionality and do not impact the behavior.

Given the variety of scanners that Harness AI integrates with, a consistent format for remediation output is essential. This standardised structure ensures that AI-generated guidance is easy to interpret and apply. 

Harness AI delivers each response in a standardised format, which may vary based on the issue processed and the LLM response, this includes: 

1. Vulnerable code snippet
2. Vulnerability description
3. Remediation concepts
4. Steps to remediation with examples
5. Suggested code changes

Auto Create Pull Requests and Code Suggestions

For scan results from code repository scans–specifically, SAST and secret detection scans– Harness AI enables direct remediation at the source code. With AI-generated remediation suggestions, developers can either open a new pull request (PR) to address the issue or integrate fixes into an existing PR if it’s already in progress.

The Suggest Fix option which is for making a code suggestion, appears when the affected file matches a file modified in the open PR. This ensures that suggested changes are applied directly to the relevant code without requiring a separate PR, streamlining the remediation process.

The Create Pull Request option is available for both branch scans and PR scans. In the case of PR scans, this option is shown only if the remediation applies to files outside those already modified in the current PR. This allows you to address new or existing vulnerabilities in the base branch without altering the active PR’s changes directly.

Editable remediation and contextual customisation

To refine the AI’s recommendations, STO allows users to edit the suggested remediation. Teams can add additional context by adding code, helping the AI to understand the codebase better and to offer even more precise suggestions. Quality gates are in place to ensure that any edits remain safe, filtering out potentially harmful code and limiting inputs to safe, relevant content. Refer to our documentation for more information.

Security and Privacy measures

Security and privacy stand as a top priority for Harness, and in Harness AI, the entire process goes through security and privacy reviews, incorporating both standard and internal protocols to ensure total protection for Harness users. Additionally, we implement hard checks to safeguard against AI-specific risks, such as prompt injection attacks and hallucination exploits. This process evaluates potential risks related to security, inappropriate content, and model reliability, making sure the AI-based solutions maintain the highest standards of safety.

To further enhance our AI-driven solutions, we track anonymised telemetry data on usage by account and issue. This anonymised data allows us to make data-driven improvements without accessing or identifying specific customer information.

Learn more

To learn more about Harness STO and auto-remediation, please visit our documentation.

Software developers are the force behind the world’s innovation. They are the architects of the future, shaping how we live, work, and interact with everything around us. From the infrastructure that keeps our digital lives connected and secure to the apps we use to communicate, shop, and create, their work enables us to experience the benefits of modern technology across nearly every industry.

At Harness, our mission is to create the best possible experiences for software developers, enabling them to deliver code to end users quickly, reliably, and securely - without manual toil. By removing the friction of repetitive tasks and complex workflows, we help developers focus on what they do best—innovating at speed.

Today at {unscripted} 2024, our annual AI-Native Software Delivery conference, I’m excited to share our latest product innovations, including how we are embedding AI deeper into the core of our platform. With nine brand-new or significantly updated products, and hundreds of additional enhancements, we’ve made significant progress toward our goal of building the world’s most comprehensive software delivery platform.

The momentum of today’s announcements builds on our incredible progress over the last year. More than 900 customers are using the Harness AI-Native Software Delivery Platform and making real progress in their modernization initiatives, getting more work done faster, seeing tangible gains in their business, and vastly improving their developer experience. 

Thank you to our customers for your support, trust, and partnership. We are incredibly proud to have the opportunity to work with some of the most innovative companies on the planet, and we are inspired by the results they have achieved with Harness. These success stories represent just a glimpse of the meaningful impact our platform delivers across so many industries: 

• Ulta Beauty increased deployment volume by 50x using Harness CI/CD, allowing developers to focus on strategic projects.
• United Airlines improved the development efficiency of 3,000 engineers, cutting build times by 17 minutes per build with Harness CI Test Intelligence.
• Citibank transformed its software delivery for 20,000 engineers, reducing release times from days to just 7 minutes.
• Experian increased deployments from 2x to 100x per month for 3,000+ product managers and software engineers using Feature Flags and Experimentation.

And that’s just to name a few!

Our commitment to innovation has never been stronger. We have systematically built out our platform to transform your DevOps modernization journey and developer experience. Our engineering velocity has never been higher—today, it’s 27% faster than it was a year ago, allowing us to deliver more powerful features and improvements that accelerate your development process and enhance your productivity.

Over the last year, we added five new modules, shipped 11,000 new features and enhancements, and made the game-changing acquisition of Split Software — boosting our capabilities in feature management and experimentation. And for the first time, Harness was named a leader in the Gartner Magic Quadrant for DevOps Platforms, citing our pace of innovation as one of the key strengths. And those are just a few of the highlights! 

The new products we’re announcing today mark the next chapter in our vision for the future of AI-native software delivery. Below is an overview of what’s new. We invite you to be the first to experience these innovations by signing up for early access. I am excited for you to dive in and see what is possible!

– Jyoti

‍

AI-Native DevOps 

Our vision is a multi-agent architecture embedded directly into the fabric of the Harness Platform.  We are building a powerful library of ‘assistants’ designed to make software delivery faster, more efficient, and more enjoyable for developers. These AI-powered agents work seamlessly within our platform, handling everything from automating complex tasks to providing real-time insights, freeing developers to focus on what they do best: creating innovative solutions to some of the most challenging problems with software.

Today, we are announcing our first three AI Assistants and an enhanced offering to measure and assess the productivity impact of AI. 

• Harness AI DevOps Assistant: With the explosion of developer tools, integrations, and cloud offerings, DevOps teams are stretched to keep up with the basics, let alone refine their pipelines. Teams are eager to hand over manual, repetitive tasks to AI and focus on value-added, innovation-led projects. The Harness AI DevOps Assistant helps developers keep up with routine DevOps tasks like pipeline generation, diagnosing common sources of pipeline failure, and repairing issues in your pipeline. It recommends enhancements to existing pipelines to make them faster and more robust. Learn more about AI Agents. 

• Harness AI QA Assistant: Comprehensive, automated testing provides a critical safety net for application teams who are releasing quickly. However, building and maintaining the functional test suites that validate good customer experience is notoriously labor intensive. The Harness AI QA Assistant simplifies end-to-end test automation and accelerates migration from manual to automated testing. It enhances test creation speed by up to 80% and reduces maintenance by the same margin, ensuring high-quality applications are delivered with confidence.
  ‍Learn more about AI Agents

• Harness AI Code Assistant: Developers often spend time writing repetitive code, finding issues in code, looking for things in their code base, converting their ideas into actual code, and doing repetitive tasks such as summarizing pull requests. All of this toil is time that developers do not spend actually writing code. The Harness AI Code Assistant recommends code snippets and auto-generates entire functions, unit tests, and comments. It also includes an intuitive chatbot that can quickly answer questions and search code with natural language.
  ‍Learn more about AI agents

• Harness AI Productivity Insights: AI Code Assistants are growing in popularity, but engineering leaders struggle to understand how to validate, optimize, and monitor the impact and progress they get from these investments. Harness AI Productivity Insights helps organizations measure and optimize the impact of AI Code Assistants on developers by providing accurate metrics and data to enable intelligent decision-making for organizational investments.
  ‍Learn more about Harness AI Productivity Insights

Comprehensive Software Delivery 

Our goal is to build the most comprehensive end-to-end software delivery platform in the world. That means providing you and your teams with the tools to accelerate your entire software development lifecycle. Our platform delivers a unified experience that supports everything from developer onboarding to coding, deployment, security, measurement, and everything in between. 

Today, we are excited to build this foundation with powerful new products and capabilities designed to streamline your processes, tackle the challenges you face, and unleash the full potential of your software development teams.

• Harness Cloud Development Environments (CDEs): Developers often face challenges with local environments, including significant time spent on setup and maintenance, security vulnerabilities, and performance issues. This not only hampers productivity but also risks code security, leading to a frustrating experience. Harness Cloud Development Environments are ready-to-use cloud-hosted environments that can be quickly spun up at the click of a button. Each environment is pre-configured with everything a developer needs to start writing code, including dependencies, tools, and source code, and connects directly to their preferred IDE.
  ‍Learn more about Harness Cloud Development Environments 

• Harness Artifact Registry: Tooling for artifact registries isn’t new, yet critical challenges persist. Developers continue to waste valuable time manually managing artifacts across multiple systems instead of innovating. Our modern Artifact Registry accelerates builds with universal package management and end-to-end artifact governance that automatically integrates with Harness Continuous Integration and Continuous Delivery products, and is designed for scale of some of the most demanding enterprise software engineering organizations.
  ‍Learn more about Database DevOps

• Harness Database DevOps: Many companies ship updates several times a day, but those deployments often get stalled the instant a database change is needed because they often rely on manual processes, which are slow and error-prone. Harness Database DevOps simplifies the deployment, management, and governance of database changes that integrate seamlessly into the CI/CD pipeline while increasing visibility into database changes across environments and automating policy enforcement for database changes.
  Learn more about Harness Database DevOps

• Harness Supply Chain Security: Modern software supply chains are highly complex, distributed, and challenging to secure. In fact, by 2025, almost 50% of organizations will have experienced a software supply chain attack. Harness Supply Chain Security provides CI/CD security posture management and offers a feature-rich solution for continuous supply chain governance, risk, and compliance. Learn more about Harness Supply Chain Security

Commitment to Open Source 

Renowned organizations like Citibank, United Airlines, Choice Hotels, and Ancestry rely on Harness to expedite their software development life cycle and enhance their development experiences. We’re excited to extend the benefits of our platform to all software organizations, regardless of size or budget, and continue our commitment to open source.

• Harness Open Source: Developers have to learn, maintain, and juggle multiple tools to develop, build, store artifacts, and ship their code. Currently, no solution offers all the tools required for this process in one place. Harness Open Source is an end-to-end open-source software delivery platform that developers can use to code, build, manage artifacts, and deploy software from one centralized place. Harness Open Source includes Harness flagship products: Continuous Integration (CI), Continuous Delivery (CD), and Code Repository as well as our new Artifact Registry and Cloud Development Environments (CDE) offerings.
  ‍Learn more about Harness Open Source

Visit harness.io for more information on these new capabilities and experience the power of our platform firsthand!