Your PRD.Your GitHub.Your AWS.Deployed.

Upload your product requirements. An AI agent refines them. A graph engine validates your architecture, no hallucinations. Your codebase gets written and committed to GitHub. Your AWS goes live.

PRD UploadClaude reads it.
→
AI RefinementFills the gaps.
→
Final ArchitectureGraph-validated.
→
Code GenerationTo your GitHub.
→
AWS DeployYour account.
✓ Architecture validated · 3 components · 0 conflicts
✓ Scaffold committed → github.com/user/my-app
✓ 4 resources live · us-east-1 · 4.2s
End-to-end pipeline·Graph-validated architecture·Deploys to your AWS, not ours·10+ AWS services·Open source
THE PROBLEM

How cloud projects actually go

Write a PRD nobody reads again
Copy-paste Terraform from Stack Overflow
Manually provision resources and pray

How CloudForge does it

Agent refines your PRD into a spec
Graph-validated architecture, no guesswork
One click. Real resources. Streamed live.
HOW IT WORKS
01

Upload your PRD

Connect GitHub once. Create a project. Upload your Product Requirements Document (PDF or plain text). CloudForge's agent reads it and opens a refinement conversation immediately.

02

Refine with an AI agent

The agent asks targeted clarifying questions based on your actual requirements, not generic ones. You answer. It synthesizes a final structured spec. This becomes the source of truth for everything downstream.

03

Graph-validated architecture

CloudForge runs your requirements through a LangGraph pipeline backed by a KuzuDB knowledge graph of AWS architecture constraints. The graph engine deterministically validates service compatibility, with no hallucinated recommendations. Claude Sonnet explains the reasoning. You finalize.

04

Codebase written and committed

CloudForge generates a production-ready codebase matched to your finalized architecture: framework, structure, and Terraform infra included. Review it in the UI, then one click pushes it directly to your GitHub repo.

05

Deploy to your own AWS

Connect AWS per-project via IAM role assumption. No credentials stored. CloudForge triggers CI/CD, provisions every resource through the AWS Cloud Control API, and streams the live log back to your browser in real time.

THE DIFFERENTIATOR

Most AI tools guess your architecture.
CloudForge proves it.

A KuzuDB knowledge graph deterministically validates AWS service compatibility before Claude Sonnet writes a word of explanation.

Every architecture recommendation passes through a graph traversal step first. The graph encodes AWS constraints: which services are compatible, which conflict, and which are required given your NFRs.

LangGraph routes your extracted requirements through the graph. It resolves valid paths, marks blocked combinations, and surfaces conflicts. Only the validated path reaches the LLM.

Claude Sonnet explains what the graph proved. It never decides. That's how you get zero hallucinated 'you could use Lambda or maybe ECS or perhaps Fargate' hedging.

Constraint Graph
REQUIRESREQUIRESCONFLICTSLambdaElastiCacheAurora ServerlessIn-Memory Cache
REASONING TRACE
✓ serverless → Lambda (cost optimization)
✓ Lambda → ElastiCache (no persistent memory)
✓ ACID required → Aurora (managed, serverless-compatible)
✗ in-memory cache → BLOCKED (no Lambda persistence)
WHAT CLOUDFORGE GENERATES

Tell us what to build. We build it.

Describe what you're building. Iterate with the agent until it's right. CloudForge writes your application code and AWS infrastructure — then deploys it to your own AWS account.

main.tfWritten by CloudForge · Claude Sonnet · 2.3s
provider "aws" {
region = "us-east-1"
}
 
resource "aws_iam_role" "lambda_exec" {
name = "cloudforge-lambda-exec"
assume_role_policy = jsonencode({
Version = "2012-10-17"
Statement = [{
Action = "sts:AssumeRole"
Effect = "Allow"
Principal = { Service = "lambda.amazonaws.com" }
}]
})
}
 
resource "aws_lambda_function" "api_handler" {
function_name = "api-handler"
runtime = "nodejs20.x"
handler = "index.handler"
role = aws_iam_role.lambda_exec.arn
memory_size = 512
}
 
resource "aws_db_instance" "postgres_db" {
identifier = "cloudforge-db"
engine = "postgres"
engine_version = "15"
instance_class = "db.t3.micro"
}

Everything you need.

Nothing you don't.

PRD-first

Start with what you're building, not what infrastructure to pick. CloudForge extracts requirements before recommending anything.

Graph-validated

A KuzuDB constraint graph deterministically validates AWS service compatibility before the LLM writes a single line.

Your GitHub

CloudForge writes your full codebase and pushes it directly to your repo: not a template, not boilerplate. Production-ready code.

Your AWS

Cross-account IAM role assumption only. No credentials stored. Your infrastructure, your bill, your control.

Live deploy log

Every Terraform operation streams to your browser in real time. Lambda created. IAM attached. VPC peered. Nothing hidden.

Zero config files

No YAML, no HCL to write, no AWS console to click through. Every resource is configured through a visual panel.

From PRD to deployed.
No detours.

Create an account and start your first project in minutes.

Writes your codebase · Deploys your infrastructure · You own everything