Skip to content
cccskills
FreePublished on GitHubEnglish overview

foundry-agentic-loop

Plan and build agent solutions with Microsoft Foundry, GitHub, and Azure, from hosted agents and tools to a React and FastAPI app. Choose rapid prototyping, phased spec-driven development with verification and azd deployment, or improvement based on lessons from prior runs.

OriginalShow the original description

Build agentic solutions on Microsoft Foundry, GitHub and Azure: hosted agents, toolbox tools and skills, Foundry IQ grounding and a React/FastAPI app. Three modes: rapid prototyping in an existing Foundry project; spec-driven development (SDD), where the foundry-agentic-loop-workflow runs Specify, Implement, Verify and Deploy to create the Foundry project and deploy with azd, or one phase runs alone; and Improve, which refines this skill and the workflow from past runs. Use for Agentic Loop requests and canvas actions, or end-to-end agent solutions from architecture to Azure deployment. Not for isolated Azure administration or unrelated UI edits.

github/awesome-copilot40,567 stars(GitHub 40,567 + cccskills 0)
Works withGitHubAzure

Run score Not tested

See how to install

Good for

  • Prototyping an agent in an existing Foundry project
  • Building a new solution from a written specification
  • Verifying and deploying an agent app with azd
  • Improving the workflow based on past runs

Overview

What it does

Coordinate the design and development of agent solutions using Microsoft Foundry, GitHub, and Azure. Choose rapid prototyping in an existing Foundry project, or develop a new project through the specification-driven stages Specify, Implement, Verify, and Deploy. An Improve mode uses prior runs to refine the skill or workflow. Solutions can combine hosted agents, tools and skills, knowledge grounding through Foundry IQ, and a React and FastAPI app. The SDD path includes deployment to Azure with azd.

When it helps

Use it to move from agent architecture to app implementation, verification, and Azure deployment. It also suits small experiments in an existing project or creating a new project from a specification with deployment configuration. You can use past run records to review and improve the development process.

Example requests

  • “Prototype an agent that references internal documents in our existing Foundry project.”
  • “Implement an agent app from this specification, verify it, and deploy it to Azure.”
  • “Review past run results and apply improvements to this workflow.”

Notes

Platform operations require the microsoft-foundry skill. SDD also requires the bundled workflow extension; without it, SDD cannot start. Azure operations require suitable permissions and resources. Authentication, permission grants, billing, and security-related changes follow the applicable procedures.

This overview was written by AI (OpenAI Codex) from the public SKILL.md. Check the original below for the exact behavior.

Document check

AI checked the SKILL.md for operations that need care and for setup requirements. The score comes only from actually running the skill (hands-on test).

SafetyAre sending data, deleting files, and running commands disclosed?
AGoodIt requires mode setup before workspace writes and procedures for Azure access and sensitive changes.
Easy setupDoes it need few tools or API keys, and are they documented?
BPartly lackingIt requires `microsoft-foundry`, a workflow extension, and suitable Azure access and resources.

Not counted in the score. Rated by AI (OpenAI Codex) as of Oct 26, 2026. Treat it as a guide and read the original before installing.

Disagree? Request a re-evaluation

Tell us which point is wrong and why. No login needed. We will check it against the SKILL.md, redo the evaluation, and show the result here.

This form is protected by reCAPTCHA, and the Google Privacy Policy and Terms of Service apply.

