Teams that adopt Amazon Bedrock Automated Reasoning checks often want to run the policy lifecycle in code. Running it in code keeps the work repeatable, reviewable, and driven by the coding agent they already use. AWS now addresses that with a suite of Agent Skills that teaches a coding agent how to build, test, deploy, and validate an Automated Reasoning policy end to end.
What Agent Skills are and why they matter here
Agent Skills are a lightweight, open format from Anthropic that extends a coding agent with specialized knowledge and workflows. According to Anthropic, a skill is a structured context package that teaches the agent how to use a specific service or domain correctly, so the agent no longer relies on general training data that may be incomplete or out of date. Each skill carries validated patterns, common mistakes to avoid, and step-by-step workflows. Because the format is open, a skill installs into any agent that supports it, including Kiro, Claude Code, Cursor, and Codex, and it activates automatically when you ask your agent about the task it covers.
For Automated Reasoning on Amazon Bedrock, that specialization matters. An Automated Reasoning check runs in two steps: a set of foundation models translates the question and answer into formal logic, mapping natural language to variables in your policy, then an SMT solver validates that logic against your rules and returns a verdict. The validation step is mathematically sound—if the translation is faithful, the verdict is correct. That soundness is also what makes the result explainable. Every verdict comes back with the specific rules that support or contradict it.
The six skills across the policy lifecycle
AWS built a suite of six Agent Skills, one for each stage of the Automated Reasoning policy lifecycle. Each skill is a short instruction file that teaches the agent the judgment for its stage, backed by small runnable scripts that call the Amazon Bedrock Automated Reasoning APIs. The skills share one reference document that describes the API surface, the finding types, and the rule syntax, so guidance stays consistent across the suite.
- Builder skill creates a policy from a source document and extracts its rules and variables.
- Reviewer skill reads the quality and fidelity reports the build produces and flags issues such as conflicting rules, unused variables, and bare assertions.
- Tester skill generates scenarios and runs question-and-answer tests that check whether the policy translates and validates real inputs the way you expect.
- Debugger skill diagnoses failures and repairs the policy, working from the principle that a wrong verdict almost always comes from a translation problem rather than the rules.
- Deployer skill snapshots a numbered policy version and attaches it to a guardrail.
- Validator skill checks answers with the ApplyGuardrail API. It can also run a rewrite loop that feeds a failing answer’s contradicting rules back to the model until the answer is sound.
Each skill follows the standard Agent Skills layout. A SKILL.md file holds the core instructions for that stage, including when the skill applies and the judgment calls specific to it. A references/ folder holds deeper material, such as the finding types and the rule syntax, that the agent loads only when it needs the detail. A scripts/ folder holds the runnable Python that calls the Amazon Bedrock Automated Reasoning APIs. The scripts are standalone and take a --help flag and a --dry-run flag, so you can read what an operation does and inspect the exact request before it reaches Amazon Bedrock.
Practical walkthrough: from policy document to verified answer
The following example runs the full lifecycle on a short human resources policy for parental leave eligibility. The steps are compact so the flow is clear, and the same pattern applies to a loan eligibility policy, an insurance coverage policy, or any other domain where answers must follow written rules.
Prerequisites
You need an AWS account with access to Amazon Bedrock in an AWS Region where Automated Reasoning checks are available, permissions for the Amazon Bedrock control plane and runtime APIs, and Python with uv to run the scripts. For feature availability by Region, refer to the Automated Reasoning checks in the Amazon Bedrock documentation.
uv is an extremely fast Python package and project manager written in Rust. According to its documentation, it is 10-100x faster than pip and replaces pip, pip-tools, pipx, poetry, pyenv, twine, and virtualenv in a single tool. For the Automated Reasoning policy lifecycle walkthrough described in this post, see the primary source. Install it with the official standalone installer or via your preferred package manager, then clone the skills repository.
Install the skills into your coding agent
In Claude Code, add the suite as a plugin marketplace and install the skills you want:
/plugin marketplace add ./amazon-bedrock-samples/responsible_ai/automated-reasoning-checks-skills
/plugin install ar-policy-builder@automated-reasoning-skills
For other agents that support the open format, such as Kiro, Cursor, and Codex, install with npx:
REPO=https://github.com/aws-samples/amazon-bedrock-samples
SUBDIR=responsible_ai/automated-reasoning-checks-skills
npx skills add $REPO/tree/main/$SUBDIR --skill '*'
Either way, a skill activates automatically when you ask your agent about the matching task, such as creating a policy from a document or debugging a failing test.
Create the policy and extract rules
Start from a short source document that states the rules in plain language, for example that full-time employees with more than 12 months of service are eligible for parental leave and part-time employees aren’t. The builder skill creates the policy resource and starts a build that extracts formal rules and a variable schema from the document:
uv run create_policy.py --name "hr-leave-policy" \
--description "Validates parental leave eligibility answers"
uv run build_from_document.py --policy-arn <policy-arn> \
--file leave-policy.txt --doc-name "Leave Policy" \
--instructions "Capture full-time status and tenure in months; focus on eligibility."
In one run, the build extracted six rules, four variables, and one custom type from three sentences of source text, including a boundary rule that keeps tenure non-negative.
Source: Agent Skills for Automated Reasoning policies in Amazon Bedrock | Artificial Intelligence
Review what the service produced
Rule extraction is not deterministic, so review the result before you test it. The reviewer skill pulls the quality report and the policy definition and summarizes them:
uv run audit_policy.py --policy-arn <policy-arn>
The audit reports the rule, variable, and type counts, then flags structural issues by severity. For this policy it noted one unused variable and one disjoint rule set, both low-severity items to consider rather than errors. It also reports that a fidelity report wasn’t produced, because a standard content build does not generate one. You request it with a separate build type when you want the source-grounding view for a subject matter expert.
Write and run a test
The tester skill creates a question-and-answer test and runs it against the completed build. A test states the question a user might ask, the answer your model might give, and the verdict you expect:
uv run create_test.py --policy-arn <policy-arn> \
--input "I'm full-time with 18 months. Am I eligible for leave?" \
--output "Yes, you are eligible for parental leave." \
--expected VALID
uv run run_tests.py --policy-arn <policy-arn>
The test workflow returns the expected and actual verdicts and whether they match. For this policy the answer validated as VALID, with the actual result matching the expected result.
Deploy behind a guardrail and validate an answer
After the policy passes its tests, the deployer skill snapshots an immutable numbered version and attaches it to a guardrail, and the validator skill checks a live answer:
uv run create_version.py --policy-arn <policy-arn>
uv run deploy_guardrail.py --policy-arn <policy-arn> \
--policy-version 1 --guardrail-name hr-leave-guardrail
uv run validate_response.py --guardrail-id <guardrail-id> --guardrail-version 1 \
--question "I'm full-time with 18 months. Am I eligible for leave?" \
--answer "Yes, you are eligible for parental leave."
The validator returns the finding and confirms that the check ran. Here the answer came back VALID with the supporting rule attached, which is the audit trail you keep for a validated response.
Source: Agent Skills for Automated Reasoning policies in Amazon Bedrock | Artificial Intelligence
Two lessons from running the suite against Amazon Bedrock
The first lesson is that explainability sits at the center of how the feature works. Every verdict returns the rules behind it—the supporting rules for a VALID answer and the contradicting rules for an INVALID one. The validator skill logs these so a validated answer ships with mathematically verifiable proof of why it was allowed, and a rejected answer carries the exact rule it broke into the rewrite step. The check returns a non-VALID verdict with the rule the answer broke, the model rewrites the answer using that rule, and the check runs again until the answer is sound.
The second lesson is that a SATISFIABLE verdict isn’t a failure. Automated Reasoning distinguishes between an answer that’s consistent with your policy and one that is entailed by it. Suppose a rule says full-time employees with sufficient tenure are eligible. An answer that asserts eligibility is consistent with the policy but not proven by it, so the service returns SATISFIABLE rather than VALID. Reading that result as a failure leads you to change rules that were correct. The debugger skill encodes this distinction so the agent interprets verdicts the way the service defines them.
A practical constraint the skills handle for you
A policy allows a limited number of concurrent build workflows, and a long refinement session can reach that limit. The skills release a slot automatically before each build by removing the oldest completed build, so an agent working through several refinements doesn’t stall on the cap.
To avoid ongoing charges, delete the resources you created in dependency order, because a policy won’t delete while its test cases, build workflows, or versions still exist. Remove the test cases first, then the build workflows and the numbered version, then the policy, and finally the guardrail. The skills follow this sequence when they tear down resources, and you can also delete everything from the Amazon Bedrock console.
Getting started
Automated Reasoning checks give you verifiable, explainable verdicts on AI answers, and the quality of those verdicts depends on the policy behind them. The Agent Skills in this post move the full authoring lifecycle into code, so building, reviewing, testing, debugging, deploying, and validating a policy become repeatable steps your coding agent can run and you can review. The approach is not limited to the parental leave example or to one agent. It applies to various policy domains, from finance to insurance to healthcare, and installs into the coding agents you already use.
To get started:
- Install the skills from the code repository into your coding agent.
- Point the builder skill at your own policy document and review the quality report.
- Add question-and-answer tests that reflect how your users ask questions, and refine until they pass.
- Deploy a versioned policy behind a guardrail and validate answers with the runtime skill.
If your team already runs policy guardrails on Amazon Bedrock, this suite turns the lifecycle from a manual console walkthrough into a repeatable, testable workflow. If you manage AI compliance in finance, insurance, or healthcare, the same pattern lets you codify rules that must never be broken and verify every answer against those rules in production.
Related coverage
For context on how Amazon Bedrock policy tooling is expanding, see Amazon Bedrock AgentCore adds temporal policies and rate limits. For a look at policy-driven AI in another domain, see How Cohere Health digitizes clinical policies using Amazon.
