Domain I Business Problem: Usher’s New Look program, aimed at creating social mobility to lift youth from underserved backgrounds out of poverty. USE AI TO PERSONALIZE CAREER DISCOVERY TO MATCH YOUTH WITH THEIR SPARK

(How do kids use AI effectively)
We are building (or prososing) A Product

-Leverage Advantages of AI logically. -Algorithmically Guided “Spark” Nurturing Define the product

(Sentiment Evaluation with AI??) (Implement WebScraping to evaluate history??)

  1. USE AI TO BUILD PROFESSIONAL PORTFOLIOS AND DEMONSTRATE 7 CAPITALS

Define the Product

Domain II Analytical Problem Framing: AI solution directed towards helping Usher’s new Look.. Help their Diversity Equity and Inclusion Initiatives Use AI to help youth discover new career pathways aligned with their creativity and interests Reduce uncertainty or mismatch when exploring entertainment roles Boost Youth Confidence Parameters:

  1. Desirability
  2. Feasibility
  3. Safety
  4. Scalability & Sustainability
  5. Storytelling & Presentation
  6. Innovation and Creativity

Shifting towards Dynamic

  1. Increase credibility and reputation gap for youth from under- resourced backgrounds by providing portfolios

    Help mentors and employers better assess creative potential by surfacing evidence of skill, initiative and growth not captured in traditional resumes. Innovate and improvise with AI

    Enable continuous portfolio development through AI tools that help them grow their portfolios and projects and experience Insurance Services provided by Travelers: Health Work-Life Financial Unemployment ChildCare Educational

Traveler’s Development Programs: Entry Level Coursework slide ins for careers Learning Professional Accelerators Networking and Event Participants

Ushers New Look:

Social Mobility For Programs tacking wealth inequality and lack of social mobility among poor youth Aims to build system to lift one million out of poverty into permanent wealth

The 6 capitals:

Human Capital Individual Skills and Abilities Wellness Capital Habits, Emotional Regulations, Physical and mental Health Economic Capital Money, Credit, Salary, Assets Spark Capital Purpose Cultural/Clout Capital: Impact Social Capital: Networking, Communities and connections

The Three Es:

Exposure -Spark Club
Career exposure to multiple fields.

Explorations - Paid Internships and Development Prograns

Experience: Develop holistic Skilsets: -Professional -Technical -Social Fields Covered: -Business Animation FVX Writing and Journalism Music Sports Film & Television

Domain III: Gather User data through variety of means Gather web history, webscraping, gather skills and interest from previous work or consumption of content. Implement interactive chatbot that can act as segway for kids in these programs to find their spark. Chatbot will consult with quizzes, surveys, interact with users, answer queries, or incentivize Journal entries. Save that text for processing and analyzing by AI Interactive Application which simulates different career paths, similar to the development and experience programs that Usher’s New look has in place. Application will gather and save work, inputs, outputs, and form evaluations and patterns from this history. Domain IV:

FINALIZE PLAN Methodology Chatbot that acts as segway into other programs and services

2 . Resume Sparsers

  1. Interviewer

4.User Interface

Domain V: Model/Solution Strands SDK Agent: -Native AWS Strands SDK agent that comes with prepackage functionality, provided by Amazon AWS. Internal configuration ready via schema -Contribution was elaborate prompt to feed into the prepackaged agent with which to guide conversation and interactions with users. Analyzes interests, spots trends, and returns “spark” of interest” and corresponding programs with Usher’s New Look.

Amazon Polly to transcribe conversation with user, Transcribe to convert conversation to text. Then uses LLM to prompt user with Dynamic questions to help build a profile based on the RIASEC framework for jobs.Results stored in Dynamo DB as a JSON From a corpus of user skills, interests, strengths, weaknesses, likes, dislikes etc., we give an Amazon Bedrock LLM the task of reading, analyzing, and returning only the items that match the user's profile (resume, short description of the user’s likes/dislikes, interests) in a user feature vector. This user feature vector is then matched, using cosine similarity (subject to change) to a list of jobs in the entertainment industry. This would be how entertainment industry professionals in Usher’s New Look could connect young talented kids with mentors.

Domain VI: Deployment ( Idea of how can they deploy it) -Couple ideas and reccomendations

Domain VII: Lifetime Maintenance -Monitoring Maintenance -best practices -Safety & Ethics

*Chatbot might not be efficient

Solution Submission: Due 2:30 pm tomorrow JUdges will be short Presentations Start 3:15pm 5 minute Presentations

Rubric: Desirability and Impact Feasability

Yeah, you can absolutely “link” profiles when using an API, but it’s not magic—you have to design the profile layer yourself on top of the (mostly) stateless API. Let me break it into two parts: How to attach a profile to API calls

