SylicaParallel Context Execution for Multi-Task AI
Independent time-anchored instruction streams
Abstract
Most conversational AI handles one thing at a time. Human cognition maintains multiple parallel threads: tracking background tasks, monitoring ongoing processes, and handling interruptions. We are formalizing a model where AI can maintain multiple independent context threads, executing them in parallel without cross-contamination.
Problem Statement
Current dialogue systems use a single context window. If a user says 'check my calendar and also start the timer for 10 minutes', the system must serialize these tasks. Long-running tasks block the conversation. Interruptions require context resets. There is no model for true parallel task management with independent state.
Approach
We treat each user instruction as a potential thread with its own context window, state, and execution lifecycle. A scheduler manages thread creation, suspension, resumption, and termination. Threads communicate through explicit message passing rather than shared state, preventing context bleeding. A foreground thread handles dialogue; background threads execute silently.
Thread lifecycle model
Threads are created by explicit user instruction or implicit trigger (e.g., timer expiration). Each thread has: creation time, priority, estimated duration, dependencies, and parent thread. The scheduler uses these attributes plus resource availability to determine execution order.
Context isolation
Each thread maintains its own conversation history and working memory. Cross-thread contamination is prevented by design—there is no shared global context. When a thread completes, its results can be posted to a message bus that other threads may subscribe to, enabling coordination without coupling.
Interruption handling
When a new high-priority thread is created (e.g., urgent notification), the scheduler can suspend the current foreground thread rather than replacing it. The suspended thread's state is checkpointed. When the interrupting thread completes, the previous thread resumes from its checkpoint.
Resource constraints
Unbounded thread creation would exhaust memory and user attention. We implement limits: maximum concurrent threads, maximum thread lifetime, and automatic cleanup of completed threads after result delivery. The user can view and terminate threads through a thread manager interface.
Evaluation framework
We measure task completion rate, response latency for foreground threads, and correctness of parallel execution (no missed state updates). User studies measure cognitive load through task resumption time after interruption and subjective ratings of system responsiveness.