Sample Fdep

An MCP server that helps forward-deployed engineers build AI-native applications on AWS from tested architecture patterns. Describe a customer's situation (industry, goals, AI maturity), and the kit activates the right programs, applies industry-specific lenses, and guides the agent through a structured delivery — from requirements through working code and deployment.

The kit doesn't just configure an agent workspace — it drives actual application development using 26 verified reference patterns (CDK stacks, Python agents, Bedrock configuration, React UI) and the AWS AI-DLC methodology (Inception → Construction → Operations). Programs interleave during delivery: architecture decisions feed requirements, requirements feed code generation, RAI reviews produce guardrail configs that get implemented, resilience patterns get deployed.

What You Get

For a typical build + aidlc engagement (e.g., "build a claims processing agent for an insurance company"), the kit drives the agent to produce:

All code is generated from version-specific, tested reference patterns — not from model memory. The agent reads .fde-manifest.json to know which reference to consult before writing each component.

Delivery flow (programs interleave):

/facilitate-working-backwards  →  defines WHAT to build and success KPIs
/design-agent                  →  selects architecture pattern (agent topology, HITL, guardrails)
/aidlc-inception               →  captures detailed requirements using AI-DLC methodology
/build-app                     →  generates infrastructure + agent + UI from layer references
/rai-review                    →  validates safety, produces guardrail configuration
/map-blast-radius              →  documents failure modes and recovery
/aidlc-operations              →  deploys with monitoring, incident response, production readiness

Industry lenses (financial-services, healthcare, life-sciences, games, manufacturing, public-sector) automatically overlay regulatory and domain-specific guidance onto active programs when the customer's industry matches.

How It Works — Loop Engineering

Most agent toolkits are pipelines: configure once, execute linearly. The FDE Kit runs delivery loops where each program's output enriches the system and feeds the next:

Load intention → Resolve programs → Build
        ↑                                 ↓
   Re-resolve ← Patch intention ← Discover
        ↓
Implement findings → Ship

Three mechanisms make this work:

1. Shared state mutation — Programs call fde_patch_intention as they discover things. When ai-plc working-backwards produces "build a claims processing agent", it patches the intention's workload.primaryDescription. Downstream programs see enriched context without being told.

2. Artifact handoffs — Every skill has explicit handoff routing. RAI review findings become guardrail specs → the builder implements them as Bedrock Guardrails. Blast radius maps become degradation policies → the builder implements circuit breakers. Output from one program is input to the next.

3. Re-resolve cycles — After sync-to-fde-intake or state transitions, the system calls fde_resolve again. New programs can activate mid-engagement based on what was discovered (e.g., discovering regulated: true activates responsible-ai at weight 95).

The result: the agent doesn't just follow a plan — it refines the plan as it builds. Each iteration produces working code, not documents about what to build.

Quick Start

Prerequisites

• Node.js 22+ (LTS)
• AWS MCP Server — required for building applications with FDE programs (provides AWS API access for CDK deployments, Bedrock, S3, etc.)

Setup

git clone <your-repo-url> fde-kit
cd fde-kit
npm install
npm run build

MCP Client Configuration

Configure the FDE kit and AWS MCP server in your MCP client config:

{
  "mcpServers": {
    "fdep-mcp": {
      "command": "node",
      "args": ["/absolute/path/to/fde-kit/bin/fdep-mcp.mjs"]
    },
    "aws-mcp": {
      "command": "uvx",
      "args": ["mcp-proxy-for-aws@latest", "https://aws-mcp.us-east-1.api.aws/mcp"]
    }
  }
}

{
  "mcpServers": {
    "fdep-mcp": {
      "command": "node",
      "args": ["C:\\Users\\<username>\\path\\to\\fde-kit\\bin\\fdep-mcp.mjs"]
    },
    "aws-mcp": {
      "command": "uvx",
      "args": ["mcp-proxy-for-aws@latest", "https://aws-mcp.us-east-1.api.aws/mcp"]
    }
  }
}

{
  "mcpServers": {
    "fdep-mcp": {
      "command": "node",
      "args": ["/home/<username>/fde-kit/bin/fdep-mcp.mjs"]
    },
    "aws-mcp": {
      "command": "uvx",
      "args": ["mcp-proxy-for-aws@latest", "https://aws-mcp.us-east-1.api.aws/mcp"]
    }
  }
}

curl -LsSf https://astral.sh/uv/install.sh | sh

Note: The FDE kit itself makes no AWS calls — it renders configuration files locally. The AWS MCP server is needed by your agent when it acts on the rendered skills (deploying CDK stacks, creating Bedrock resources, etc.).

Restart your MCP client. Ask the agent: "List the FDE programs" — done.

MCP Tools

The MCP server (bin/fdep-mcp.mjs) exposes the full toolkit as MCP tools for any compatible agent client:

Exposed tools: fde_list_programs, fde_list_lenses, fde_load_intention, fde_resolve, fde_render, fde_aim_assess, fde_get_skill, fde_get_steering, fde_patch_intention, fde_get_engagement_context, fde_init_workspace, fde_install_assets.

Typical workflow: fde_init_workspace → fde_load_intention → fde_resolve → fde_render.

The Five Primitives

What's in the Catalog

9 programs:

6 industry lenses:

13 platform adapters — render to whichever platform the FDE uses. Specify one or more targets in fde_render:

kiro, claude, copilot, cursor, codex, cline, continue, aider, windsurf, zed, chatgpt-custom-gpt, gemini-code-assist, mcp

Adapters bootstrap from a declarative adapters/manifest.json — adding a platform is a data change plus one adapter module.

Repository Layout

fde-kit/
├── bin/fdep-mcp.mjs        # MCP server entry point (stdio transport)
├── core/                   # Loader, resolver, renderer, state, MCP handlers, security
├── schemas/                # JSON Schemas for intention, lens, program, skill, steering
├── adapters/               # 13 platform-native renderers + manifest.json + _shared/
├── programs/               # 9 enablement programs
├── lenses/                 # 6 industry overlays
├── pipelines/              # Pipeline stage definitions
├── documentation/          # Guides, references, lens docs
└── scripts/                # Validation and utility scripts

Documentation

Security

The MCP server runs over stdio (local process, no listening ports). All tool operations are deterministic pure functions over the on-disk catalog.

License

MIT No Attribution (MIT-0) License — see LICENSE for details.