Get Ship Done: Everything We Shipped in July 2026 | Harness Blog

Harness shipped 71 features in July, about one every 10 hours. That's more than June's 62, and the surge lines up with what AI is doing to the rest of the SDLC: coding agents are writing more of the code, test agents are now generating and running more of the tests by default, and every stage downstream: deployment, security, cost, and resilience has to absorb that pace without falling over.

This month's list runs from a canary strategy for Kubernetes to a test execution engine that's agentic by default to an AI bill of materials tracking components nobody was cataloging six months ago, and on top of all of it, Harness extended the entire platform to cover how agents themselves get built and shipped. Here's everything we shipped.

This month's biggest ships

Harness Agent DLC: We extended our platform to cover the full agent lifecycle, build, test, store, deploy, operate, and govern, so teams ship AI agents through the same pipelines, policies, and audit trails they already use for every other service.

One command line for humans and agents: Harness CLI is a single binary, with one command grammar and one auth flow across pipelines, CD, Harness Code, Artifact Registry, Infrastructure as Code Management, feature flags, governance, and audit. It's now in public beta, and it's built to be driven by an AI agent as reliably as by a person typing at a terminal.

AI DLC Insights starts tying AI spend to outcomes: New session-level insights, PR and work-item attribution, and multi-layer developer identity resolution let engineering leaders see which developer, which AI agent, and which token spend produced which shipped work, with Cursor now joining Claude Code and GitHub Copilot as a supported source.

‍

Here are the details:

Agent DLC brings the SDLC to AI agents

Agents don't behave like regular software: the same input can produce a different output twice, because the model underneath is deciding how to complete the task instead of running fixed code. That breaks the build-test-deploy playbook that took a decade to get right for applications. Harness Agent DLC extends the same platform used for services today to build, test, store, deploy, operate, and govern AI agents too, so a team doesn't need a separate toolchain just because the thing they're shipping is an agent instead of a service. Agents get built the same way services do, through Harness Continuous Integration, but testing needed new tools: Harness AI Evals scores agent output for correctness, performance, and safety and can gate a CD pipeline on the result, while AI Test Automation validates an agent through its actual chat interface using plain-English assertions instead of API hooks.

Everything downstream got the same treatment. Harness Artifact Registry now tracks the definitions, prompts, skills, MCP servers, models, and policies an agent is built from, with full version history. Agent Deployments extends Continuous Delivery's canary releases and approval gates to managed runtimes like Amazon Bedrock AgentCore and Google's Agent Runtime, governed by the same OPA policies as any other deployment. Cloud and AI Cost Management now attributes spend to individual agents and models, and a new AI Configs capability lets teams change prompts and models at runtime through the same feature flag infrastructure, with instant rollback. On governance, a new AI Asset Catalog auto-discovers and assigns owners to every agent, skill, and plugin, and security runs through the whole lifecycle: Primitive Scanning and an extended AI Bill of Materials catch risk before an agent ships, Harness AI Testing probes for adversarial behavior across the OWASP Top 10 for LLMs, and Agent Discovery, Posture Management, and a new AI Firewall watch agents once they're live. A new AgentTrace layer captures execution at the run and session level across all of it, and Harness is open-sourcing its foundational SDKs, harness-sdk and harness-evals, so teams can use the same tracing and eval primitives outside Harness. Learn more about Harness Agent DLC.

One CLI for humans and agents

Harness CLI 3.0 is now in public beta, and it replaces every per-module CLI Harness has shipped with one binary, one command grammar, and one auth flow. Every command follows the same shape, a verb, a noun, and an identifier, across pipelines, CD, Harness Code, Artifact Registry, Infrastructure as Code Management, feature flags, governance, and audit, so learning one command teaches you all of them. That consistency matters as much for AI agents as for people: the CLI exposes a closed, enumerable grammar and structured output in table, JSON, CSV, and several other formats, so an agent can predict what a command will return and chain it into a workflow instead of guessing at the shape of the output. It's fully open source under Apache 2.0. Learn more about the Harness CLI.

Worker Agents get scoped tokens, a graded marketplace, and more context

