The specialist

The simplest multi-agent pattern is to pull one job out of the monolith and give it a dedicated prompt. No framework, no state yet. Just a class with one async method and one narrow responsibility.

cv_agentic_analyzer.py
python
class CVStrengthsAnalyzer:
    """Agent with one job: identify strengths against the job description."""

    def __init__(self, llm_provider):
        self.llm = llm_provider

    async def analyze_strengths(self, cv_content: str, job_analysis: dict) -> list[str]:
        prompt = f"""
        Analyze this CV and identify its key strengths.

        CV Content: {cv_content}
        Job Requirements: {job_analysis}

        Return the TOP 3 strengths relevant to the role.
        Be concise. One sentence each. JSON list only.
        """
        response = await self.llm.generate_text(prompt)
        return json.loads(clean_json_response(response))

One class, one responsibility. This agent never scores, never suggests, never checks ATS. It only surfaces strengths, which is exactly why it does that job well. The clean_json_response helper strips any markdown code fences the LLM wraps around its output, so json.loads receives clean JSON.

Flashcards: Flashcards

Loading practice…

Sometimes, but the tradeoff usually wins. Smaller prompts are cheaper per call, and parallelizable agents can recover the latency you pay on orchestration. The big win is reliability: one broken agent is easy to fix, and a broken monolith is a rewrite.

Quiz: Quiz

Loading practice…