aixplain — The operating system for autonomous work

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:

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

Here’s what the format_instructions template includes:

1format_instructions = """
2# FORMAT INSTRUCTIONS
3Your job posting should follow this exact structure:
4## 🚀 Job Title: [TITLE]
5📍 **Location:** [LOCATION]
6🕒 **Employment Type:** [EMPLOYMENT_TYPE]
7💼 **Team:** [TEAM]
8---
9## 📝 About the Role
10[COMPANY_INTRODUCTION]
11[ROLE_OVERVIEW]
12---
13## 🔍 What You'll Do
14- [RESPONSIBILITY 1]
15- [RESPONSIBILITY 2]
16- [RESPONSIBILITY 3]
17...
18---
19## ✅ Qualifications
20**Required:**
21- [REQUIRED QUALIFICATION 1]
22- [REQUIRED QUALIFICATION 2]
23...
24**Preferred:**
25- [PREFERRED QUALIFICATION 1]
26- [PREFERRED QUALIFICATION 2]
27...
28---
29## 🌟 Why Join Us
30- [BENEFIT 1]
31- [BENEFIT 2]
32...
33---
34## 📊 Industry Trends
35[INDUSTRY_TRENDS_PARAGRAPH]
36---
37## 📋 How to Apply
38[APPLICATION_PROCESS]
39"""

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:

1from aixplain.modules.agent.agent_task import AgentTask
2company_analysis_task = AgentTask(
3    name="analyze_company_culture",
4    description="Analyze the company culture, values, and work environment.",
5    expected_output="Detailed analysis of company culture with key values."
6)
7# Role and job post tasks
8role_analysis_task = AgentTask(...)
9job_posting_task = AgentTask(..., dependencies=[company_analysis_task, role_analysis_task])
10industry_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

1from aixplain.modules.agent.tool.model_tool import ModelTool
2search_tool = ModelTool(model="65c51c556eb563350f6e1bb1")
3company_analyst = AgentFactory.create(
4    name="Company Culture Analyst V3",
5    description="Analyzes company culture from job descriptions and external data.",
6    instructions="""You are a Company Culture Analyst...""",
7    tasks=[company_analysis_task],
8    tools=[search_tool],
9    llm_id="67e2f3f243d4fa5705dfa71e"
10)

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:

1from aixplain.factories import TeamAgentFactory
2team = TeamAgentFactory.create(
3    name="Job Posting Analysis Team V5",
4    description="Generates job posts by analyzing roles, companies, and trends.",
5    agents=[company_analyst, role_analyst, job_posting_creator, industry_analyst],
6    use_mentalist=True,  # For dynamic planning
7    use_inspector=True,  # For verifying outputs
8    llm_id="67e2f3f243d4fa5705dfa71e"
9)

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:

1format_instructions = """..."""  # Your Markdown template
2result = team.run(
3    query="Create a job posting for an AI Vibe Coder...",
4    content=format_instructions,
5    output_format=OutputFormat.MARKDOWN
6)
7print(result.data["output"])

The output looks as follows:

1# AI Vibe Coder (AI-Assisted Development Specialist)
2## About Us
3Join 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,
4and collaboration as we explore this exciting new paradigm in software creation.
5## Key Responsibilities
6- Translate business requirements into effective natural language prompts for AI systems
7- Review, refine, and validate AI-generated code outputs
8- Collaborate with traditional developers to integrate AI-generated solutions
9- Continuously develop and improve prompt engineering techniques
10- Document and share best practices for conversational software development
11- Stay current with advancements in AI-assisted development tools
12## Required Qualifications
13- 2+ years experience in software development or AI-assisted coding
14- Proficiency in natural language processing concepts
15- Experience with AI development tools (e.g., GitHub Copilot, ChatGPT)
16- Strong understanding of software development principles
17- Excellent communication and technical documentation skills
18- Creative problem-solving and adaptability to new technologies
19## Preferred Qualifications
20- Familiarity with multiple programming languages
21- Experience with prompt engineering techniques
22- Knowledge of AI model fine-tuning
23- Storytelling ability for requirements description
24- Experience in technical communication or requirements gathering
25## Growth Opportunities
26- Be at the forefront of a new development paradigm
27- Work with cutting-edge AI technologies
28- Shape the future of conversational software development
29- Continuous learning in emerging tech fields
30- Opportunities to publish/present innovative approaches
31## Benefits
32- Competitive compensation package
33- Flexible work arrangements
34- Professional development budget
35- Collaborative, flat-hierarchy team structure
36- Results-oriented work environment
37- Health and wellness benefits
38## How to Apply
39To apply, please submit:
401. Your resume highlighting relevant experience
412. A brief cover letter explaining your interest in 'vibe coding'
423. (Optional) Examples of AI-generated code you've worked with
43We'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

An AI Agent for Job Post Creation