We launched Autonomous Worker Agents last month. Worker Agents running in step groups and stages now get scoped tokens instead of a broad session credential. You declare exactly which resources and verbs a stage needs, and Harness mints a token bound to that scope for the run, then discards it. Learn more about scoped tokens for Worker Agents.

Harness now offers managed LLM connectors for Anthropic and OpenAI, running on Harness Cloud through AWS Bedrock. There's no separate API key to provision or rotate: Worker Agents reach the models through the Harness LLM Gateway, and access is controlled the same way any other platform permission is.

The Worker Agent Marketplace picked up a real taxonomy. Agents now show up as Managed, Verified, or Community, so a team browsing the catalog knows whether they're installing something Harness built and supports, something a trusted partner built that's been reviewed, or something the community contributed that hasn't gone through review yet.

Harness AI Chat can now reach third-party MCP connectors directly. Attach a connector for GitHub, GitLab, Jira, or any custom MCP server, and the assistant pulls context from those systems inside the same conversation instead of you copying data back and forth between tools.

AI-SRE's root cause analysis can now factor in Worker Agent and pipeline outputs alongside its built-in investigation logic, so teams can extend what the AI Investigator reasons over with their own data sources and domain-specific logic, without waiting on a Harness release.

AI takes on more of the SDLC and starts grading its own work

AI Test Automation now runs every test through a new agentic execution engine by default. The "Create Test with AI" workflow got a matching overhaul, so generating a test and running it both go through the same agent-driven path instead of two disconnected steps.

AI DLC Insights added Cursor as a supported source, joining Claude Code and GitHub Copilot. Whichever AI coding tool a team standardizes on, or however many they mix, the same instrumentation now covers it. A new AI Session Insights view gives engineering managers session-level detail on how their developers actually use AI tools, not just adoption counts, so managers can coach specific habits instead of guessing from an aggregate percentage. PR and work-item level attribution now connects individual AI token spend to the pull request and work item it produced, and multi-layer developer identity resolution ties usage back to the right person across whichever AI coding agent they used. Together, that's the difference between knowing an org spent money on AI and knowing which developer, which agent, and which PR that money turned into.

Deployments that flex without a rewrite

Kubernetes deployments now support a dedicated canary strategy that rolls a new version out in percentage-based phases, 25%, then 50%, then 100%, while Harness holds the total pod count to a fixed budget by shifting replicas between two Deployments. Verification or approval gates sit between each phase, so a bad rollout gets caught at 25% instead of 100%. Learn more about Canary Deployments for Kubernetes.

Post-production rollback now works in bulk. From the service dashboard, you can select multiple infrastructures where a service is deployed, choose the target execution for each one, and roll them all back together instead of walking through each infrastructure one at a time.

AWS Auto Scaling Group deployments got smarter about what they touch. Redeployments now compare lifecycle hooks, scaling policies, scheduled actions, load balancers, and target groups against your configuration and update only what changed, instead of deleting and recreating the group and losing in-flight instances in the process. ASG deployments also now support MixedInstancesPolicy, letting AWS pull from multiple instance types automatically, including spot instances with automatic fallback when capacity runs short, while Harness keeps the launch template version in that policy current across deployments.

A handful of other delivery upgrades this month: the Shell Script step can now declare named identities and get an independent OIDC ID token injected for each one at runtime, so a script authenticates as the workload itself instead of through a connector; the Kubernetes cluster connector supports the client credentials OIDC grant type for machine-to-machine access, useful for clusters fronted by Microsoft Entra ID; AWS CDK steps can now run on ECS-based delegates instead of requiring a Kubernetes delegate runtime; Google Cloud Run and GKE deployments support pause and rollout control, so you can deploy without traffic, shift a percentage, validate, and gate the rest behind manual approval; monitored service configurations can now live in Git through the new Git Experience; and Kubernetes Blue Green rollbacks now automatically scale the previous stable deployment back up so traffic actually has active pods to route to.

Security and supply chain for a world of AI-generated code

Harness Supply Chain Security can now generate an AI Bill of Materials, cataloging the models, datasets, agents, frameworks, and libraries embedded in a repository the same way an SBOM catalogs open-source packages. Traditional SBOMs miss all of this. As AI components spread through codebases faster than most security teams can inventory them by hand, that gap is becoming the more urgent one. Learn more about AI Bill of Materials support.