Shortcuts for building a decent profile for someone else

  1. How to attach a profile to API calls At the API level, you basically have three main options: A. Put the profile in the system message You store the user profile in your database, and on each request you do something like: messages = [ { "role": "system", "content": ( "You are a career coach.\n\n" "USER PROFILE:\n" "- Strengths: analytical thinking, systems building, automation.\n" "- Motivations: likes solving complex problems, enjoys building tools, dislikes repetitive manual work.\n" "- Values: autonomy, learning, visible impact.\n" ) }, {"role": "user", "content": user_question} ]

The model then uses that profile to shape its answers. Pros: Very explicit and controllable

Easy to update or A/B test profiles

Cons: Costs tokens every call

You have to keep it short and distilled

B. Store the profile in your own DB and fetch + inject dynamically Same idea, but you treat the profile as its own object: { "user_id": "abc123", "profile": { "strengths": [...], "values": [...], "motivators": [...], "drainers": [...], "career_theme": "Makes complex systems simple and automated." } }

Then your API layer: Looks up user_id

Pulls profile

Injects a compressed version into the prompt (system or a separate “assistant” note).

This is basically “build your own memory,” which is exactly what people do when they need long-term state for agents.OpenAI Developer Community+1

C. Use embeddings for profile retrieval If the profile gets large (e.g., notes from multiple sessions, long coaching transcripts), you can: Chunk and embed the profile data

On each request, embed the new question

Retrieve the top-k most relevant chunks about that person

Add only those bits into context

This is just RAG, but the corpus is “who this person is.”

  1. Shortcuts for building a profile for someone else You don’t have to run a 20-page intake to get something useful. You can hack together a good enough profile with a few structured inputs. Shortcut approach: “3-pass profile” Pass 1 – Quick survey or observed data Get a tiny set of signals (could be form answers, behavior in your app, or a few chat questions): 3 tasks they enjoy / dislike

Things they feel proud of

Things that drain them

A couple of past roles or projects

Pass 2 – Let the model infer a profile Send those answers to the API with an instruction like: “Extract a concise strengths/motivations/values profile from this person’s answers. Limit each category to 3 bullet points max. Then generate a 1-sentence career theme.” You store the result as a structured JSON: { "strengths": ["...", "..."], "motivations": ["...", "..."], "drainers": ["...", "..."], "values": ["...", "..."], "career_theme": "..." }

Pass 3 – Refine over time Each time the user interacts, you can: Ask the model: “Given this new interaction, should we update the profile?”

If yes, create a new version or merge into the existing one

Keep the profile small and distilled (otherwise token-hell)

Practical “shortcuts” you can bake in Here are concrete shortcuts you can use when you’re building this for other people: Default templates by persona

If user selects “data/tech/creative/people-oriented,” preload a default profile and let the model tweak it based on answers.

Use fixed questions that map to frameworks

2–3 questions per lens:

Strengths (“What do people come to you for help with?”)

Motivations (“When do you feel most ‘in the zone’ at work?”)

Values (“If you had two similar jobs, what would be the tie-breaker?”)

Ask the model to compress

After a long intake, call:

“Summarize this into a profile that fits under 300 tokens. Use the schema: strengths, motivations, drainers, values, career_theme.”

Store profiles as JSON, display as prose

JSON for the machine, pretty sentences for the human.

Make the profile editable

Let the human say, “That doesn’t sound like me,” and then send that correction + old profile to the model with:

“Update the profile to reflect the user’s correction. Keep it under 300 tokens.”

If you want, I can: Design a JSON schema for a strengths/narrative/motivation profile you can drop straight into your code

Write a prompt template that:

Takes raw answers

Returns a clean profile

Is easy to feed back into system messages

Sketch the flow for a “career coach agent” that builds and uses profiles across calls

Tell me which language / stack you’re thinking of (Python, JS, etc.), and I’ll give you copy-pasteable pieces.

Sources You said: could we build an agent that analyses google profiles etc to build a list of strengths then match it to a list of careers? ChatGPT said: Thought for 6s Yes, with guardrails. You can absolutely build a “career coach agent” that reads someone’s public, consented digital footprint and then: Infers a strengths profile, and

Matches it to a set of career paths.

The interesting work is in designing the pipeline + schema, not the raw LLM calls.

  1. First, the big caveats (important but quick) If you do this: Do it for the user, with their explicit consent, not as a stealth profiling tool.

Limit it to links they provide (e.g., “Analyze my LinkedIn and personal site”) instead of crawling everything you can find.

Let them review and edit the inferred strengths before you use them for recommendations (LLMs are probabilistic, not omniscient).

Avoid inferring sensitive traits (race, health, politics, etc.). Focus on skills, behaviors, achievements, preferences.

