■Background

Recently, a conversation came up within our team about building a talent matching system for members and teams. We had been planning to do a quick validation by just pasting prompts around, but I figured — why not use AWS Bedrock AgentCore to build a POC for learning purposes?

For the matching logic, I went with the honest approach of standing on the shoulders of giants and surveyed related papers on Arxiv. The most useful one proposed a design using RAG (Retrieval-Augmented Generation) × multi-agent architecture to evaluate resumes, scoring them and explaining the rationale. For this implementation, I essentially translated the paper’s design directly into code.

  • Agent 1: Data Analysis: Converts member data (skills, experience, achievements, etc.) to JSON and removes PII
  • Agent 2: Normalization: Corrects notation inconsistencies, aggregates data, and estimates skill levels
  • Agent 3: Matching Evaluation: Ingests input data via RAG and scores across 5 categories
  • Agent 4: Explanation Generation: Organizes evidence fragments + strengths/gaps by sub-score

All output is in strict JSON format, with total value checks (total == sum(subscores)) and re-output rules built in.

■Implementation Environment

This time, partly to get more familiar with AWS, I leaned heavily on Bedrock for the foundation.

  • Region: us-west-2 (Oregon)
  • Storage: S3 (folder structure for KB)
  • Knowledge Base: Bedrock Knowledge Bases + Amazon Titan Embeddings (honestly, I left this to the AI)
  • Inference Model: Claude / Titan Text (used differently depending on the task)
  • Evaluation Engine: LangGraph for multi-agent branching execution
  • Result Storage: DynamoDB (agent_runs / match_results) *ended up not using this for the POC
  • Serving: AgentCore Runtime (API Gateway + Lambda as needed)

■Build Steps (PoC Version)

The POC flow went like this:

1. Region Setup & Permissions

Set to Oregon:

aws configure set region us-west-2

For the POC, I started with broad permissions like AmazonBedrockFullAccess and narrowed them down after things worked. I wasn’t familiar with IAM operations either, so it was a cycle of errors and adding permissions.

2. S3 Bucket Creation

aws s3 mb s3://talent-match-poc-2025
aws s3api put-object --bucket talent-match-poc-2025 --key kb/positions/

3. CSV Creation & Markdown Conversion for KB

  • position_requirements.csv (position_id, title, department, required_skills…)
  • team_policies.csv (team_id, min_experience, tech_stack…)
python csv_to_kb.py
aws s3 sync kb_out/ s3://talent-match-poc-2025/kb/

4. Knowledge Base Creation & Sync

Specified the data source from the Bedrock console and ran Sync. This is where I got stuck on permission issues. Temporarily granted full admin permissions to push through.

5. DynamoDB Table Creation

  • agent_runs
  • match_results

6. Multi-Agent Implementation with LangGraph

Parallel category scoring across S1–S5 nodes → JOIN → A5 coverage calculation.

7. Save Results to S3 and Visualize with Athena

NDJSON format can be queried directly.

8. Deploy to AgentCore Runtime

Granted execution role, set environment variables (KB_ID, MODEL_ARN, etc.), and verified with Invoke.

■Pain Points

  • KB sync failed due to insufficient permissions: After granting embedding model access, manual re-ingestion was required. → Temporarily slapped on Admin permissions and brute-forced my way through.
  • AgentCore wouldn’t start: Issues with the app.py code and environment variable persistence.

■Cost After a Day of Tinkering

Surprisingly expensive. Total: $12.48. Should have come out of free credits though.

  • OpenSearch Service: $11.98
  • CodeBuild: $0.30
  • Claude 3 Haiku (Bedrock Edition): $0.19
  • S3: $0.01
  • EC2 Container Registry (ECR): $0.00
  • Other: $0.00

OpenSearch accounts for most of it — was that because I left it running? How do you even stop the billing on that?

■Learnings and Next Steps

I managed to build a serverless multi-agent system on AWS.

I’d been thinking “Could I build this with GPT-5’s help?” — and sure enough, I was able to take the paper’s design, implement it broadly, and actually get matching working. Pretty satisfying. The fact that it’s serverless is a nice bonus.

That said, while I managed to build it, my understanding isn’t deep, so I need to make sure I don’t neglect the fundamentals. Going forward, I’ll probably need to deliberately put myself through inefficient methods to really stress-test my own learning.

■Side Note

On a tangent — I recently attended a Claude MAX meetup hosted by Nukonuko-san (@schroneko), and it turns out everyone just casually reads papers. I’ve been making it a daily habit to analyze and read papers on education, security, and alignment using LLMs, but I assumed not many people read papers regularly. That was pure hubris on my part.

Also, why did GPT-5 occasionally bug out — losing context, getting amnesia, or randomly starting to talk about project knowledge out of nowhere?