Security Testing Orchestration now supports bulk exemption requests. Teams managing findings at scale can request exemptions for multiple vulnerabilities in a single action instead of filing one at a time. Learn more about bulk exemption requests.

Supply Chain Security now runs inside GitLab CI pipelines directly, with reusable templates for generating SBOMs, creating SLSA provenance, signing artifacts, verifying attestations, and enforcing security policies, all without leaving GitLab. Learn more about GitLab CI support for SBOM, SLSA, and artifact signing.

API Security Testing picked up three upgrades this month. The Traceable MCP Server now supports AI Security assets and issues, so teams running an AI Security proof of concept can generate a full AI Security posture report straight from a customer environment using Claude Desktop or any other MCP-compatible client. Scans also gained plugin-level visibility into execution, coverage, and performance for every API tested, and a new alerting framework lays the foundation for flexible, granular alert conditions across the platform. Learn more about generating AI Security Value Reports with the Traceable MCP Server.

The developer portal gets sharper eyes and fewer clicks

The Internal Developer Portal overview now shows each user a view tailored to their role. Developers, platform engineers, and engineering leaders see different cards by default, and platform admins configure the layout per view and assign it to the right user groups instead of shipping one generic dashboard to everyone.

OPA policy enforcement now covers every catalog entity, not just environments. Platform engineers can write Rego policies that block or warn on non-compliant entities at save time, enforcing naming conventions, ownership requirements, and lifecycle standards across the whole catalog instead of one corner of it.

Teams migrating off Backstage can now import catalog-info.yaml files directly from GitHub and Bitbucket, and the integration converts those entity definitions into the Harness IDP format automatically. No manual re-entry of everything Backstage already knew about your services.

Smaller catalog upgrades round out the month: the Kubernetes integration now supports a persistent agent mode for near real-time resource updates alongside the existing cron mode, with a new Kubernetes tab on entity detail pages showing workloads, pods, nodes, and containers; the portal now parses OpenAPI specs automatically and surfaces individual endpoints as structured metadata that external tools can enrich with risk scores or ownership tags through the Catalog Custom Properties API; the Discovered tab can bulk-select and import every service recommended for merge or registration in one click instead of one at a time; and accounts with outbound network restrictions can now route sync traffic through their own vanity URL instead of the default Harness endpoint. Learn more about routing sync traffic through your vanity URL.

Infrastructure as code adds real guardrails

Infrastructure as Code Management now includes native Ansible configuration management, bringing provisioning and configuration into one governed workflow instead of handing configuration off to a separate tool once the infrastructure exists. Learn more about native Ansible configuration management.

AWS CDK provisioning, in beta, picked up Drift and Destroy steps, a dedicated approval step, and expanded language support, closing gaps between what CDK could do standalone and what it could do inside a governed Harness pipeline. Learn more about AWS CDK Phase.

Module Registry versions were previously all treated as equally supported, with no way to flag one as outdated. A new lifecycle rule, in beta, automatically classifies each module version as Supported, Update Required, or Deprecated based on how recent it is, configurable from the Lifecycle Management tab on any module.

Cloud and AI cost management gets more precise

AI Perspectives can now drill down by Principal into Provider, Sub Provider, Sub Account ID, Model, and Token Type, so teams can trace AI spend to the specific account and model generating it instead of stopping at a vendor-level total. Learn more in the Cloud and AI Cost Management release notes.

The Overview page can now be filtered by cost category, and most tiles respect the filter (optimization tiles are the exception). The Anomalies widget on that page picked up a time series chart and a count of stale anomalies, and the Budgets widget got a clearer read on status.

Commitment Orchestration now supports Database Savings Plan purchases for RDS across the Actions, Approvals, and Inventory views, so teams can track and approve those commitments the same way they already handle other savings plans.

A few smaller fixes rounded out the month: AI chat quick actions now match whichever cost experience you're in, offering "Create a View" in Cost Explorer or "Create a Perspective" in the classic experience instead of one generic label; Cluster Orchestrator schedules show a live status badge and countdown for each schedule; and Perspectives now display clearer badges for external data sources like Snowflake, so it's obvious at a glance which numbers came from where.

Database changes ship like code, and reach further

