GRANT SCOUT

Autonomous multi-agent system powered by AWS Bedrock AgentCore that discovers Grants.gov opportunities, matches eligibility via RAG, and drafts audit-ready federal proposals.

Comment

GrantScout: Autonomous Federal Grant Intelligence & Proposal Drafting Swarm

Inspiration

Federal grants distribute over $1.2 trillion annually, but the barrier to entry remains notoriously steep. Securing federal funding through Grants.gov requires navigating thousands of dense pages, parsing complex Notices of Funding Opportunities (NOFOs), and assembling exhaustive proposals that easily demand over 150 hours of specialized staff time. For small nonprofits, emerging research laboratories, and educational initiatives that lack dedicated grant-writing personnel, this administrative burden becomes an insurmountable bottleneck—causing high-impact organizations to miss deadlines or submit applications disqualified by minor structural technicalities.

We built GrantScout to dismantle this barrier. Our goal was to design an autonomous multi-agent swarm that acts as a 24/7 federal funding strategist: continuously discovering opportunities, verifying institutional alignment using internal knowledge bases, and synthesizing comprehensive, audit-ready proposals tailored to federal review criteria.

How We Built It

GrantScout is engineered as a decoupled, production-grade 3-tier architecture separating client visualization, orchestration, and containerized agent reasoning.

1. Autonomous Agent Swarm (AWS Bedrock AgentCore & Strands SDK)

The reasoning layer runs inside an isolated container deployed to AWS Bedrock AgentCore using the Strands SDK:

  • Matcher Agent: Evaluates federal opportunity synopses against an institutional profile using Retrieval-Augmented Generation (RAG). Match affinity is modeled as a multi-factor weighted equation: Match Score = (w_similarity × Semantic_Fit) + (w_eligibility × Eligibility_Status) + (w_capacity × Capacity_Fit)
    (where Eligibility_Status acts as a binary gate: 1 if fully compliant, 0 if disqualified).
  • Drafter Agent: Employs AWS Bedrock Claude 3.5 Sonnet to execute a multi-pass synthesis pipeline:
    • Federal Blueprinting: Establishes standard agency structural breakdowns (NSF, NIH, DOE, ED).
    • Context-Injected Section Expansion: Hydrates each section with verified organizational metrics, budget constraints, and staff credentials.
    • Rubric Audit & Compliance Scoring: Computes quantitative scores across federal criteria:
      Overall Rubric Score = Σ (w_i × criterion_score_i), where Σ w_i = 1.0 across Broader Impacts, Intellectual Merit, Feasibility, and Budget Justification.
  • Model Context Protocol (MCP): Agent tools interact with system persistence and local services via authenticated FastMCP protocols, maintaining clean boundaries between containerized reasoning and host data.

2. Backend Orchestration Gateway (FastAPI & Python)

  • Connects directly to the Grants.gov REST API to index live opportunities, normalize federal metadata, and validate active application package URLs.
  • Manages continuous background scanning loops, local storage persistence (JSON/SQLite), and an asynchronous warmup endpoint (POST /api/agent/warmup) to trigger container boot sequences without blocking client threads.
  • Implements defensive security controls, including path traversal sanitization, CORS whitelisting, and API key authentication.

3. Frontend Mission Control (React 18 & Vite)

  • A high-density analytical dashboard featuring real-time telemetry streaming, interactive pipeline funnels, dynamic rubric scoring visualizers, and a split-view proposal editor.
  • Deployed as an edge-optimized Single Page Application (SPA) on Vercel with automated deep-route rewrite configurations.

Challenges We Faced

  1. Federal Data Normalization: The Grants.gov API frequently yields inconsistent data representations, such as varying date encodings, fragmented XML summaries, and broken application package URLs. We developed defensive normalization routines that ingest raw schemas and extract uniform metadata regardless of the issuing agency.
  2. Eliminating Boilerplate Placeholders: Single-prompt LLM architectures consistently produce generic prose littered with bracketed placeholders like [Insert Key Personnel Here]. We eliminated this by designing a 3-stage blueprinting engine that queries the RAG knowledge store prior to generating each section, grounding all narratives in real organizational metrics (staff FTEs, past budgets, community demographics).
  3. Container Scale-to-Zero Latency: Operating with a 15-minute idle runtime timeout (900 seconds) on AWS Bedrock AgentCore saves compute expenses but creates cold-start delays. We solved this by implementing an asynchronous warmup protocol on the client splash screen, polling container state and rendering real-time telemetry until the environment is operational.
  4. Decoupled Security Boundaries: Running the backend on Render, the agent swarm on AWS Bedrock AgentCore, and the frontend on Vercel required strict token isolation to ensure that no master credentials or IAM roles leaked into client code or repository commits.

What We Learned

  • Hierarchical Generation Outperforms Monolithic Prompts: Breaking complex federal proposals into sequential phases—outline generation, evidence-grounded prose expansion, and adversarial rubric auditing—produced drastically higher factual consistency and compliance adherence.
  • Economic Viability of Scale-to-Zero Agents: Deploying specialized agent containers on AWS Bedrock AgentCore demonstrated that sophisticated enterprise swarms can run with negligible standby infrastructure costs.
  • Standardizing Agent Tooling via MCP: Adopting the Model Context Protocol simplified inter-service communication, allowing agent containers to read and write to host persistence systems without tight coupling.

Built With

Share this project:

Updates

Submission history