Yourgoal

Implements a BabyAGI-style autonomous task loop that decomposes high-level goals into executable subtasks, prioritizes them in a queue, and iteratively executes them using an LLM backbone. The system maintains a task list, executes the highest-priority task, generates new subtasks based on results, and re-prioritizes the queue in each iteration. This creates a self-improving agent that can tackle complex multi-step objectives without explicit human orchestration.

Abstracts LLM provider interactions through a pluggable interface that supports multiple API backends (OpenAI, Anthropic, local models). Each task execution sends the current task context and previous results to the LLM, receives structured responses, and parses them into executable actions. The engine handles prompt templating, token management, and response parsing without coupling to a specific model provider.

Processes execution results from completed tasks and synthesizes them into new subtasks or goal refinements. The system analyzes what was accomplished, identifies gaps or dependencies, and generates follow-up tasks that move toward the original goal. This creates a feedback loop where each task's output informs the next task's design, enabling emergent problem-solving without explicit branching logic.

Maintains an ordered task queue where tasks are ranked by priority (computed by the LLM or heuristics) and executed in priority order. After each task execution, the queue is re-evaluated and re-prioritized based on new information. This allows the agent to dynamically shift focus toward the most impactful remaining tasks rather than executing a static sequence.

Maintains the original goal statement and execution context throughout the agent loop, passing them to each task execution and synthesis step. The system tracks what has been attempted, what succeeded, and what failed, building a coherent narrative of progress toward the goal. This context prevents task drift and enables the LLM to make informed decisions about next steps.

Uses Swift's async/await concurrency model to orchestrate the task loop, with structured concurrency for managing task execution, LLM API calls, and result synthesis. Each step in the loop is an async function, enabling clean error handling, cancellation support, and potential future parallelization of independent tasks without callback hell.

Stores all task state (definitions, results, status, priority) in memory using Swift data structures (arrays, dictionaries, custom types). The system maintains a single source of truth for the task queue and execution history during the agent's lifetime. State updates are synchronous and immediate, with no persistence layer by default.