Database DevOps pipelines can now pin a database instance to a specific git SHA instead of always tracking the latest commit on a branch, useful for teams that need a migration to run against an exact, audited version of a schema.

Database DevOps now supports Google Cloud Bigtable, so teams can manage schema changes and migrations for Bigtable workloads through the same workflows they already use for other databases. Learn more in the Database DevOps release notes.

Two reliability fixes round out the month: custom Database DevOps pipelines can now configure reserved parameters without manual encoding, and long-running Google Cloud migrations now refresh their OIDC token automatically instead of risking an authentication failure partway through.

Artifact Registry grows into more of the deployment path

Harness Artifact Registry now supports three more package types: Puppet, Debian, and a new Helm HTTP registry type that hosts and serves Helm charts through the classic helm repo add and helm pull workflow. Unlike the existing Helm OCI registry, Helm HTTP speaks the protocol most Helm repositories still use, with upstream proxy pull-through for public repos. Learn more about the new Artifact Registry package types.

Continuous Delivery can now deploy Raw File artifacts from Artifact Registry directly to WinRM targets, so a .zip package or other file stored in a Raw File registry reaches a Windows target without a third-party artifact connector in between. Learn more in the Artifact Registry release notes.

Run steps inside a containerized Step Group can now pull images straight from Harness Artifact Registry, no Docker connector required. Set the registry type to Artifact Registry, pick the registry and image, and the step runs against it natively.

Resilience testing catches more before it becomes an incident

Resilience Testing shipped a prompt library that turns the entire chaos-testing lifecycle into copy-paste prompts for Cursor, Claude Desktop, Windsurf, or any MCP-compatible client, with a builder for filling in service names, environments, and tolerance thresholds. Learn more about the Resilience Testing prompt library.

Services can now onboard with their own custom chaos service agent instead of going through discovery-based onboarding only, giving teams a second path for services that don't fit the standard discovery flow. Learn more in the Chaos Engineering release notes.

Load testing picked up several upgrades this month: tests can now be linked to a service directly from the UI, image registry support spans the frontend, backend, and DDCR so runs can pull images from your own registry; JMeter load profiles now enforce consistent user counts, duration, and ramp-up across script, zip, and custom-image modes, and both the load step and composite load stage now run through templates instead of inline configuration.

Chaos dashboards now render natively instead of through an embedded view, and pipeline scans got dedicated list, detail, and scanned-risks pages so results are reviewable directly in the UI instead of buried in a run log.

A handful of smaller onboarding and API upgrades round out the month: infrastructure type selection during service onboarding associates a service with the right infrastructure from the start; probe tuning can now inherit inputs from a linked Chaos Service instead of requiring re-entry; the Enterprise ChaosHub added ready-made Datadog health-check probe templates; a new API lists every service associated with a given probe identity; experiment YAML can reference a specific service inside a probe reference; and a redundant validation check during network map and service creation was removed.

Smaller updates that still save time

Access management got a couple of real conveniences: Resource Groups and Access Control roles can now be cloned directly from the UI, so a new role or scope starts from an existing baseline instead of from scratch. Dynamic GCP Secrets Manager references also gained project ID support, so a JEXL expression can pull a secret from a different GCP project than the one the connector lives in. Learn more about GCP Secrets Manager project ID support.

Two smaller updates rounded out July: code comments in Harness Code Repository now support emoji reactions, and Feature Management & Experimentation added a bucketingKey column to Amazon S3 impression exports, making it easier to validate consistent treatment assignment and analyze account-level rollouts.

The pattern

Seventy-one features in 31 days, about one every 10 hours! The velocity story this month isn't just that Harness shipped more. It's what got shipped: an entire lifecycle framework for building and running AI agents themselves, attribution that ties AI token spend to the pull request it produced, and a scoped-token system for the Worker Agents already running in production pipelines. AI is doing more of the actual work this month, writing tests, running them, triaging security findings, and the platform underneath it is building the guardrails and the receipts to match. June put Worker Agents into the pipeline. July gave them a permission system, gave the entire agent lifecycle a home in the same platform as everything else, and gave engineering leaders a way to see exactly what all of it is producing.

‍

We'll be back in August with more of it!

‍