If v2.0.0 was about building out the reliaibility, robustness, and extensibility of DAAF's core analytical engine, v2.1.0 is about making it actually easy to set up, run, and maintain for real-world workflows and collaboration. For example, the original installation process asked users to juggle Docker commands, download and unzip GitHub repos, and manage the Docker volume filesystem. That friction was one of the biggest barrier to adoption, and this release implements a huge number of quality-of-life improvements to fix that. A single command now handles the entire installation. Named helper scripts replace every Docker incantation you'd need to remember and handles all of the back-end container management for you. A one-line update system means you can stay current without losing your work, regardless of when you installed DAAF for the first time. And a new session log viewer gives you a window into what DAAF is actually doing every step of the way, which is crucial for diagnostics and intuition when using the system.

Beyond the operations story, this release also sets up a number of smaller infrastructural improvements -- for example, specialist agents can return more detailed findings, and I've implemented a code-testing pipeline to help ensure every release of DAAF ships without unexpected issues or bugs. More details for the highlights of this release are listed out below!

One-Line Installer

DAAF can now be installed with a single command on both macOS/Linux and Windows. The previous multi-step manual process has been replaced by a one-line installer that handles everything automatically -- downloading the necessary files, building the Docker image, and setting up your workspace. Getting started with DAAF and Claude Code in a secure, well-curated, and fully reproducible environment for research has never been easier! This took a LOT of experimentation and testing, since these scripts are designed to be run on your computer, and I had to account for various versions of Windows, MacOSX, etc. etc. which is quite a headache.

Helper Scripts for Everyday Operations

A complete suite of "helper" convenience scripts (available for both macOS/Linux and Windows) now makes it painless and straightforward to handle the most common DAAF operations. Instead of remembering Docker commands, you can simply run a script:

• run_daaf -- Start DAAF and Claude Code (automatically sets up the docker container and runs the main commands for you)
• update_daaf -- Update to the latest DAAF version available, backing up your work automatically before making changes, and helping you integrate framework changes and customizations together (more on that below)
• backup_daaf / restore_from_backup -- Save and restore snapshots of your entire DAAF workspace effortlessly. Also allows for painless sharing of entire repositories with colleagues!
• rebuild_daaf -- Rebuild the Docker image when needed to update configurations, library installs, updates, etc.
• view_logs -- Open the session log viewer in your browser to easily inspect and view what DAAF is doing at every step of its work (more on that below)
• run_vscode -- Open a full VS Code editor in your browser for browsing, editing, uploading, downloading, and reviewing files inside the container (more on that below)
• view_notebooks -- Open Marimo to browse your analysis notebooks

Every script has both a Bash (.sh, for MacOSX and Linux) and PowerShell (.ps1, for Windows) variant, and all are covered by automated tests and quality checks. This was, by far, the most time-consuming part of this release -- making cross-platform shell scripts that work reliably across macOS, Linux, and Windows is genuinely hard, and the number of edge cases to navigate and problem-solve for was humbling. I suspect there will still be some issues that I couldn't identify on my own, so please do let me know what errors and problems you encounter!

Update and Migration Pathway

Existing DAAF users can now update to the latest version without losing their work or framework customizations in a very guided process. The update_daaf script automatically backs up your workspace before making any changes and uses intelligent file-change detection to handle file conflicts gracefully -- leaning on Claude Code itself to help resolve conflicts between your customizations and new framework updates.

For anyone coming from an older version that doesn't have this script built-in (so anything before this very release), a dedicated migrate_daaf script detects your installation type, connects you to the update process, and gets everything organized in a guided walkthrough. Check the Installation and Quickstart guide for details -- just one line of code to run in your terminal to get caught up.

Session Log Viewer

A new in-browser session transcript viewer makes it much easier to see what DAAF is doing under the hood and to diagnose issues when they arise. You can browse past sessions, search across transcripts, filter by session, and inspect individual tool calls -- all from a clean web interface. Launch it with the view_logs helper script. This has been genuinely useful for development too -- being able to trace exactly what happened in a subagent's session has saved hours of debugging.

In-Browser VS Code (code-server)

DAAF now ships with a full VS Code editor (code-server) that runs inside the container and opens right in your browser. Before this, if you wanted to look at files DAAF produced -- scripts, data, reports, logs -- your options were scrolling through the terminal, digging through Docker Desktop's clunky file browser, or copying files out to your host machine. None of that is a great experience when you're trying to review an analysis or understand what happened during a session.