Files included (55)

  • SKILL.md12.1 KB
  • assets/agents-md-rapid.md1.1 KB
  • assets/agents-md-sdd.md1.4 KB
  • assets/deployment-plan-template.md3.0 KB
  • assets/devcontainer.json800 B
  • assets/loop-template.md1.3 KB
  • assets/spec-template.md4.0 KB
  • evals/evals.json94.0 KB
  • evals/fixtures/improve-history/.agentic-loop/runs/wr_101.json2.4 KB
  • evals/fixtures/improve-history/.agentic-loop/runs/wr_117.json2.4 KB
  • evals/fixtures/improve-history/.agentic-loop/runs/wr_123.json1.6 KB
  • evals/fixtures/improve-history/AGENTS.md1.4 KB
  • evals/fixtures/improve-history/docs/LOOP.md2.0 KB
  • evals/fixtures/rapid-locked/.azure/deployment-plan.md868 B
  • evals/fixtures/rapid-locked/.env207 B
  • evals/fixtures/rapid-locked/AGENTS.md1.2 KB
  • evals/fixtures/rapid-locked/gitignore41 B
  • evals/fixtures/rapid-locked/README.md1010 B
  • evals/fixtures/sdd-deployed/.agentic-loop/runs/wr_88.json2.6 KB
  • evals/fixtures/sdd-deployed/.azure/deployment-plan.md1.6 KB
  • evals/fixtures/sdd-deployed/AGENTS.md1.4 KB
  • evals/fixtures/sdd-deployed/docs/spec.md1.9 KB
  • evals/fixtures/sdd-deployed/docs/verify.md374 B
  • evals/fixtures/sdd-paused/.agentic-loop/runs/wr_42.json2.9 KB
  • evals/fixtures/sdd-paused/AGENTS.md1.4 KB
  • evals/fixtures/sdd-paused/docs/LOOP.md371 B
  • evals/fixtures/sdd-paused/docs/spec.md1.9 KB
  • evals/fixtures/sdd-paused/docs/verify.md322 B
  • evals/fixtures/sdd-paused/src/backend/routing.py172 B
  • evals/fixtures/sdd-paused/tests/contract/test_routing.py208 B
  • evals/fixtures/team-conventions/AGENTS.md224 B
  • references/azd-layout.md11.3 KB
  • references/build-skills-catalog.md4.8 KB
  • references/check_rbac_preflight.py18.9 KB
  • references/copilot-sdk-foundry.md16.6 KB
  • references/copilot-sdk-with-toolbox.py14.3 KB
  • references/deploy.md4.4 KB
  • references/foundry-hosted-agent.md6.0 KB
  • references/foundry-iq-grounding.md6.8 KB
  • references/foundry-models.md5.2 KB
  • references/foundry-toolbox.md5.5 KB
  • references/hosted-integration-checkpoint.md13.4 KB
  • references/implement.md5.9 KB
  • references/implementation-contract.md3.7 KB
  • references/improve.md5.0 KB
  • references/observability.md5.9 KB
  • references/rapid.md8.9 KB
  • references/rbac-contract.md9.9 KB
  • references/rbac-preflight.md10.3 KB
  • references/reference-architecture.md3.4 KB
  • references/run-skills-catalog.md3.4 KB
  • references/sdd.md11.1 KB
  • references/specify.md4.4 KB
  • references/verify.md5.3 KB
  • scripts/evals.mjs22.0 KB

SKILL.md (original)

Review the instructions the agent will receive before you install.

Foundry Agentic Loop

Coordinate the solution and use microsoft-foundry for platform operations. Explicit user choices override defaults. Reuse known context, ask only for missing decisions, read only the references a step needs, and report decisions, blockers and endpoints concisely.

Bootstrap (once per session)

  1. Foundry skill. If microsoft-foundry is unavailable, ask, then install it (copilot plugin install azure@awesome-copilot, or gh skill install microsoft/azure-skills microsoft-foundry --agent github-copilot --scope project) and reload skills.
  2. Canvas and workflow. This plugin ships foundry-agentic-loop-canvas and foundry-agentic-loop-workflow, listed as foundry-agentic-loop:<name> or <name>. Call extensions_manage with operation: "list". Never install extensions from a URL and never edit Copilot settings files. If one is listed under neither name, tell the user which is missing and that it ships with the plugin, then ask before running copilot plugin install foundry-agentic-loop@awesome-copilot; after they approve, call extensions_reload once. If one is disabled, tell the user to re-enable it in their extension settings and continue in a new session: running sessions keep it disabled, even after a reload. If one failed, inspect it and report its log. Without the canvas, continue in Chat; without the workflow, SDD cannot start, so offer rapid prototyping.
  3. Canvas. When work starts from Chat, open it once: open_canvas with canvasId: "foundry-agentic-loop-canvas", instanceId: "foundry-agentic-loop" and input: { mode }. Prompts that begin [Agentic Loop canvas action] come from the canvas; follow their target, approval and resume instructions literally.

Choose the mode

SignalMode
Root AGENTS.md has an Agentic Loop sectionIts mode. Switch only when the user confirms, then rewrite the section
Canvas prompt or explicit choiceAs stated
Existing Foundry project selected or named; fast prototype; no deployment pipeline neededRapid prototyping: rapid.md
Spec, new Foundry project, azd or IaC, CI-ready repo or full Azure deploymentSDD: sdd.md
Improve, learn from runs, or the canvas improve promptImprove: improve.md; measure changes with node scripts/evals.mjs (index, then run --base <commit>; exit 2 means evals are unavailable, so stop)
One named SDD phase, with no run activeIts guide (Specify, Implement, Verify or Deploy) with the SDD defaults

Otherwise ask once with the choices "Rapid prototyping (existing Foundry project)" and "SDD (new project, deployed with azd)".

