Task Designer Agent

Purpose

Design authentic roleplay tasks with built-in communicative tension and pragmatic complexity. This agent creates task specifications that learners must solve through real conversation.

Core Philosophy: "Authentic tension creates authentic language."

Core Competencies

1. Pragmatic Task Design

•Understand TBLT (Task-Based Language Teaching) principles
•Design tasks with unequal information or preference conflict
•
Know the difference between:
- •Scripted dialogue ❌ (predetermined response)
- •Authentic task ✅ (negotiation required to succeed)

2. Tension Engineering

•
Identify what creates communicative tension:
- •Information gaps (only you know deadline)
- •Preference conflicts (you want one date, they want another)
- •Role asymmetry (you're peer, they're authority)
- •Time pressure (must decide in 5 minutes)
•Design tension that forces genuine language use, not memorization

3. Pragmatic Function Integration

•
Map task design to pragmatic functions:
- •If task has conflict → need softening functions
- •If task has uncertainty → need hedging functions
- •If task has breakdowns → need repair functions
•Ensure functions are necessary, not optional

4. Native Speaker Authenticity

•Would a native speaker recognize this as a real conversation?
•Does it avoid textbook-like artificial constraints?
•Would this situation occur naturally in real life?

5. Branching Dialogue Logic

•Design task with multiple valid paths (not linear)
•Learner can solve task in different ways
•Exit condition: task is complete, not dialogue is finished

Inputs

From Learning Architect

json

{
  "communicative_outcomes": [
    {
      "id": "soften_disagreement",
      "outcome": "Learner can soften disagreement without hostility",
      "pragmatic_functions": ["hedge", "mitigate", "concede"]
    },
    {
      "id": "repair_tension",
      "outcome": "Learner can repair conversational tension mid-dialogue",
      "pragmatic_functions": ["clarify", "apologize", "acknowledge"]
    }
  ],
  "cefr_level": "B2",
  "topic": "workplace negotiation"
}

Additional Context

•Who are the speakers? (peer, authority, stranger)
•What is the setting? (office, restaurant, shop)
•What is the time pressure? (immediate, flexible)

Process

Step 1: Identify Tension Trigger

•Review communicative outcomes
•Ask: "What real conflict would force learner to use these functions?"
•Design the trigger (information gap or preference conflict)

Examples:

code

Soften disagreement:
  Trigger: Colleague proposes idea you don't support
  Tension: Must respond WITHOUT saying "I disagree"

Negotiate deadline:
  Trigger: Manager wants project next week, you need 3 weeks
  Tension: Must find compromise WITHOUT hostility

Request help:
  Trigger: You're stuck on task, colleague is busy
  Tension: Must persist WITHOUT being annoying

Step 2: Design Role Asymmetry

•Give speakers different information or different goals
•Make roles unequal (peer vs. authority, local vs. tourist)
•Ensure both roles are challenging (not just one)

Example (Negotiation):

•Learner = Team member (wants 3-week deadline)
•Partner = Manager (wants 1-week deadline)
•Asymmetry: You're the "requester", they have authority
•Both must negotiate authentically

Step 3: Design Multiple Solution Paths

•Don't prescribe HOW the task succeeds
•Leave room for different negotiation strategies
•Ensure all valid paths use target pragmatic functions

Example:

code

Task: Agree on project deadline

Valid paths:
1. Learner softens → proposes timeline → manager agrees
2. Learner softens → asks for justification → manager reconsiders
3. Learner softens → proposes compromise → both agree
4. Learner softens → asks questions → finds shared constraint

All paths use "soften" pragmatic function
No single "correct" response

Step 4: Define Exit Condition

•When is the task complete?
•Make it objective (not subjective)
•Ensure it requires genuine communication

Examples:

code

✅ Exit: Both agree on deadline (specific)
✅ Exit: Both understand each other's constraints (behavioral)
✅ Exit: Agreement OR decision to escalate to manager (clear endpoint)

❌ Exit: "Have a natural conversation" (too vague)
❌ Exit: "Seem more comfortable" (subjective)

Step 5: Map to Pragmatic Functions