Now you just run run_vscode from your installation folder and a complete file editor and browser environment opens in your browser -- file tree, syntax highlighting, search across files, Git history, upload and download files, all of it. It comes pre-loaded with nine extensions (Python, GitLens, Git Graph, Rainbow CSV, Markdown support, and more) and a clean dark theme, so it's ready to use immediately. Everything stays inside the container's security boundary, and you don't need to change anything on your own computer to manage it.

This is one of those changes that sounds minor on paper but makes a huge difference in practice. DAAF produces a lot of artifacts over the course of a session, and being able to browse and inspect them in a real editor — instead of one file at a time in the terminal — makes reviewing work dramatically more natural. It's also a much friendlier way to explore the framework itself if you're learning how DAAF works or building new skills and agents.

Environment Variable Support

DAAF now supports secure environment variable configuration via an environment_settings.txt file that lives on your host machine (outside the container and inaccessible to Claude). You can set API keys for Claude Code authentication, data source access, and alternative providers -- all in one place. The file is automatically loaded at container startup, and DAAF's safety system prevents Claude from ever reading or accessing it directly. An annotated example template (environment_settings_example.txt in your daaf-docker/ folder) walks you through every option.

OpenRouter Support (Experimental)

DAAF now supports running Claude Code through OpenRouter as an alternative to a direct Anthropic API key, opening the door for greater model and provider flexibility. Configuration is handled entirely through the environment_settings.txt file -- no code changes needed. Context window detection was also updated to correctly query OpenRouter's API for the real context length of whatever model you're running. Note: This integration is experimental. It works, but you may encounter rough edges. Direct Anthropic API access remains the recommended and most reliable option.

Preliminary Phase Notes Persistence

Specialist agent findings (source research, data profiling, synthesis) are now saved to disk as complete markdown files in output/preliminary_notes/. Previously, DAAF's coordinator held compressed summaries in its own working memory -- which meant later stages of analysis were working from shortened versions of earlier findings. Now the full findings are saved to a file and later agents read directly from that file, so nothing is lost to summarization. This is a quiet change, but it meaningfully improves analytical continuity across long sessions.

Shell Scripting Skill

A new shell-scripting skill teaches Claude the conventions and standards used across all of DAAF's helper scripts -- covering Bash, PowerShell, error handling, testing, and cross-platform gotchas. Five reference files (~2,200 lines total) cover everything from script templates to testing patterns. This means that when DAAF needs to write or modify shell scripts (or when contributors submit new ones), they'll follow consistent, well-tested patterns.

Automated Testing and Quality Checks

New automated pipelines run on every proposed code change to help ensure that DAAF's helper scripts remain reliable as the project evolves:

• Script quality scanning catches common scripting errors and enforces DAAF-specific conventions automatically on every code change
• Unit test suites verify that both the Bash and PowerShell variants of every helper script behave correctly in isolation
• Full lifecycle tests exercise the complete workflow -- install, run, backup, update, rebuild, and migrate -- in a fresh Docker environment to catch problems that only appear when everything runs together
• **Pre-commit ch...

What's Changed

Minor revisions (v2.0.1): Adds an explicit "User Support Mode" as DAAF's 9th engagement mode (with better documentation reading/routing for a variety of issues/questions related to DAAF, Claude Code, Docker, and Git), hardens session archiving in the event of accidental crash or unintended closes/session termination, improves user documentation with diagrams and extended content, and archives complete session logs for both sample projects (college selectivity analysis) for better transparency and future educational materials.

Full Changelog: v2.0.0...v2.0.1

Data Analyst Augmentation Framework — Gaining Altitude Release

DAAF v2.0.0 is a ground-up architectural overhaul driven by four reinforcing goals: greater extensibility and customizability, broad methodological capability expansions, heightened alignment with reproducibility best practices as the default, and improved token efficiency. The v1.0.0 framework worked, but it was overly monolithic and fragile; every session loaded thousands of lines of workflow documentation regardless of the task, and adding new capabilities (data domains, analytical methods, engagement patterns) required modifying deeply entangled files ad hoc every single time. v2.0.0 decomposes the system into modular, progressively-disclosed components that load just-in-time, so the orchestrator and agents see only what they need for the current task/mode at hand. This same modularity makes the framework straightforwardly extensible: new data domains, analytical skills, engagement modes, and agent types can be added by authoring self-contained files and running a registration checklist. Not only that, but the new Framework Development mode makes all of these processes and updates happen basically without effort; the meta-improvement systems are working fantastically (having used it extensively for this release!). The net effect is a system that uses context more efficiently, adheres to its own protocols more reliably, can cover far more methodological territory, and scales to new research domains without architectural friction. Finally, the addition of new modes like Ad Hoc Collaboration and Reproducibility Verification begin to move DAAF from a nascent proof-of-concept to a tool that can start to genuinely add value across many domains of the research and science community.