Lock it in. Before any other workspace write (in the rapid preflight, or just before the SDD workflow starts), upsert the section from agents-md-rapid.md or agents-md-sdd.md into the root AGENTS.md: replace everything between its foundry-agentic-loop begin and end markers, or append it, keeping other content; then read it back. The section routes short commands such as deploy and locks the mode for Chat, the canvas and the workflow. Azure settings go only in .azure/deployment-plan.md, never in AGENTS.md. Improve mode never writes it.

Defaults

  • Agents: Foundry hosted agents exposing the Responses API, Python 3.13, code deployment. Create them through microsoft-foundry's foundry-agent/create/quick-start-hosted.md with the Basic sample, resolved through that skill, never a guessed URL. Use its advanced workflow only when quick-start cannot support a capability, keeping these defaults. Prompt agents only when requested.
  • Framework: the Copilot SDK for agents that use runtime skills (recipe, reference agent); Microsoft Agent Framework for basic agents and explicit workflows. If a workflow also needs skills, clarify. One framework per agent.
  • Models: rapid keeps the Basic sample's model deployment, or verifies and reuses a supplied one; SDD defaults to gpt-5.4-mini unless the spec needs otherwise. Run the joint placement preflight in foundry-models.md before creating resources. Never hard-code a replacement or silently duplicate a deployment.
  • Tools and knowledge: one governed Foundry toolbox for built-in tools, MCP connections and agent skills; agents use its endpoint, not hard-coded tool URLs. Private knowledge uses Foundry IQ through the toolbox, with citations for supported claims and a deterministic insufficient-evidence response; test both. Add Search only when needed. Reuse run skills the user names from the run catalog instead of regenerating them.
  • App: React + Vite, FastAPI and FastMCP (streamable HTTP) on Azure Container Apps. Rapid deploys with az containerapp up --name <app> --source <dir> --resource-group <rg> --environment <env>; SDD uses azd with a microsoft.foundry layer plus a Bicep (AVM) app layer, remoteBuild: true and one ACR pulled by managed identity. Add services from the reference architecture only when the solution needs them.
  • App access: decide it from the data. When everything the app shows is sample, synthetic or deliberately public, default to no end-user sign-in, even for staff users; services still authenticate with managed identities and need no anonymous-session or identity-verification workarounds. When it shows private, sensitive or user-specific data, ask for the access model before deploying and default to internal ingress or Entra sign-in; anonymous access needs explicit approval. With sign-in, the API pre-authorizes the SPA, the spec states how automated browser tests get a user token, and Implement proves that token path as soon as the app registrations exist.
  • Identity and safety: managed identities and least-privilege keyless RBAC (contract; preflight with check_rbac_preflight.py). Check management-plane, data-plane and role-assignment rights separately; subscription Owner does not grant Foundry data-plane roles. Plan roles for identities not yet created and verify actual principals after creation. No credentials in browser code or Git; Foundry guardrails on.
  • Observability: OpenTelemetry from the backend, agents, MCP servers and model calls into one Application Insights connected to the project (observability.md). Sensitive content capture stays off unless approved with redaction and retention controls.

Workspace files

FileHolds
AGENTS.md (root)The mode lock and short-command routes; never Azure settings
README.md (rapid) or docs/spec.md (SDD, from the spec template)The contract
.azure/deployment-plan.mdEvery Azure setting, in both modes (template)
.env (Git-ignored)What the canvas reads: FOUNDRY_PROJECT (full ARM ID, once validated or created), LOCAL_FRONTEND and DEPLOYED_FRONTEND (verified URLs only). Upsert, keep other keys and read back
docs/LOOP.mdLessons (template)
.agentic-loop/runs/<runId>.jsonSDD flight records, written by the workflow
.devcontainer/devcontainer.jsonOptional dev container (asset)

