Skip to main content
Glama

Argocd Patch Application

argocd_patch_application
Idempotent

Patch an Argo CD application to update its spec, such as changing targetRevision or disabling auto-sync, using a JSON merge or JSON patch body.

Instructions

Patch an application — the one tool for every update.

Examples: change targetRevision with patch='{"spec":{"source":{"targetRevision":"v2"}}}'; disable auto-sync with patch='{"spec":{"syncPolicy":{"automated":null}}}'.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
nameYesApplication name; accepts namespace/name for apps-in-any-namespace
patchYesJSON patch body
projectNoProject; with it a missing app is 404 and a wrong-project app is 403
patch_typeNomerge (RFC 7386) or json (RFC 6902)merge
app_namespaceNoOverride appNamespace; defaults to ARGOCD_APP_NAMESPACE

Output Schema

TableJSON Schema
NameRequiredDescriptionDefault
resultYes

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observedv0.1.0

TDQS

A4.2/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare destructiveHint=false and idempotentHint=true, so the safety profile is covered structurally. The examples hint at merge-patch semantics (setting 'automated': null removes the field), but that behavior is never stated, nor are permission/RBAC needs or the consequences of a failed patch. Useful but not rich beyond the structured data.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

One short scoping sentence followed by two examples — no filler, and the tool's identity is front-loaded before the illustrative detail. Every sentence carries information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With an output schema present, return values need no explanation, and the 5 parameters are fully documented in-schema. The only residual gap for a write tool with openWorldHint=true is the absence of any note on how patch conflicts or invalid JSON bodies surface, which is minor.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so the baseline is 3; the description earns an extra point by making the otherwise vague 'JSON patch body' concrete with two literal patch examples showing the expected shape. It adds nothing for name, project, patch_type or app_namespace, which the schema already documents well.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb (patch) and resource (application), then immediately positions itself as 'the one tool for every update', which distinguishes it from sibling mutators like argocd_sync_application, argocd_rollback_application and argocd_delete_application. The two inline examples make the tool's remit concrete rather than abstract.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The phrase 'the one tool for every update' plus concrete examples (bump targetRevision, disable auto-sync) tells an agent exactly what class of change belongs here rather than in the dedicated sync/rollback tools. It stops short of stating exclusions explicitly — e.g. that a full sync or rollback should use the sibling tools instead of a hand-written patch.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.