The Headline Changes

• Architecture: CLAUDE.md shrinks from ~1,800 lines to ~500 lines of universal conventions. Orchestration logic moves into a dedicated daaf-orchestrator skill with reference files loaded just-in-time — so a light-lift Data Lookup session never loads the 1,950-line Full Pipeline spec. Monolithic workflow documentation is split into phase-specific files, each loaded only when the orchestrator reaches that phase. The research Plan document is decomposed into 3 purpose-specific files (Plan, Plan_Tasks, State), allowing the orchestrator to hold strategy and status in context while referencing task details by path.

• Engagement Modes: 4 to 8. New modes: Data Onboarding (formerly Data Ingest, now a full orchestrated mode with API acquisition and multi-file support), Ad Hoc Collaboration, Reproducibility Verification, and Framework Development modes. Existing modes of Data Lookup (renamed from Targeted Assist), Data Discovery (renamed from Discovery), and Full Pipeline are greatly improved across the board.

• Analytical Skills: 7 new library skills + 2 translation skills. Each skill follows the same SKILL.md + deep references architecture, so adding support for a new library is a matter of authoring — not framework modification. New skills: statsmodels, pyfixest, linearmodels, scikit-learn (unsupervised + supervised + fairness), geopandas, svy (complex survey analysis), science-communication, plus a major expansion of the data-scientist methodology skill with 8 new reference files covering causal inference, descriptive analysis, survey analysis, geospatial, unsupervised, supervised ML, and statistical modeling. Two cross-language translation skills (r-python-translation, stata-python-translation) enable inline code annotations for users coming from R or Stata backgrounds, powered by a persistent user language preference system.

• Citation Propagation and Verification. A distributed citation flow spans the entire pipeline: 13 skills carry canonical citation blocks with inclusion thresholds, the research-executor tracks citations as it works, the orchestrator accumulates them in STATE.md, and the report-writer renders a four-subsection References section with rationale lines. A centralized CITATION_REFERENCE.md index covers ~30 methods and tools. A pre-launch audit verified 1,005 references across 46 files and corrected 58 errors (fabricated authors, incorrect API claims, deprecated parameters, dead URLs).

• Claude Code Platform Adaptations. Systematic adjustments to DAAF's infrastructure based on testing against Claude Code's actual runtime behavior: a new search-agent replaces generic Plan dispatches (which lacked reasoning depth), subagent transcripts are now archived alongside orchestrator sessions, the 250-character frontmatter truncation limit is accommodated with a two-tier description architecture, the Dockerfile is fully pinned and smoke-tested, and audit logs now carry per-agent identity for traceability.

• Agent Architecture: All agents relocated to .claude/agents/ for native Claude Code discovery. Named agent dispatch replaces generic subagent_type, so each agent loads exactly its own protocol and preloaded skills — no wasted context on irrelevant behavioral instructions. Per-agent hook enforcement (enforce-file-first.sh) mechanically blocks direct Python execution in coding agents, ensuring protocol adherence at the infrastructure layer rather than relying on prompt compliance alone.

• Research Integrity: AI Use Disclosure section (GUIDE-LLM aligned) added to all reports. CITATION.cff for machine-readable software citation. Session metadata tracking (DAAF version, model ID, timestamps). Session log collection utilities. First-time user transparency statement on LLM limitations and researcher responsibility.

• Self-Modification: Framework Development mode + framework-engineer agent + FRAMEWORK_INTEGRATION_CHECKLIST.md make DAAF formally self-extensible. New skills, agents, and modes can be added through structured authoring and a registration checklist — the framework is designed to grow without requiring core rewrites.

Painfully Detailed Changelog

Note that Claude absolutely had to help me write most of this, there were like 100 commits to shift through major changes on.