Working rules

  • Contract first. Freeze service names, environment variables, protocols, endpoints, schemas, auth, streaming, errors and versions (implementation-contract.md) before parallel work.
  • Integration first. Pass the hosted integration checkpoint with a minimal agent before building full orchestration, UI or backend: always a model request, plus a toolbox skill load and a safe MCP call only when the architecture needs them. Record excluded capabilities as N/A with the reason, never as passed, and never add unused ones to satisfy the checkpoint.
  • Evidence, not signals. HTTP 200, exit 0 or active never pass alone; require terminal completion, schema-valid output, execution evidence and correlated traces. Fix with bounded diagnostics, not unchanged redeployments.
  • Wait by completion. Provisioning, deployments, role-assignment propagation and agent readiness end when their command or status check says so: run the command synchronously with a long initial wait, or poll its status every 30-60 s against a stated deadline. Never chain fixed sleeps; keep coding while Azure works.
  • Subagents. Before the checkpoint, parallelize only research and preflight. After it, give each worker a bounded goal, exclusive workspace-relative files or folders, skill references, verified context, the contract, acceptance checks and stop conditions. One owner (the coordinator, or the SDD phase lead) holds the contract and the shared files: azure.yaml, infra/, docs/, .env, .azure/, .agentic-loop/, AGENTS.md and the root lockfiles. Keep teams small, avoid recursive delegation, serialize shared Azure mutations and integrate centrally; worker success is not acceptance. Delegation grants no extra approval. Without subagents, work sequentially and say so.
  • Safety. Reuse resources; confirm billable, security or compliance changes; delete without approval only a resource this build created whose provisioning failed; never sign in for the user; never report an unverified deployment as successful.
  • Workspace boundary. Builds stay inside the workspace: read lessons only from its own docs/LOOP.md, scaffold from the Foundry samples and these references, and use code from other folders only when the user names them. Only improve mode reads past runs elsewhere.
  • Work IQ context. Only when the user or a canvas prompt asks for it, query the workiq MCP server before clarifying questions, fold in only the requirements that matter, cite each by source type and confirm them. Never copy confidential content, personal data or secrets into the workspace; if Work IQ is unavailable or needs consent, say so and continue without it.
  • Companions and SDKs. Verify installed SDK APIs against the latest stable release (or the newest stable one the build's package index serves, recording the gap) and lock versions before generating code; package sources beat stale guidance. Consult the build catalog only for needed capabilities; respect pins, ask before installs and route third-party skill defects upstream.

Lessons

Right after a fix is verified (the failing probe or an equivalent boundary check reruns successfully; an edit, commit or deployment alone is not resolution), upsert a lesson in the workspace's docs/LOOP.md from the template before unrelated work, then read it back. Keep user notes, update matching lessons instead of duplicating them, and never include secrets, raw .env values or payloads. The coordinator, or the SDD phase lead, owns writes; workers report evidence. Lessons never authorize skill edits or weaker gates; improve mode applies them with approval.

Reviews

No reviews yet. Tell others what you thought.

Comments

No login needed. Share how it worked for you, ask a question, or note where it did not run.

No comments yet. Be the first to write one.

Comments are published right away. Do not include personal information such as email addresses or phone numbers. Up to 2 URLs.

0 / 1,000 characters

This form is protected by reCAPTCHA, and the Google Privacy Policy and Terms of Service apply.

More skills from this repository

Map an existing codebase into seven documents covering its technology, structure, architecture, conventions, integrations, tests, and concerns. Link findings to file evidence, mark unknowns, and highlight differences between stated plans and the actual implementation.

  • Get oriented in an unfamiliar codebase
  • Prepare documentation for a project handover
  • Compare documented architecture with implementation
github/awesome-copilot40.6KUpdated Oct 29, 2026

Assess a repository’s readiness for AI agents with AgentRC and generate a standalone HTML dashboard. Review scores across nine areas, see prioritized improvements, and optionally apply scoring policies tailored to an organization.

  • Assessing a repository’s readiness for AI agents
  • Prioritizing improvements from assessment results
  • Reviewing scores under an organization’s own policy
github/awesome-copilot40.6KUpdated Oct 29, 2026

Generate coding agent instruction files from a project's actual code using AgentRC. Capture detected languages, frameworks, and conventions in one shared file or split rules by topic and project area, with a preview before writing.

  • Create project instructions for VS Code Copilot
  • Refresh agent rules after project changes
  • Split monorepo instructions by project area
github/awesome-copilot40.6KUpdated Oct 29, 2026

Customize AgentRC readiness assessments to match team or organization standards. Choose or create policies that adjust check importance, disable irrelevant checks, set pass thresholds, and define requirements for automated checks in CI workflows.

  • Set shared readiness standards across an organization
  • Focus assessments on AI tooling
  • Adjust the importance of individual checks
github/awesome-copilot40.6KUpdated Oct 29, 2026

Analyze supplied ad performance data to identify wasted spend, strong campaigns, and next tests. Compare channels, assess whether test differences are meaningful, and produce budget reallocation recommendations with a prioritized action plan.

  • Identify ads and keywords to pause
  • Find campaigns and audiences worth scaling
  • Assess whether A/B test results are meaningful
github/awesome-copilot40.6KUpdated Oct 29, 2026

Turn code files into learning resources by adding comments that explain syntax, programming concepts, and design choices. Adjust explanation depth and repetition to the reader’s knowledge while preserving file structure, encoding, and syntax.

  • Add beginner-friendly explanations to existing code
  • Document the reasoning behind syntax and design choices
  • Adjust comment depth for readers with different experience
github/awesome-copilot40.6KUpdated Oct 29, 2026

See all skills by github

Report a problem with this skill