An AI Agent for Job Post Creation

Writing a great job post isn’t just about filling in blanks, it’s about capturing the role, your company’s voice, and market expectations. For enterprises hiring at scale, this is a recurring bottleneck: either teams spend hours researching and drafting from scratch, or end up with generic templates that don’t convert.

That’s why I built a team of AI agents using aiXplain’s framework to automate the entire process from analyzing company culture to structuring role responsibilities and capturing industry trends. If you’re in HR, talent ops, or building internal tools to streamline recruiting workflows, this agent setup offers consistency, quality, and speed—without sacrificing context or customization.

In this tutorial, I will walk you through:

• Defining agent tasks using AgentTask
• Creating specialized agents per task
• Using the Google search tool for better accuracy
• Combining agents into a powerful team with TeamAgentFactory

Let’s break it down.

What This Agent Team Does

A team of agents is where different agents collaborate, each with a specific role or skill, coordinated under a shared orchestration logic. The user provides a job title or a short description, and the team agent returns a fully formatted job post in Markdown format. The structure is controlled by the format_instructions passed into the team.run() method as shown below:

team.run(
    query="Create a job posting for a technical product manager",
    content=format_instructions,
    output_format=OutputFormat.MARKDOWN
)

Here’s what the format_instructions template includes:

format_instructions = """
# FORMAT INSTRUCTIONS

Your job posting should follow this exact structure:

## 🚀 Job Title: [TITLE]
📍 **Location:** [LOCATION]
🕒 **Employment Type:** [EMPLOYMENT_TYPE]
💼 **Team:** [TEAM]

---

## 📝 About the Role
[COMPANY_INTRODUCTION]
[ROLE_OVERVIEW]

---

## 🔍 What You'll Do
- [RESPONSIBILITY 1]
- [RESPONSIBILITY 2]
- [RESPONSIBILITY 3]
...

---

## ✅ Qualifications

**Required:**
- [REQUIRED QUALIFICATION 1]
- [REQUIRED QUALIFICATION 2]
...

**Preferred:**
- [PREFERRED QUALIFICATION 1]
- [PREFERRED QUALIFICATION 2]
...

---

## 🌟 Why Join Us
- [BENEFIT 1]
- [BENEFIT 2]
...

---

## 📊 Industry Trends
[INDUSTRY_TRENDS_PARAGRAPH]

---

## 📋 How to Apply
[APPLICATION_PROCESS]
"""

This is powered by four specialized agents working together:

Agent role	Task
Company Culture Analyst	Analyzes work environment and values
Role Requirements Analyst	Extracts skills and qualifications
Industry Analyst	Identifies current job market trends
Job Posting Creator	Writes the comprehensive job post based on inputs from the other agents

Each of these agents uses a shared Google Search tool for real-world context, enhancing relevance and accuracy. You can find the tool a.k.a. Asset ID from aiXplain marketplace as shown below:

Now let’s walk through the architecture and code that make this team agent work.

Step 1: Define agent tasks with AgentTask

AgentTask lets you explicitly define what each agent in the team should do. Instead of letting the Mentalist break down the problem on its own, you can step in and specify the exact tasks and dependencies. This gives you tighter control over execution, especially useful when the workflow needs to follow a particular order or when different agents depend on each other’s outputs. By doing this, you’re essentially switching from autonomous planning to guided execution. You tell the orchestrator: Here’s what needs to happen, and in what order.

Before creating agents, we define their responsibilities using AgentTask as seen below:

from aixplain.modules.agent.agent_task import AgentTask

company_analysis_task = AgentTask(
    name="analyze_company_culture",
    description="Analyze the company culture, values, and work environment.",
    expected_output="Detailed analysis of company culture with key values."
)

# Role and job post tasks
role_analysis_task = AgentTask(...)
job_posting_task = AgentTask(..., dependencies=[company_analysis_task, role_analysis_task])
industry_analysis_task = AgentTask(...)

The job_posting_task depends on outputs from the company_analysis_task and role_analysis_tasks-enabling composable, sequential reasoning.

Learn more about AgentTask in aiXplain’s docs.

Step 2: Create specialized agents

Using AgentFactory.create(), we define four agents. Each one uses:

• A clear instruction prompt
• A specific AgentTask
• An LLM of your choice (in this example, I used DeepSeek V3)
• The Google Search Tool

Example: Company Culture Analyst

