Task Affinity

This is the most common driver of task affinity. An agent that has recently processed related data may have cached intermediate results, embeddings, or context in its working memory. Reassigning a follow-up task to the same agent avoids the costly overhead of:

• State transfer between agents over the network.
• Recomputing intermediate results from scratch.
• Re-retrieving context from a shared vector database.

Example: An agent that just summarized a large document has the full text cached; a subsequent task to answer questions about that document should have high affinity for that agent.

Certain agents may be provisioned on infrastructure with unique capabilities, creating a hard affinity constraint. Tasks must be routed to agents with access to the required physical or virtual resources.

Key examples include:

• GPU/TPU/NPU Acceleration: Model inference or training tasks requiring specific AI accelerators.
• Secure Enclaves: Tasks handling PII or regulated data that must execute within a certified confidential computing environment.
• Geographic Location: Tasks with data sovereignty requirements or low-latency needs for a specific region.
• Legacy System Access: Agents with direct API or database connections to isolated on-premise systems.

In distributed systems, network latency can dominate execution time. Affinity based on physical or network topology minimizes inter-agent communication hops.

Strategies include:

• Co-location: Assigning tightly coupled, chatty agents (or agents and their data sources) to the same availability zone, rack, or host.
• Model Parallelism: Keeping different layers of a single large model on agents with high-bandwidth links (e.g., NVLink).
• Sub-task Grouping: Clustering subtasks with high interdependency and assigning the cluster to a single agent or a closely located group to minimize cross-network chatter.

Agents can be permanently or semi-permanently specialized for a task domain, creating a strong affinity. This goes beyond runtime caching to intrinsic capability.

Forms of specialization:

• Parameter-Efficient Fine-Tuning (PEFT): An agent's underlying model is adapted (e.g., via LoRA) for a specific domain (legal, medical, code).
• Tool Proficiency: An agent has deep, practiced experience with a complex external tool or API, reducing error rates.
• Learned Policies: Through Multi-Agent Reinforcement Learning (MARL), an agent develops an optimal policy for a recurring task type, making it uniquely efficient.

Assignment systems must track this capability metadata in an agent registry.

Commercial and operational factors can dictate affinity. Assigning a task to a specific agent may be necessary to comply with licenses or to minimize variable costs.

Examples include:

• Model API Licensing: A task requiring GPT-4 must be sent to an agent configured with that specific API key and endpoint.
• Cost-Aware Routing: Routing simple tasks to smaller, cheaper models (e.g., a Small Language Model) and complex tasks to larger, more expensive ones, based on pre-defined cost-performance thresholds.
• Private Instance Affinity: Ensuring all tasks for a specific client are executed on a dedicated, isolated agent pool for billing and security isolation.

For interactive applications (e.g., AI assistants, customer support bots), maintaining a coherent conversation requires a stateful session. A user's session has high affinity for the agent that initiated it.

This involves managing:

• Conversation History: The agent maintains the dialogue context in its memory.
• User Preferences: Learned preferences or facts about the user during the session.
• Transactional State: For multi-step processes (e.g., booking a flight), the agent holds the state of the partially completed transaction.

Orchestrators use session sticky routing to enforce this affinity, often via a session ID, unless the primary agent fails, triggering state transfer to a backup.

The foundational process of aligning task requirements with agent competencies. While task affinity is a performance-oriented preference, capability matching is a binary prerequisite for assignment.

• Key Distinction: An agent may have the capability to perform a task, but another agent may have a higher affinity for it due to cached state or physical proximity.
• Semantic Matchmaking: Advanced systems use task ontologies to understand the semantic meaning of capabilities beyond simple keyword matching.

A core orchestration strategy that distributes work evenly across resources. Task affinity introduces a critical tension with pure load balancing.

• Optimization Trade-off: A scheduler must balance the performance gain from respecting affinity against the risk of overloading a "preferred" agent, which can create bottlenecks.
• Dynamic Adjustment: Sophisticated systems use utility functions to quantify this trade-off, dynamically deciding when to violate affinity to maintain system-wide throughput and prevent agent starvation.

The set of techniques for maintaining consistent context across distributed agents. Task affinity is often employed to minimize the need for costly synchronization.

• Locality of Reference: Assigning a follow-up task to the agent that processed the initial task leverages its in-memory context, avoiding the latency of reading from a shared database or vector store.
• Cache Affinity: A primary use case where an agent retains a working set of data (e.g., a large language model's KV cache), making it the most efficient candidate for related subsequent tasks.

A classic decentralized negotiation framework for task allocation. Task affinity can be a decisive factor in the bidding phase of this protocol.

• Bid Calculation: When a manager agent broadcasts a task announcement, contractor agents formulate bids. An agent with high affinity (e.g., lower estimated completion time due to local data) can submit a more competitive bid.
• Market-Based Allocation: This protocol is a foundation for market-based allocation systems, where affinity translates into a lower "cost" or higher "utility" in the artificial economy.

The algorithmic process of determining execution order and timing. Task affinity acts as a critical scheduling constraint that influences both assignment and sequence.

• Constraint Satisfaction: Schedulers model affinity as a soft constraint in a Constraint Satisfaction Problem (CSP) or as a term in an Integer Linear Programming (ILP) objective function.
• Real-Time Systems: In real-time task allocation, respecting processor or core affinity is often mandatory to guarantee that timing deadlines are met, as migration overhead can violate schedulability.

A learning paradigm where agents discover coordination policies through interaction. Task affinity can emerge as a learned policy without being explicitly programmed.

• Emergent Specialization: In a MARL system, agents may learn to gravitate towards tasks they handle more efficiently, developing de facto affinities based on their unique experiences and model parameters.
• Nash Equilibrium: The stable state of a learned allocation policy may represent a balance where each agent is assigned tasks for which it has a comparative advantage, aligning with affinity-based optimization.