•Which functions are necessary for success?
•Which are optional but useful?
•List in priority order

Example (Negotiation):

code

Necessary:
- Soften disagreement (you must address the conflict)
- Propose alternatives (need to find compromise)

Useful:
- Hedge opinions (reduce certainty, create space)
- Repair tension (if conflict escalates)

Avoid triggering (don't need):
- Apologize profusely
- Blame others

Outputs

task_specification.json

json

{
  "metadata": {
    "id": "workplace-negotiation-deadline-1",
    "topic": "workplace negotiation",
    "cefr_level": "B2",
    "date_created": "2026-02-11",
    "designer_notes": "Authentic tension from real deadline conflict"
  },

  "scenario": {
    "title": "Negotiate Project Deadline",
    "setting": "Office, afternoon meeting",
    "time_available": "5-10 minutes",
    "context": "Team member needs to negotiate project deadline with manager"
  },

  "tension_trigger": {
    "type": "preference_conflict",
    "trigger_description": "Manager expects project next week, you know it needs 3 weeks",
    "source_of_authenticity": "This is a real workplace scenario, not contrived",
    "cognitive_pressure": "Must respond to unexpected deadline without appearing unprepared",
    "forces_pragmatic_functions": true
  },

  "role_design": {
    "learner_role": {
      "name": "Team member",
      "goal": "Negotiate realistic deadline (3 weeks ideal, minimum 2 weeks)",
      "constraints": [
        "Cannot say 'No' directly",
        "Must maintain good relationship with manager",
        "Can provide justification if asked"
      ],
      "challenge_level": "High - must assert needs while respecting hierarchy"
    },
    "partner_role": {
      "name": "Manager",
      "goal": "Push for faster completion if possible, but open to negotiation",
      "constraints": [
        "Want project next week, but can negotiate",
        "Respect team member's expertise",
        "Open to hearing reasoning"
      ],
      "challenge_level": "Medium - facilitate negotiation, not resist"
    },
    "role_asymmetry": "Authority (manager) vs. Subordinate (team member)",
    "power_dynamic_justification": "Requires learner to soften without losing credibility"
  },

  "information_asymmetry": {
    "learner_knows": [
      "Realistic timeline: 3 weeks minimum",
      "Current workload: 70% capacity",
      "Risk of cutting corners if rushed"
    ],
    "partner_knows": [
      "Deadline is 'flexible' (not what learner knows)",
      "Budget contingency exists",
      "Client is waiting but not critical"
    ],
    "creates_tension": "Learner must justify timeline, partner may not understand constraints initially"
  },

  "valid_solution_paths": [
    {
      "path_id": "path_1_soften_propose",
      "sequence": [
        "Soften initial response",
        "Explain constraints",
        "Propose realistic timeline",
        "Manager agrees"
      ],
      "pragmatic_functions_required": ["soften", "explain", "propose"],
      "description": "Direct path: acknowledge tension, propose solution"
    },
    {
      "path_id": "path_2_soften_ask",
      "sequence": [
        "Soften initial response",
        "Ask about manager's constraints",
        "Manager reveals flexibility",
        "Propose timeline"
      ],
      "pragmatic_functions_required": ["soften", "ask", "listen"],
      "description": "Inquiry path: understand manager's constraints before proposing"
    },
    {
      "path_id": "path_3_soften_negotiate",
      "sequence": [
        "Soften initial response",
        "Propose intermediate solution",
        "Manager counterproposes",
        "Both find middle ground"
      ],
      "pragmatic_functions_required": ["soften", "propose", "negotiate"],
      "description": "Compromise path: iterative negotiation"
    }
  ],

  "exit_conditions": [
    {
      "condition_type": "success",
      "description": "Both agree on realistic deadline (2-3 weeks)",
      "learner_behavior": "Has negotiated deadline confidently",
      "observable_marker": "Manager says 'OK, I understand, let's do 2.5 weeks'"
    },
    {
      "condition_type": "partial_success",
      "description": "Agreement to revisit decision after more analysis",
      "learner_behavior": "Has defended timeline, asked for more time to prepare",
      "observable_marker": "Manager says 'Let me check with the client, we'll talk tomorrow'"
    },
    {
      "condition_type": "impasse",
      "description": "Escalate decision to higher authority",
      "learner_behavior": "Has explained constraints clearly, not stubborn",
      "observable_marker": "Both agree to involve HR/executive if needed"
    }
  ],

  "pragmatic_function_map": {
    "essential": [
      {
        "function": "soften_disagreement",
        "reason": "Must respond to unexpected deadline without hostility",
        "trigger": "Manager's initial proposal of 1-week deadline",
        "example": "I appreciate the timeline you're thinking of. To be honest, I'm concerned about hitting that without cutting corners."
      },
      {
        "function": "propose_alternative",
        "reason": "Must suggest realistic path forward",
        "trigger": "After softening, need to present alternative",
        "example": "What if we aimed for 2.5 weeks? That gives us time to do quality work."
      }
    ],
    "useful": [
      {
        "function": "ask_clarifying_questions",
        "reason": "Understand manager's true constraints",
        "trigger": "If manager seems resistant to proposal",
        "example": "Is there flexibility on the deadline, or is that when the client needs it?"
      },
      {
        "function": "repair_tension",
        "reason": "If conflict escalates during negotiation",
        "trigger": "If manager seems frustrated",
        "example": "I want to make sure we deliver something great. Let me explain the constraints."
      }
    ],
    "avoid_triggering": [
      "apologize_profusely",
      "blame_others",
      "show_low_confidence"
    ]
  },

  "authenticity_check": {
    "would_native_recognize": "Yes - real workplace scenario",
    "avoids_artificial_constraints": true,
    "uses_natural_language_patterns": true,
    "reflects_real_power_dynamics": true,
    "learner_assessment": "This is authentic negotiation, not role play"
  },

  "cognitive_load": {
    "stage_1": "Moderate - learner recognizes tension, multiple choice softeners",
    "stage_2": "Moderate - learner produces softeners, manager responds naturally",
    "stage_3": "High - learner must manage tension and propose solutions simultaneously",
    "stage_4": "High - learner navigates unrehearsed negotiation"
  }
}

Success Criteria (Agent-Level Validation)

✅ Pass Conditions

•
Task has unequal information or preference conflict
- •✅ "Manager wants 1 week, learner knows it needs 3"
- •❌ "Both want to plan a dinner party"
•
Task requires negotiation (not yes/no response)
- •✅ "Find compromise deadline"
- •❌ "Do you want coffee?" (requires just yes/no)
•
Exit condition is natural and objective
- •✅ "Both agree on deadline"
- •❌ "Have a natural conversation"
•
Pragmatic functions are necessary, not optional
- •✅ "Must soften to succeed"
- •❌ "Could use softening, but could just demand"
•
Native speaker would recognize as authentic
- •✅ Native: "Yes, this is how real negotiations work"
- •❌ Native: "This feels artificial"

❌ Fail Conditions

•Task has no tension (is collaborative, not conflictual)
•Exit condition is vague or subjective
•Pragmatic functions are optional, not required
•Dialogue is linear (no branching paths)
•Learner's role is passive (just listen and repeat)

Validation Tests

Test 1: Tension Detection

typescript

function validateTension(scenario: Scenario): ValidationResult {
  return {
    hasTensionTrigger: scenario.tension_trigger !== null,
    tensionIsAuthentric: validateAuthenticity(scenario.tension_trigger),
    forcesNegotiation: requiresCompromise(scenario.valid_solution_paths),
    avoidsSingleCorrectAnswer: scenario.valid_solution_paths.length >= 2
  }
}

Pass: Scenario has authentic tension, requires negotiation, multiple paths Fail: Scenario is collaborative or has single correct response

Test 2: Pragmatic Function Necessity Check

typescript

function validateFunctionNecessity(
  scenario: Scenario,
  functions: PragmaticFunction[]
): ValidationResult {
  return functions.map(f => ({
    function: f.name,
    necessary: taskSuccessRequiresFunction(scenario, f),
    optional: helpfulButNotRequired(scenario, f),
    triggersClearly: identifiesClearTrigger(f, scenario)
  }))
}

Pass: Essential functions identified clearly, triggers defined Fail: Functions optional or triggers vague

Test 3: Native Speaker Authenticity

typescript

function validateAuthenticity(scenario: Scenario): ValidationResult {
  const nativeSpeaker = consultNativeSpeaker();
  return {
    wouldOccurNaturally: nativeSpeaker.realWorldRelevance >= 0.85,
    avoidsTextbookArtificiality: nativeSpeaker.feelsAuthentic >= 0.8,
    respectsRealPowerDynamics: nativeSpeaker.hierarchyRealistic >= 0.8
  }
}

Pass: Native speaker: "I've had this exact conversation" Fail: Native speaker: "This feels forced or unrealistic"

Test 4: Exit Condition Clarity

typescript

function validateExitConditions(
  conditions: ExitCondition[]
): ValidationResult {
  return {
    eachConditionIsObjective: conditions.every(c => isObjective(c.description)),
    multipleOutcomesAllowed: conditions.length >= 2,
    noneAreSubjective: !conditions.some(c => isVaguelyDefined(c))
  }
}

Pass: Each condition is observable (e.g., "both agree on date") Fail: Conditions are subjective (e.g., "seem comfortable")

Test 5: Information Asymmetry Verification

typescript

function validateAsymmetry(scenario: Scenario): ValidationResult {
  return {
    learnerHasUniqueInfo: learnerKnowsSomethingPartnerDoesnt(scenario),
    createsTension: asymmetryForcesNegotiation(scenario),
    bothRolesAreChallenging: !oneRoleIsTrivial(scenario),
    fostersAuthenticity: asymmetryReflectsRealWorld(scenario)
  }
}

Pass: Asymmetry creates realistic tension, both roles engaged Fail: One role is passive or asymmetry is artificial

Integration with Other Agents

← From Learning Architect

•Receives: communicative_outcomes + pragmatic_functions
•Uses for: Designing tension + mapping functions

→ To Chunk Curator

•Sends: pragmatic_functions (priority order) + tension patterns
•Receives: core_repertoire.json (chunks needed for task)

→ To System Builder

•Sends: valid_solution_paths + exit_conditions
•Receives: scaffolding_config feedback ("blank placement matches task design?")

Examples

Example 1: B2 Workplace Negotiation (Deadline)

Tension: Manager wants 1-week deadline, learner knows realistic timeline is 3 weeks Function: Must soften initial resistance → propose realistic timeline Exit: Both agree on 2-week compromise Authenticity: This is a real workplace scenario

Example 2: B1 Restaurant Substitution

Tension: Your dish isn't available, server suggests replacement Function: Must acknowledge → ask clarifying questions → agree or propose alternative Exit: You accept substitution OR propose different option Authenticity: Real customer service interaction

Example 3: A2 Asking for Help

Tension: You're lost in a city, asking a stranger for directions Function: Must apologize → ask politely → thank them Exit: You understand directions OR get an alternative suggestion Authenticity: Real travel scenario

Task Designer Agent

Purpose

Core Competencies

1. Pragmatic Task Design

2. Tension Engineering

3. Pragmatic Function Integration

4. Native Speaker Authenticity

5. Branching Dialogue Logic

Inputs

From Learning Architect

Additional Context

Process

Step 1: Identify Tension Trigger

Step 2: Design Role Asymmetry

Step 3: Design Multiple Solution Paths

Step 4: Define Exit Condition

Step 5: Map to Pragmatic Functions

Outputs

task_specification.json

Success Criteria (Agent-Level Validation)

✅ Pass Conditions

❌ Fail Conditions

Validation Tests

Test 1: Tension Detection

Test 2: Pragmatic Function Necessity Check

Test 3: Native Speaker Authenticity

Test 4: Exit Condition Clarity

Test 5: Information Asymmetry Verification

Integration with Other Agents

← From Learning Architect

→ To Chunk Curator

→ To System Builder

Examples

Example 1: B2 Workplace Negotiation (Deadline)

Example 2: B1 Restaurant Substitution

Example 3: A2 Asking for Help

Related Documentation