DAIV

---

DAIV integrates directly with GitLab and GitHub through webhooks — no new tools to adopt, no context-switching. Beyond your Git workflow, DAIV plugs into your editor over MCP and ships with an optional self-hosted dashboard to chat with the agent, start and watch runs, schedule jobs, and review what changed. You host it, you pick the model, and every task executes in an isolated sandbox whose network access you define.

Three ways to put DAIV to work

In your Git platform — webhooks, zero setup

• Issue Addressing — DAIV reads a labelled issue, proposes a plan, and — once you approve — opens a merge/pull request with the implementation.
• Pull Request Assistant — answers reviewer comments, applies requested changes, and repairs failing CI/CD pipelines, all inside the merge/pull request thread.
• Slash Commands & Skills — invoke /plan, /code-review, /help, and your own custom skills straight from issues and merge requests.

From your editor and pipelines

• MCP Endpoint — connect Claude Code, Cursor, or Codex CLI over the Model Context Protocol and delegate tasks without leaving your editor.
• Jobs API — trigger agents programmatically from CI, scripts, or other tools, then poll for the result.

From the dashboard

• Sessions — a unified workspace and history: chat with the agent live, start background runs, and see every execution — webhook, API, MCP, scheduled, or manual — in one list, with retries.
• Scheduled Jobs — run agents on any cron schedule: dependency audits, code-quality scans, stale-branch cleanup, and more.
• Sandbox Environments — define a reusable runtime once: base image, CPU/memory, network egress policy, and encrypted secrets, scoped to the repositories you choose.
• Per-run model & effort — pick the LLM and thinking effort for each run.
• Notifications — know the moment work finishes, via the in-app bell, email, or Rocket Chat.
• Merge Metrics — track code velocity with commit-level DAIV-vs-human attribution.

Quick example

1. You create an issue: "Add rate limiting to the API endpoints"
2. DAIV posts a plan: Analyzes the codebase and proposes implementation steps
3. You approve: Comment @daiv proceed
4. DAIV implements: Creates a merge request with the code changes
5. Reviewer asks for changes: "@daiv use Redis instead of in-memory storage"
6. DAIV updates the code: Modifies the implementation and pushes

Under the hood

DAIV is powered by Deep Agents, a general-purpose deep-agent framework built on LangGraph with sub-agent spawning, a middleware stack, and a virtual filesystem. On top of it, DAIV adds:

• Subagents — specialized agents for fast codebase exploration and complex multi-step tasks.
• Sandbox — secure command execution for tests, builds, linters, and package management inside an isolated Docker container.
• MCP Tools — external integrations over the Model Context Protocol, such as Sentry for error tracking.
• Monitoring — trace every agent execution with LangSmith to analyze performance and spot issues.
• Scalable Workers — background workers scale horizontally by adding replicas, with a dedicated scheduler for recurring jobs.
• LLM Providers — run on OpenRouter, Anthropic, OpenAI, or Google — your keys, your choice.

Technology Stack

• Agent Framework: Deep Agents — the core agent engine powering DAIV. A general-purpose deep agent with sub-agent spawning, middleware stack, and virtual filesystem. Built on LangGraph.
• Backend Framework: Django for building robust APIs and managing database models.
• Async Tasks: Django Tasks with the django-tasks-db backend and django-crontask for periodic scheduling.
• Code Executor: Sandbox for running commands in a secure sandbox to allow the agents to perform actions on the codebase.
• Observability: LangSmith for tracing and monitoring all the interactions between DAIV and your codebase.
• Error Handling: Sentry for tracking and analyzing errors.

Getting Started

git clone https://github.com/srtab/daiv.git && cd daiv
make setup                 # creates config files from templates

Add at least one LLM provider key to docker/local/app/config.secrets.env — it is read at container start — then bring the stack up:

docker compose up --build  # db, redis, app, worker, worker-interactive, scheduler

• Running DAIV for real → Deployment, then Platform Setup to connect GitLab or GitHub.
• Developing DAIV → CONTRIBUTING.md covers Compose profiles, the local GitLab instance, webhooks, tests, and linting.

Roadmap

• Configurable hooks — run DAIV on specific events with user-defined triggers and actions.
• Chrome extension — interact with DAIV directly from the git platform without leaving the browser.
• Custom MCP servers — user-defined MCP servers via a JSON config file following the Claude Code .mcp.json standard.
• Scheduled maintenance tasks — run DAIV on a cron schedule for tasks like dependency updates, security scans, or documentation drift detection.
• Notifications — in-app, email, and Rocket Chat delivery shipped; Slack, Discord, and Microsoft Teams planned.
• Self-hosted LLM support — enable local model inference via Ollama or vLLM for air-gapped or cost-sensitive environments.

Contributing

We welcome contributions! Whether you want to fix a bug, add a new feature, or improve documentation, please refer to the CONTRIBUTING.md file for more information.

License

This project is licensed under the Apache 2.0 License.

Support & Community

For questions or support, open an issue. See the Community page for contribution paths and project links.