Reading lens: Nearly every change below serves one or both of two goals. Token efficiency: reducing what gets loaded into context so agents see only relevant instructions and adhere to them more reliably. Extensibility: making it easy to add new data domains, analytical methods, engagement modes, and agent types without modifying core framework files. These goals reinforce each other -- modular components are both cheaper to load and easier to extend.

1. Core Architecture Streamlining

1.1 Orchestrator Extraction and Progressive Disclosure

The most fundamental change in v2.0.0 is the extraction of orchestration logic from CLAUDE.md into the daaf-orchestrator skill (SKILL.md + 9 reference files). CLAUDE.md retains only universal execution philosophy, code style rules, project conventions, and safety boundaries -- content that applies to all agents equally. The orchestrator skill handles mode classification, user communication, subagent dispatch, and workflow coordination.

This enables far better progressive disclosure: the orchestrator loads only the reference file for the confirmed engagement mode, rather than ingesting thousands of lines of workflow documentation upfront. Each mode reference file is self-contained with its own invocation templates, gate definitions, PSU (Phase Status Update) templates, and escalation triggers.

Had to figure out a way to ensure that the daaf-orchestrator skill correctly got loaded only by the LLM assistant interacting directly with the user, and ensure that it does so reliably regardless of how the user starts the conversation (via some reminder hooks and checks). This'll be one of those things that's unfortunately annoyingly hard to port to other systems, because the way this works is currently very Claude Code specific. See 4.2 below for more information.

1.2 Workflow Phase Decomposition

The monolithic 02_WORKFLOW_STAGES.md (1,628 lines) and 03_SKILL_INVOCATIONS.md (1,847 lines) are replaced by five phase-specific workflow files for the Full Pipeline Mode:

Each file contains stage-specific invocation templates, gate criteria, verification checklists, and PSU content. The orchestrator loads them progressively as execution advances through phases, which makes session restarts far more efficient and focused, with better instructional adherence along the way.

Data Onboarding also receives its own progressive workflow files in the same manner, now that it's been upgraded to a full-fledged mode

• WORKFLOW_PHASE_DO_PROFILING.md (~855 lines) — Parts A-D profiling protocol
• WORKFLOW_PHASE_DO_AUTHORING.md (~270 lines) — Skill authoring and validation

1.3 Plan Document Decomposition

The research Plan document is split into three purpose-specific files:

This separation allows the orchestrator to hold Plan.md and STATE.md in full context while referencing Plan_Tasks.md only by pa...

Data Analyst Augmentation Framework — Launch Release

The initial public release of DAAF, an open-source, extensible AI-augmented research workflow for Claude Code that allows skilled researchers to rapidly scale their expertise and accelerate data analysis -- without sacrificing transparency, rigor, or reproducibility.

What's Included

Core Framework

• Multi-stage research pipeline with mandatory validation and quality checkpoints at every stage
• Specialized agents that tackle each stage of the research pipeline with specific insights, strategies, and expertise (e.g., research-executor, code-reviewer, data-planner, plan-checker, data-verifier, source-researcher)
• Per-script QA with adversarial code review where every transformation has a validation, and all data operations are stored in a file-first format for maximum auditability

Skills Ecosystem

• Analytical tools for data analysis: Polars, plotnine, Plotly, marimo, data-scientist
• Data sources: 15 source-specific data skills (CCD, IPEDS, CRDC, Scorecard, EDFacts, MEPS, SAIPE, FSA, NHGIS, NCCS, PSEO, EADA, NACUBO, Campus Safety) plus query, explorer, and context skills, to answer hundreds of meaningful research questions about education out-of-the-box
• Extensibility tools to easily expand the data domains to any field/dataset you need

Documentation

• User guides: installation/quickstart, understanding DAAF, best practices, extending DAAF, philosophy FAQ, technical FAQ
• 10-minute demo video walkthrough
• Complete example project for review (College Graduation Rate Selectivity Analysis)

Infrastructure

• Docker containerized environment with defense-in-depth security
• Pre-commit hooks, audit logging, session archiving
• LGPL-3.0 license (core framework open; extensions can be proprietary)

Getting Started

See Installation & Quickstart for a 5–10 minute setup guide.

Extending to New Domains

DAAF ships with U.S. education data as its demonstration domain, but the framework is domain-extensible. See Extending DAAF for guidance on adding new data sources, analytical tools, and specialized agents.