from aixplain.modules.agent.tool.model_tool import ModelTool
search_tool = ModelTool(model="65c51c556eb563350f6e1bb1")

company_analyst = AgentFactory.create(
    name="Company Culture Analyst V3",
    description="Analyzes company culture from job descriptions and external data.",
    instructions="""You are a Company Culture Analyst...""",
    tasks=[company_analysis_task],
    tools=[search_tool],
    llm_id="67e2f3f243d4fa5705dfa71e"
)

All other agents follow the same pattern with different tasks and instructions.

Step 3: Assemble the team

Now that we have all the agents, we use TeamAgentFactory to bind them together:

from aixplain.factories import TeamAgentFactory

team = TeamAgentFactory.create(
    name="Job Posting Analysis Team V5",
    description="Generates job posts by analyzing roles, companies, and trends.",
    agents=[company_analyst, role_analyst, job_posting_creator, industry_analyst],
    use_mentalist=True,  # For dynamic planning
    use_inspector=True,  # For verifying outputs
    llm_id="67e2f3f243d4fa5705dfa71e"
)

The Mentalist is a micro-agent responsible for breaking down high-level goals into executable tasks and assigning each task to the most suitable agent based on capability. It lets the team plan and execute tasks dynamically based on the dependencies, while the inspector ensures outputs follow expected formats.

Step 4: Run the team

Finally, you can run the full team agent like this:

format_instructions = """..."""  # Your Markdown template

result = team.run(
    query="Create a job posting for an AI Vibe Coder...",
    content=format_instructions,
    output_format=OutputFormat.MARKDOWN
)

print(result.data["output"])

The output looks as follows:

# AI Vibe Coder (AI-Assisted Development Specialist)

## About Us
Join our pioneering team at the forefront of software development innovation! We're redefining coding through our 'vibe coding' approach - where natural language meets AI-powered development. Our culture thrives on innovation, technical adaptability,
and collaboration as we explore this exciting new paradigm in software creation.

## Key Responsibilities
- Translate business requirements into effective natural language prompts for AI systems
- Review, refine, and validate AI-generated code outputs
- Collaborate with traditional developers to integrate AI-generated solutions
- Continuously develop and improve prompt engineering techniques
- Document and share best practices for conversational software development
- Stay current with advancements in AI-assisted development tools

## Required Qualifications
- 2+ years experience in software development or AI-assisted coding
- Proficiency in natural language processing concepts
- Experience with AI development tools (e.g., GitHub Copilot, ChatGPT)
- Strong understanding of software development principles
- Excellent communication and technical documentation skills
- Creative problem-solving and adaptability to new technologies

## Preferred Qualifications
- Familiarity with multiple programming languages
- Experience with prompt engineering techniques
- Knowledge of AI model fine-tuning
- Storytelling ability for requirements description
- Experience in technical communication or requirements gathering

## Growth Opportunities
- Be at the forefront of a new development paradigm
- Work with cutting-edge AI technologies
- Shape the future of conversational software development
- Continuous learning in emerging tech fields
- Opportunities to publish/present innovative approaches

## Benefits
- Competitive compensation package
- Flexible work arrangements
- Professional development budget
- Collaborative, flat-hierarchy team structure
- Results-oriented work environment
- Health and wellness benefits

## How to Apply
To apply, please submit:
1. Your resume highlighting relevant experience
2. A brief cover letter explaining your interest in 'vibe coding'
3. (Optional) Examples of AI-generated code you've worked with

We're excited to hear from innovative developers ready to shape the future of software creation!

Why It Matters

This project shows how a multi-agent system can do more than automate; it can coordinate, contextualize, and scale tasks that are otherwise repetitive and inconsistent across teams. By structuring job post creation as a set of roles with clear responsibilities, we move beyond prompt engineering into task-level orchestration, where each agent contributes meaningfully to a shared outcome. It’s a glimpse into how modular AI can be applied to solve real enterprise bottlenecks, from recruiting to documentation and beyond.

Try It Yourself

Curious to build your own agent team? With aiXplain’s Agentic Framework, it’s quite straightforward. Define the roles, give each one a clear task, and plug in tools like web search or APIs to give them context. The framework handles the heavy lifting such as task planning, execution order, and coordination between agents.

You can start small: automate a product description, draft a user guide, or analyze competitor sites. Then scale up by adding more agents as your workflow grows.

Think in roles. Build in tasks. Let agents handle the rest.

See the full code in our GitHub repository