Think: “personal career assistant” → not “background surveillance engine.”

  1. High-level architecture Here’s a clean, modular design: Step 1 – Inputs from user User gives you: Links: LinkedIn, portfolio site, GitHub, Google Scholar, CV, etc.

Optionally: a short self-description or answers to 2–3 questions.

{ "user_id": "abc123", "sources": [ "https://www.linkedin.com/in/…", "https://github.com/…", "https://scholar.google.com/citations?user=…" ], "extra_notes": "I enjoy building automation scripts and ML tools." }

Step 2 – Fetch & normalize content Agent tools: fetch_url / scrape_profile tools (or your own scrapers / APIs where allowed)

A “cleaner” that turns messy HTML into structured text chunks like:

{ "source": "linkedin", "sections": { "headline": "Data Science & Analytics Graduate | Treasury Automation", "about": "…", "experience": ["…", "…"], "projects": ["…"] } }

You store this as the raw career corpus for that user.

Step 3 – LLM-based strengths extraction Now you call the model on the combined structured text with a tight schema: Prompt idea (system): You are a career coach. From the data below, infer the user’s strengths, skills, working style, and likely interests. Only use evidence from the text. Respond in the JSON schema provided. Schema to return: { "strengths": [ {"name": "Systems thinking", "evidence": "…"}, {"name": "Data analysis", "evidence": "…"} ], "skills": [ {"name": "Python", "level": "advanced"}, {"name": "SQL", "level": "intermediate"} ], "work_style": [ "enjoys building repeatable workflows", "likes solving complex problems" ], "interests": [ "machine learning", "process automation" ] }

You can run multiple “views”: One pass focusing on technical skills

One on behavioral strengths

One on themes / narrative

Then merge + dedupe.

Step 4 – Build / use a career knowledge base You need a structured catalog of careers. At minimum: { "career_id": "ml_engineer", "title": "Machine Learning Engineer", "description": "Builds and deploys ML models into production...", "key_strengths": ["Systems thinking", "Problem solving", "Programming"], "key_skills": ["Python", "ML frameworks", "Data pipelines"], "work_style": ["likes experimentation", "comfortable with complexity"] }

You can: Hand-curate this for ~30–100 target roles, or

Pull from O*NET / similar and normalize.

Store it in a DB and also embed each career’s description + required strengths using an embeddings model.

Step 5 – Matching algorithm Now you “score” careers against the user profile. Hybrid approach works best: Symbolic overlap:

Strengths intersection (e.g., user has “Systems thinking”, “Analytical”, etc.)

Skills intersection (Python, SQL, cloud, etc.)

Work-style compatibility (prefers independent work vs. heavy client-facing)

Vector similarity:

Embed:

User’s inferred profile text (e.g., “Top strengths: … Work style: … Interests: …”)

Each career’s description

Compute cosine similarity:

Higher similarity → better fit

Return something like: [ { "career_id": "ml_engineer", "fit_score": 0.86, "reasons": [ "Strong alignment in Python and ML", "Enjoys building automation and tools", "Comfortable with complex systems" ] }, { "career_id": "analytics_engineer", "fit_score": 0.82, "reasons": [ "ETL/data pipeline skills", "Enjoys turning messy data into usable models" ] } ]

Then send those results back to the LLM for a nice human-facing explanation: “Here are 3 roles that seem like good fits and why…”

  1. How to turn this into an “agent” You can wrap all of that into an agent with tools like: get_user_sources (from your DB)

fetch_and_clean_url

extract_strengths_from_text

retrieve_matching_careers

explain_matches_to_user

The high-level loop: Agent receives: Analyze this user’s links and suggest careers.

Calls fetch_and_clean_url for each source.

Calls extract_strengths_from_text (LLM tool).

Calls retrieve_matching_careers (embedding search + scoring).

Uses LLM to turn the JSON result into friendly recommendations and follow-up questions.

You can make it interactive: After showing matches, ask:

“Which of these feels most interesting or least interesting?”

Use that feedback to update the profile and re-rank careers.

  1. Where the shortcuts come in To avoid overkill: Start with just LinkedIn or a CV upload.

Limit the profile to 3 strengths + 3 skills + 3 work-style traits.

Limit careers to a short curated list aligned to the domain you care about (e.g., data/tech roles).

Let the user edit or confirm their inferred strengths before final matching.

You don’t need full “internet persona mining” to get value. A small, truthful slice of data plus a good schema gets you very far.

If you want, I can sketch: A concrete JSON schema for the strengths & career objects

A sample Python skeleton that:

Takes a LinkedIn-like text blob

Calls an LLM to infer strengths (schema above)

Uses a tiny in-memory career list

Ranks and prints top 3 fits

That would be a nice starting point you could extend into a proper agent.

Built With

Share this project:

Updates

Submission history