Devika

Devika abstracts multiple LLM providers (Claude 3, GPT-4, Gemini, Mistral, Groq, Ollama) behind a unified interface, allowing runtime selection and swapping without code changes. The LLM Integration Architecture uses a provider registry pattern where each backend implements a common interface for chat completion, token counting, and streaming. Configuration is externalized via config.py, enabling users to specify model, API keys, and provider settings without modifying agent code.

Devika implements a multi-agent system coordinated by AgentOrchestrator that delegates tasks to specialized agents: PlannerAgent (task decomposition), ResearcherAgent (information gathering), CoderAgent (code generation), PatcherAgent (bug fixing), FeatureAgent (feature implementation), and ActionAgent (system actions). Each agent is stateless and receives context via the orchestrator, which maintains InternalMonologue for reasoning continuity. The orchestrator uses a workflow pattern where agents are invoked sequentially or conditionally based on task requirements and agent outputs.

Devika uses a centralized configuration system (config.py) that externalizes all deployment settings: LLM provider selection, API keys, model names, project directories, and feature flags. The configuration supports multiple environments (development, staging, production) through environment-specific config files or environment variables. This allows the same codebase to be deployed across different environments without code changes, and enables users to customize Devika's behavior without modifying source code.

Devika includes a browser widget in the web interface that displays web pages and search results as the ResearcherAgent performs web searches. The widget shows URLs, page content, and extracted information in real-time via Socket.IO updates. Users can see what the AI is researching and verify that the research is relevant and accurate. The widget also allows users to manually navigate to URLs or provide additional research context if needed.

Devika maintains an InternalMonologue component that records the agent's reasoning process throughout task execution. This includes planning decisions, research findings, code generation rationale, and bug-fixing logic. The monologue is persisted and displayed to users, providing a detailed trace of how the AI arrived at its conclusions. Users can review the monologue to understand the AI's decision-making and identify where it may have gone wrong. The monologue is also used by agents to maintain context across multiple LLM calls.

The ResearcherAgent integrates a Search System that performs contextual keyword extraction from task descriptions and web browsing to gather relevant information. The system analyzes the user's request, identifies key concepts, and executes web searches to retrieve documentation, API references, and implementation examples. Results are cached and returned to the CoderAgent to inform code generation. The research capability is integrated into the agent workflow, allowing the system to pause code generation, research dependencies, and then resume with informed context.

The CoderAgent generates code in multiple programming languages (JavaScript, Python, Java, C++, etc.) using LLM-based code synthesis. The system maintains language-specific templates and formatting rules to ensure generated code adheres to language conventions. Code is generated in response to task decomposition from the PlannerAgent and research context from the ResearcherAgent. The generated code is written to the project file system and displayed in the web-based editor widget for user review and modification.

The PatcherAgent automatically identifies and fixes bugs in generated code by analyzing error messages, test failures, and code review feedback. When the CoderAgent generates code that fails tests or produces errors, the PatcherAgent receives the error context, analyzes the root cause, and generates corrective patches. This creates an iterative loop where code is generated, tested, and refined until it passes validation. The patcher maintains a patch history and can apply multiple fixes sequentially.

Devika maintains dynamic state tracking for each agent and the overall task execution, exposing this state through a web-based visualization dashboard. The state includes current agent, task progress, generated code, research findings, and reasoning trace (InternalMonologue). State is updated in real-time via Socket.IO, allowing users to monitor agent activity as it happens. The visualization includes a chat interface, code editor, terminal output, and browser widget showing web research in progress.

Devika organizes work around projects, where each project has its own file system, configuration, and context. The system tracks project metadata (name, description, language, framework), maintains a file index for quick lookup, and manages context windows by selectively including relevant files in agent prompts. When agents need to reference existing code, the system retrieves relevant files based on semantic similarity or explicit imports, avoiding the need to include the entire codebase in every prompt.

Devika provides a web-based chat interface where users submit natural language instructions and receive responses from the agent system. The chat maintains conversation history, allowing users to provide follow-up instructions, corrections, and feedback. Each message is processed by the agent orchestrator, which determines which agents to invoke and in what order. The chat interface also displays agent reasoning, code snippets, and research findings inline, creating a conversational development experience.

Devika includes a web-based code editor widget that displays generated code with syntax highlighting, line numbers, and code folding. The editor is integrated with a terminal widget that allows users to run commands, execute tests, and see output in real-time. When the CoderAgent generates code, it is automatically displayed in the editor. Users can edit code directly in the editor, and changes are reflected in the file system. The terminal allows execution of build commands, test runners, and other development tools.

Devika's agent system is designed to be extensible, allowing developers to create custom agents that inherit from a base Agent class and implement task-specific logic. Custom agents can be registered with the AgentOrchestrator and invoked as part of the workflow. The framework provides utilities for agent communication, state management, and LLM integration, reducing boilerplate code. Agents are stateless and receive context via the orchestrator, enabling easy testing and composition.