Summary: What is DAAF?

LLM-based AI assistants are becoming increasingly capable, but they are always at risk of hallucination, sycophancy, over-confidence, and laziness. So can these flawed and non-deterministic tools ever be useful for conducting rigorous data analysis?

Yes -- but only with the right guidance, right guardrails, and in expert hands to direct all core decisions and verify all key outputs.

Enter DAAF, the Data Analyst Augmentation Framework. DAAF is a free and open-source instructions framework for Claude Code that helps skilled researchers deepen and extend their expertise across any domain of data analysis with AI assistance -- while enhancing the transparency, rigor, and reproducibility that good science demands. DAAF sits between you and Claude Code to automatically and consistently help Claude think more like a responsible and rigorous researcher by:

• Enforcing strict auditability and reproducibility standards for all work, thus allowing you to verify everything Claude does on your behalf
• Preventing potentially dangerous unintended file access and editing, by sandboxing Claude with strict protections and logging traces
• Setting high standards of care, rigor, and thoroughness in all data analysis, by forcing Claude to comment, verify, and review all analytic code before you ever see it
• Embedding best practices for a wide variety of research methodologies like causal inference and geospatial analysis, by providing rich Skills (reference manuals Claude loads on demand when a task calls for them) that extend Claude's base capabilities with real research and resources
• Collaborating with you, the human expert, directly on all key decisions, thus keeping you firmly in the driver's seat

Think of it as a force-multiplying exoskeleton for human researchers -- a tool explicitly designed to augment your hard-earned expertise, not replace it. The goal is to make it easy for researchers to use Claude Code effectively and responsibly. Importantly, DAAF is not and will never be perfect -- but it is already immensely useful, and this is the worst a tool like DAAF will ever be from now on with the help and support of the broader research community.

Install and begin using it in as little as 10 minutes from a fresh install with an Anthropic account, an OpenRouter API key, or an OpenAI account.

New to DAAF? Start with the Getting Started video below -- a full tutorial that walks you through the entire installation and gets you oriented to the whole environment, from the Docker setup and Claude Code to DAAF itself. Or read on for more information!

Project Homepage  |  Getting Started video (30 min)  |  Installation Guide  |  User Documentation Reference  |  Open Augments Field Guide Substack  |  Contributing to DAAF

---

Quick Start

If you're already comfortable with the Terminal and Claude Code, you can get started almost immediately using the Quick Start instructions below. Otherwise, I recommend starting with the full Installation Guide for beginner-friendly details, prerequisites, and troubleshooting.

Requirements: Docker Desktop (running) and an account with one of the supported AI providers:

• Anthropic subscription (Max at $100/mo or Ultra at $200/mo recommended; verified against Anthropic's pricing page on 2026-11-01) — flat-rate, best value for heavy use.
• Anthropic API key — pay-per-use; no subscription, but a full analysis can run $50+.
• OpenRouter — pay-per-token, no subscription; provides access to Anthropic models plus high-performing open-weight alternatives like GLM 5.2; a supported route that benefits from wider community testing.
• OpenAI API key or ChatGPT subscription — run DAAF on GPT models through DAAF's provider shim, a small translator built into DAAF (you turn it on in environment_settings.txt and restart the container); supported routes that benefit from wider community testing (see Option F in the Installation Guide).
• AWS Bedrock or Google Vertex AI — route through your organization's cloud platform; DAAF ships configuration templates, but these routes aren't maintainer-validated end-to-end (see Using DAAF with Sensitive or Regulated Data).

Open a terminal in your desired installation directory.

macOS / Linux (Terminal):

# Install DAAF (downloads Docker build files, builds image, clones repo into container)
curl -fsSL https://raw.githubusercontent.com/DAAF-Contribution-Community/daaf/main/scripts/host/install.sh | bash

# Enter the installation folder and open the DAAF Control Panel
cd daaf-docker
bash daaf.sh

Windows (PowerShell):

# Install DAAF (downloads Docker build files, builds image, clones repo into container)
irm https://raw.githubusercontent.com/DAAF-Contribution-Community/daaf/main/scripts/host/install.ps1 | iex

# Enter the installation folder and open the DAAF Control Panel
cd daaf-docker
.\daaf.ps1

Using OpenRouter, Bedrock or Vertex? Before you start Claude Code, add your provider settings to environment_settings.txt in your daaf-docker folder, then choose 11) Restart Container in the Control Panel. The Installation Guide shows what to add: Configure authentication via environment_settings.txt.

Using OpenAI or ChatGPT? Before you start Claude Code, set up DAAF's provider shim. With an OpenAI API key, follow Option F in the Installation Guide. With a ChatGPT subscription, follow the ChatGPT subscription steps instead: they use different settings and include a one-time sign-in (turn on device-code login in your ChatGPT security settings, then run codex login --device-auth from Control Panel option 6) Open Terminal in Container). Either way, add the settings your steps list to environment_settings.txt, then choose 11) Restart Container.

From the Control Panel menu, choose 1) Start Claude Code. With an Anthropic subscription or API key, Claude Code asks you to sign in the first time; follow its prompts.

DAAF's default model is Claude Code's opus model setting, which on an Anthropic subscription or API key means Opus 5.5 with a 1-million-token context window (observed 2026-09-24, Claude Code 2.1.281). You can also choose from several other models:

• Anthropic's Sonnet 5 and OpenAI's GPT-5.6 Sol sit in the top performance tier on DAAF's benchmark, DAAFBench, at roughly half to two-thirds of the benchmark cost of Opus 4.8 (the model those costs are measured against; DAAFBench July 2026 corpus — the live results page adds later models and prices).
• OpenAI's GPT-6 Astra is supported but has no DAAFBench result in that corpus.
• Open-weight models are available through OpenRouter.

The model-selection FAQ compares them. To switch models, type /model in Claude Code.

You're ready to go! See Understanding DAAF for some suggestions on how to get started with progressively more complex tasks with DAAF.

---

Design Principles

DAAF explicitly embraces the fact that LLM research assistants will never be perfect and can never be trusted as a matter of course. But with the right guardrails, they can still be immensely valuable for critically-minded researchers. Every design decision serves five core requirements:

• Transparent. Because LLMs will always be susceptible to lying, hallucinating, and cutting corners, DAAF forces Claude Code to operate using file-first principles: all data operations are drafted and run as actual Python or R files, all reasoning is stored as verbose comments, plan documents, and structured code output that you can review and intervene on at any time.
• Scalable. Because most LLMs are trained as generalists susceptible to sycophancy and overconfidence, DAAF provides a comprehensive and extensible set of explicit instructions and standards enforcing highly opinionated best practices (via skill documents and agent documents; an agent is a specialist version of Claude with its own working protocol), injecting the right information at the right time for any specific task -- so you don't have to hold its hand every time to get good output.
• Rigorous. Because LLMs can perform extensive computation on your behalf, DAAF's workflows force Claude to be meticulous, cautious, self-checking, and extremely thorough. Code is broken into hyper-atomic steps and adversarially reviewed. Plans and reports are informed by deep-dives into actual data documentation and actual exploratory analyses, then also reviewed by equally informed counterparts.
• Reproducible. Because good science needs to be reproducible, every single data file, script, and output is automatically stored throughout the entire process. You do not have to just trust DAAF or Claude Code -- you can and should verify everything yourself.
• Responsible. Because AI-assisted research demands accountability, DAAF ensures that data sources are properly cited, AI assistance is transparently disclosed via the GUIDE-LLM reporting standard, data usage terms are respected, limitations are honestly acknowledged, and the human researcher's judgment remains the final authority on all analytical decisions.

---

Engagement Modes

When you open DAAF, just begin by asking it any question or for support with any type of task. DAAF intelligently responds to your needs by automatically selecting and walking you through one of ten possible research workflow modes (and you can feel free to redirect it if it gets it wrong!) while providing easy opportunities to transition across supported workflows as needed:

Data Onboarding: Make Claude an expert in your data

• What you do: Point DAAF to your data (local file, web download, or API) and any associated documentation
• What DAAF does: Runs a multi-stage data profiling process to learn all the ins and outs, with fully reproducible code
• What you get: An in-depth data documentation Skill that DAAF references for all future work with your data -- fully portable, share with colleagues
• Sensitive data? If your data can't leave your environment, DAAF routes it through a privacy-preserving synthetic-data path -- you profile it locally and only a summary (or, at the highest disclosure tier, synthetic rows you generate locally) crosses the boundary
• Example: I've got a new BLS employment dataset I want to explore and understand a bit more. I've got this link to the dataset and a technical paper from them: can you start profiling it?

Data Lookup: Your personal data documentation oracle

• What you do: Ask DAAF a specific question about any dataset it has access to
• What DAAF does: Loads the data documentation Skill and synthesizes all relevant reference information into a precise, grounded answer in seconds
• What you get: A precise, documentation-informed answer with opportunities to dig deeper
• Example: Can you give me a sense of what the year variables actually indicate in the various IPEDS datasets?

Data Discovery: Connect the dots across data sources and topics

• What you do: Ask DAAF a broad data or research scoping question
• What DAAF does: Launches explorations across all available data documentation relevant to your question
• What you get: An in-depth summary of relevant opportunities, insights, clarifications, and caveats to consider
• Example: What are all the socioeconomic status related variables we have access to across the Urban Institute Education Portal datasets?

Literature Review (experimental): Find out what the published research says, with every reference and quote checked

• Experimental: it works end to end and every reference and quote is still checked, but it has had limited real-world testing. Review its output more closely, and tell us what goes wrong. Send reports to support@openaugments.org.
• What you do: Ask what the research literature says about a question, and choose how deep to go: a quick scan of abstracts, a standard review that reads the key papers in full, or a formal systematic review that you lead
• What DAAF does: Agrees a search plan with you, searches the scholarly databases, picks out the relevant papers with you, reads them, and writes up what the evidence shows. It checks every reference against a database record (you glance at the reference list before the final write-up), checks every quote and number against the page it came from, and never averages results from different studies into one number
• What you get: A short memo of pointers (quick scan) or a written review with a note on each key paper and how sure we can be about each conclusion, plus a checked reference list, a list of open gaps, and a project folder with the full search and reading record
• Example: What does the research say about how summer bridge programs affect first-year persistence in college? A standard review is fine.

Ad Hoc Collaboration: A smarter, more grounded research partner (including creatively stress-testing your findings together)

• What you do: Ask DAAF to help you riff on anything research-related -- code review, debugging, brainstorming, writing scripts
• What DAAF does: Engages as a collaborator with embedded domain and methodological expertise guiding the way
• What you get: A much more knowledgeable and careful Claude assistant for flexible, multi-turn working sessions
• Example: How would I implement a diff-in-diff design in Python? I know how in R but not the Python equivalents. Or: I usually work in Python -- can you help me set up a fixest regression in R?

Full Pipeline: From research question to results, with your guidance every step of the way

• What you do: Ask DAAF for support answering any arbitrarily complex research question with your data
• What DAAF does: Data scoping, analytic planning, data acquisition and cleaning, in-depth code review, analysis, visualization, and report writing -- the works
• What you get: A pre-analysis plan, a fully reproducible end-to-end analysis for close review, and a summary report with key findings, data visualizations, limitations, and citations
• Example: I want to analyze how graduation rates relate to admissions selectivity, while better accounting for factors like Pell share, student demographics, and other related factors

Revision and Extension: Make the first draft better and build beyond

• What you do: Ask for revisions to or new deliverables from any prior analysis
• What DAAF does: Reviews the prior analysis, launches targeted revisions, reruns analyses as needed, updates all downstream work
• What you get: Refined analyses, new dashboards, additional visualizations, stakeholder reports -- whatever you need
• Example: The scatter plots from yesterday look scrunched -- fix the sizing and propagate the changes downstream

Reproducibility Verification: Verify, don't trust. Ensure prior work is fully reproducible.

• What you do: Point DAAF to a completed Full Pipeline analysis (yours or someone else's)
• What DAAF does: Reruns and re-verifies every script against the final report, critiquing and exploring along the way -- a "reproduced" verdict means the results matched within reasonable tolerances when re-run
• What you get: An in-depth reproducibility report with issues, concerns, and summary takeaways
• Example: I want to verify that the graduation rate analysis reproduces correctly from its replication notebook before we share it with our collaborators

Framework Development: Make DAAF work for you

• What you do: Ask DAAF to improve its own functionality: new methodologies, new Python or R libraries, new domain expertise, or new modes entirely
• What DAAF does: Reviews its own architecture, conducts in-depth research, and meticulously updates its functionality
• What you get: A better DAAF with modular skills and agents you can share with colleagues or the community
• Example: I want to explore building in more supports for more sophisticated natural language processing techniques that allow us to classify open-response text

User Support: Get help understanding and using DAAF itself and its underlying tools (Docker, Git, Claude Code)

• What you do: Ask DAAF any question about what it is, how it works, how to troubleshoot setup or tool issues, or what to expect
• What DAAF does: Loads its own documentation and responds directly with clear, educational guidance -- can also look up official Docker, Git, and Claude Code docs online when needed
• What you get: A conversational, patient explanation of anything about DAAF or its technology stack, plus pointers to the right mode when you're ready to do something specific
• Example: I'm new here -- can you walk me through what DAAF actually does? Also, how do I give Docker more memory?

---

Capabilities

The base framework comes ready to analyze any or all of the 40+ foundational public education datasets available via the Urban Institute Education Data Portal, and is readily extensible to new data domains and methodologies. DAAF also comes out-of-the-box with a deep understanding of many of the most common social science research methods and beyond: from causal inference techniques like difference-in-differences, to geospatial analysis, to unsupervised machine learning methods. It can also search and review the research literature, read PDFs, and retrieve web pages, keeping a record of every source it reads. Several additional skills are included to help DAAF support broader science communication skills, as well -- embedding many best practices related to data visualization, data dashboarding, science communication, and more.

Included data sources: CCD, CRDC, EdFacts, EADA, FSA, IPEDS, MEPS, NACUBO, NCCS, NHGIS, PSEO, SAIPE, College Scorecard, Campus Safety, plus County Presidential Election Returns 2000-2024 from the MIT Election Data and Science Lab (this one needs a Harvard Dataverse API key; see Set up data source API keys)

Methodological support: Difference-in-differences • Fixed/random effects • Mixed effects models • Instrumental variables • Regression discontinuity • Synthetic control • Event studies • Propensity score matching • Time series analysis • Complex survey analysis • Geospatial analysis & spatial statistics • Network analysis & community detection • Decomposition analysis • Quantile regression • Exploratory data analysis • DAG modeling • Predictive analytics • Cross-validation • Algorithmic fairness assessment • Cluster analysis • Wild bootstrap inference • Sensitivity analysis • Supervised machine learning • Unsupervised learning (clustering, dimension reduction) • Text as data (coding open-ended text into variables)

Literature, PDFs, and web pages:

• Literature search and review: DAAF searches OpenAlex, Semantic Scholar, and ERIC together, follows citations forward and backward from key papers, finds legal open-access copies, and checks every reference it cites against a database record and for retractions. You choose how deep a review goes: a quick scan of abstracts, a standard review that reads the key papers in full, or a formal systematic review in which you make the judgment calls. A free OpenAlex API key is strongly recommended; see Set up data source API keys.
• PDF reading: DAAF reads papers, codebooks, and reports page by page and checks each quote and number it takes from a PDF against the page it came from. Scanned pages are read with OCR, and quotes from them count as weaker evidence.
• Web retrieval: DAAF saves every web page it reads exactly as fetched, with a plain-text copy and a record of where and when it came from, so you can trace any quote back to its source.

Python library expertise: polars • pyfixest • linearmodels • statsmodels • scikit-learn • geopandas • igraph • plotly • plotnine • great-tables • marimo • svy • fairlearn • SHAP • PySAL • LightGBM • seaborn • rdrobust • marginaleffects

R library expertise: tidyverse packages: dplyr, tidyr, readr, purrr, stringr, forcats, lubridate (data manipulation) • ggplot2 (static visualization) • fixest (high-dimensional fixed effects) • stats and sandwich (base statistical modeling, robust standard errors) • Quarto (reproducible notebooks) • plotly (interactive visualization) • sf and terra (spatial analysis) • igraph and tidygraph (network analysis) • plm (panel data) • tidymodels (machine learning) • survey (complex surveys) • gt (table formatting)

R is a core execution lane engineered for parity with Python -- the same pipeline, the same validation, the same reproducibility standards -- with Python as the default and R a one-line preference away. A few method-level differences between the two remain and are documented honestly in the technical FAQ.

Need a Python or R package that isn't listed? You can add your own by editing the Dockerfile and rebuilding -- see Customizing Your Python and R Environment for instructions.

Additional features: Interactive dashboards (Plotly) • Reactive analytic notebooks (marimo for Python, Quarto for R) • Browser-based code editor (code-server) • R/tidyverse-Python code translation • Python-R code translation • Stata-Python code translation • Stata-R code translation • Citation propagation & verification • GUIDE-LLM AI use disclosure • Git version control • Session transcript archiving • DAAF Log Explorer • Docker-based safety sandboxing • Destructive command prevention • Secret/credential scanning • File-first execution enforcement • Science communication

Model benchmarking: DAAFBench measures how faithfully different models follow DAAF's research protocols (behavioral adherence to DAAF's protocols, not research quality) -- a practical guide when choosing a model or budget.

---

Demos & Sample Projects

• Watch the Getting Started tutorial -- a full 30-minute walkthrough that installs DAAF from scratch and orients you to the whole environment: the Docker setup, Claude Code, DAAF itself, and everyday essentials like the browser file editor, the session log viewer, and keeping your installation up to date
• Watch the v2.0.0 Showcase, a tour of DAAF's features at version 2.0.0 (it does not cover R support, non-Anthropic providers, or literature review)
• Explore a sample Full Pipeline project on our interactive online explainer, or browse the actual repo files to see what kinds of reports, visualizations, reproducible scripts, and other artifacts DAAF can produce.
• Explore a sample Reproducibility Verification project to explore the outputs of a Reproducibility Verification process (using the same Full Pipeline project above) -- see the project README for a guided walkthrough.
• Watch the data onboarding demo explaining how the data onboarding process works and talking through a use-case where we replicate the NYTimes' "Red Shift" interactive data visualization
• Watch the v1.0.0 10-minute demo talking through the original modes, philosophy, and intentions behind DAAF, while showing the actual interactions with DAAF to produce a Full Pipeline analysis

---

Why does DAAF have education datasets bundled with it?

DAAF is designed to be fully domain-extensible -- you can readily bring your own data sources into the ecosystem by engaging with the Data Onboarding mode (see this 10-minute tutorial for a demonstration).

The Urban Institute Education Data Portal serves as an excellent out-of-the-box demonstration domain because it offers:

• High-quality, well-documented public data
• Real, immediate policy relevance (K-12 schools, districts, colleges, outcomes)
• Sufficient complexity to stress-test the system (multiple sources, coded values, suppression rules, cross-state comparability issues)

These datasets allow new users to quickly and easily experiment with DAAF using genuine research questions, nuanced datasets, and complex analytic plans. The architecture, agents, methodological skills, validation protocols, engagement modes, and workflow stages are all domain-agnostic.

---

Using DAAF with Sensitive or Regulated Data

If you plan to use DAAF with private, proprietary, or regulated data (FERPA, HIPAA, etc.), your data-privacy situation depends on which AI provider you connect through and on your agreement with it. Your prompts, and whatever Claude reads or prints during a session (file excerpts, sample rows, summary statistics, diagnostic results), go to that provider as part of the conversation: Anthropic, with an Anthropic subscription or API key; OpenAI, with an OpenAI API key or ChatGPT subscription through DAAF's provider shim; OpenRouter and the model provider it routes to, with OpenRouter; or your organization's own cloud account, with AWS Bedrock or Google Vertex AI. Enterprise agreements, Bedrock, and Vertex each offer different data governance guarantees. It is your responsibility to understand and evaluate these nuances for your use case before using DAAF with any non-public data. Consult your IT team and legal counsel, and review your provider's data policies for your agreement type (for example, Anthropic's policies or OpenAI's data controls for its API).

DAAF ships configuration templates for the Bedrock and Vertex routes, though these routes aren't maintainer-validated end-to-end -- treat them as a starting point you'll need to stand up and test in your own environment. For more detail, see the Data Privacy FAQ.

If your data genuinely can't leave your environment, DAAF includes a built-in synthetic-data protocol for exactly this situation -- you profile the data locally and DAAF works from a disclosure-controlled summary alone, so the real data never enters the container. Its disclosure controls minimize what leaves your machine but are not a formal privacy guarantee -- you review the profile summary yourself before it ever crosses the boundary. See Can I use DAAF with data that can't leave my secure environment?.

---

Contributing

DAAF is in constant development as AI advances continue, and as more and more users find value in using DAAF for their own research. DAAF needs the support of the research community to grow into a reliable, scalable tool, so contributions of all kinds are welcome!

• Bug reports and session learnings -- even a quick issue with context is extremely valuable. Every completed Full Pipeline project produces a LEARNINGS.md file with actionable improvements that can be fed back into the framework for improvements
• New data sources and methodological tools -- use Data Onboarding mode to profile new datasets, or use the Framework Development mode to develop new statistical methods and domain expertise Skills to share back with the community.
• Workflow improvements and documentation -- suggestions for improving quality, reducing friction, clearer onboarding, and better documentation are all welcome.
• Platform ports -- the vast majority of DAAF's tooling can be ported to other agentic coding harnesses (Gemini CLI, Codex, OpenCode, etc.) with a good bit of elbow-grease, but it requires people who know the real ins-and-outs of these various harnesses' idiosyncrasies.

See Contributing to DAAF for the full contribution guide and Extending DAAF for adding new capabilities for your own use.

---

Full User Documentation Reference and Recommended Next Steps

• 00. README — [This document] Project overview, quick start, design philosophy, capabilities, and acknowledgments
• 01. Installation & Quick Start — (Recommended Next Step) Get started! Installation prerequisites, step-by-step setup, day-to-day usage, and troubleshooting
• 02. Understanding and Working with DAAF — Learn to work with DAAF for the first time: what to expect, how to use it, and how to test its strengths and limitations
• 03. Best Practices — Tips for working with Claude Code, writing effective prompts, ensuring quality and rigor with DAAF, reviewing outputs, and managing context
• 04. Extending DAAF — How to add new data source skills, analytical tools and methodologies, creating your own additional specialized agents, and customizing your Python and R environment
• 05. Contributing to DAAF — Get involved in developing DAAF! How to file issues, contribute new skills and data sources, improve documentation and protocols, test your changes, and more! (This one lives at the repository root as CONTRIBUTING.md, not in the user_reference/ folder — which is why the folder's numbering skips from 04 to 06.)
• 06. FAQ: Philosophy — (Recommended Next Step) Grapples with the broader implications of this work, AI automation in general, model advancement pace, approaching the "exponential", environmental ethics, what this means for the next generation of researchers, and more
• 07. FAQ: Technical Support — Covers frequently asked questions about Docker, issues with Claude Code, usage limits, authentication errors, and other common errors

---

How to Cite

If you use DAAF in your research, please cite it and all underlying data sources, methodological guidance, and software tooling (more on that below). Software citation ensures credit for open-source tools and supports reproducibility by recording the exact version used.

Plain text (APA):

Kim, B. H. (2026). DAAF: The Data Analyst Augmentation Framework (Version 3.1.0) [Computer software]. https://doi.org/10.5281/zenodo.19343886

BibTeX:

@software{kim2026daaf,
  author = {Kim, Brian Heseung},
  title = {{DAAF}: The Data Analyst Augmentation Framework},
  year = {2026},
  url = {https://github.com/DAAF-Contribution-Community/daaf},
  doi = {10.5281/zenodo.19343886},
  version = {3.1.0},
  license = {LGPL-3.0-or-later}
}

GitHub also provides a "Cite this repository" button (powered by the CITATION.cff file) that generates APA and BibTeX citations automatically. Following FORCE11 Principle 6 (Specificity), please cite the exact version of DAAF you used -- every DAAF report automatically records the git commit hash in its AI Use Disclosure section and the version number in its References.

Automatic Citation Tracking

Knowing the importance of citing who we build upon, DAAF includes a built-in citation propagation system that tracks data, methodological, and software attribution throughout the analysis pipeline. As DAAF executes your analysis, it accumulates citations for every data source accessed, statistical method applied, and software library used for estimation -- guided by a parsimony principle (cite what directly produced a result, not every library touched along the way). These are verified at the end of the pipeline and rendered into a structured References section in your final report, organized by data sources, methodological references, software and tools, and reporting standards.

That being said, the citations generated are best-effort, not guaranteed -- always review the References section of your report and add or adjust as needed for your publication context. See the Citation Reference for more information and examples for how the system thinks about this.

---

Open Source & Licensing

This project is licensed under the GNU Lesser General Public License v3.0 (LGPL-3.0-or-later). Anyone can use DAAF for any reason, for free, forever -- this work is too important and high-stakes to treat as anything but a shared effort we can all benefit from and contribute to.

Internal use -- personally or within your organization, no matter how extensively you modify the framework -- is completely unrestricted. More restrictions apply only if you distribute a modified version: core framework improvements must also be licensed open-source, but extensions built on top (skills for proprietary datasets, bespoke agents, etc.) can remain private under any license. This ensures DAAF stays open and community-driven while allowing proprietary extensions in any context, including institutional or enterprise environments.

For the full philosophy behind this decision, see FAQ: Philosophy. See LICENSE and COPYING.LESSER for the full license text.

---

About the Author

Hello! My name is Brian Heseung Kim (@brhkim). I have been at the frontier of finding rigorous, careful, and auditable ways of using LLMs and their predecessors in social science research since roughly 2018. I focused my entire Ph.D. dissertation on teaching others how to use these tools responsibly (finished in mid-2022, months before ChatGPT was released), and I've continued to work on that frontier through to today. As a former public high school English teacher, much of why DAAF is packaged as an educational endeavor comes from my belief that helping peers and colleagues rapidly develop deep fluency on this frontier is one of the most important things I can do. I now work full-time developing DAAF and other AI frameworks to support the work of public-interest and research organizations as Founder and Chief Data Scientist at Open Augments.

---

Acknowledgments

Open Source Software & Community Resources

• Urban Institute Education Data Portal -- The proof-of-concept iteration of this project would not be possible without this remarkable public resource that harmonizes data from over a dozen federal education data sources into a single, well-documented API. We are deeply grateful to the Urban Institute for making high-quality education data freely accessible. If you use DAAF or the Education Data Portal in your work, please cite the Urban Institute appropriately -- see the Education Data Portal documentation for citation guidelines.
• GUIDE-LLM -- DAAF integrates this consensus-based reporting checklist (developed by Feuerriegel, Barrie, Crockett, Globig, McLoughlin, Mirea, Spirling, Yang, and more than 70 additional experts; Feuerriegel et al., 2026, Nature Human Behaviour, https://doi.org/10.1038/s41562-026-02492-7) to help researchers transparently disclose how AI was used in their work.
• GSD Core (Open GSD Community) -- Several core workflow patterns in DAAF, particularly around agent specialization, shared working memory, and task decomposition, were improved thanks to excellent practices in this community-led project.
• Docker -- Containerization platform providing DAAF's sandboxed execution environment
• code-server (Coder) -- Browser-based VS Code editor, itself built on Microsoft's VS Code and the Open VSX extension registry
• marimo -- Reactive Python notebooks used for DAAF's Python reproducible research artifacts
• Quarto -- Open-source scientific publishing system used for DAAF's R reproducible research notebooks
• TinyTeX (Yihui Xie) and TeX Live -- The LaTeX distribution behind Quarto's LaTeX PDF output; TinyTeX is distributed under GPL-2, and the TeX Live packages it contains carry their own free-software licenses
• Polars -- High-performance DataFrame library and DAAF's default data engine
• Trafilatura (Adrien Barbaresi) -- Web content extraction library powering DAAF's provenance-preserving web retrieval layer (web_fetch.sh); if your research relies on retrieved web content, please cite Barbaresi (2021)
• PDF reading stack -- Poppler (pdftotext, pdftoppm; GPL-2 or GPL-3), Tesseract OCR (Apache-2.0), pypdfium2 with its bundled PDFium (BSD-3-Clause, Apache-2.0), pdfplumber (MIT) and RapidFuzz (MIT) power DAAF's page-anchored PDF reading layer (pdf_ingest.sh, lit_verify.sh; the pdf-reading skill)
• uv (Astral) -- Fast Python package manager powering DAAF's build
• Git and pre-commit -- Version control and commit-time safety checks
• DAAF also relies on a broad ecosystem of specific Python and R packages for statistical computing, visualization, and geospatial analysis -- see the Dockerfile for the full list. It freezes the Python, system, and R package sets to fixed dates so a rebuild reproduces the same environment: uv's UV_EXCLUDE_NEWER cutoff fixes the complete Python package set, system packages come from a dated Ubuntu snapshot, and R packages from a date-pinned Posit Package Manager snapshot (see How DAAF Freezes the Environment).

Methodological Foundations

DAAF's Skills encode curated methodological guidance drawn from the work of many researchers. The exact references are embedded in the Skill files themselves (see .claude/skills/), but we gratefully acknowledge the scholars whose textbooks, papers, and open educational resources most directly shaped the framework's embedded expertise:

Causal inference and econometrics: Joshua Angrist & Jörn-Steffen Pischke, Scott Cunningham, Nick Huntington-Klein, Jeffrey Wooldridge, Guido Imbens, Judea Pearl, Paul Rosenbaum & Donald Rubin, Alberto Abadie, Matias Cattaneo, Edward Leamer, Charles Manski (causal inference, statistical modeling) • Modern difference-in-differences: Brantly Callaway & Pedro Sant'Anna, Andrew Goodman-Bacon, Liyang Sun & Sarah Abraham, Clément de Chaisemartin & Xavier D'Haultfoeuille, Jonathan Roth, John Gardner, Kirill Borusyak, Arindrajit Dube (causal inference, pyfixest) • Statistical inference: A. Colin Cameron & Douglas Miller, James MacKinnon, Morten Nielsen & Matthew Webb, Yosef Benjamini & Yoav Hochberg, Joseph Romano & Michael Wolf (statistical modeling, pyfixest, linearmodels) • Sensitivity and robustness: Emily Oster, Carlos Cinelli & Chad Hazlett, Joseph Altonji (causal inference, statistical modeling) • Statistical learning and machine learning: Trevor Hastie, Robert Tibshirani & Jerome Friedman, Gareth James & Daniela Witten, Leo Breiman, Susan Athey & Stefan Wager, Sendhil Mullainathan, Victor Chernozhukov, Cynthia Rudin, Christoph Molnar, Scott Lundberg, Galit Shmueli (supervised ML, exploratory/unsupervised) • Fairness: Jon Kleinberg, Alexandra Chouldechova, Ziad Obermeyer (supervised ML) • Clustering and unsupervised methods: Leonard Kaufman & Peter Rousseeuw, Christian Hennig, Brian Everitt, Chris Fraley & Adrian Raftery, Ian Jolliffe, Laurens van der Maaten, Leland McInnes (exploratory/unsupervised) • Decomposition methods: Ronald Oaxaca & Alan Blinder, Jonah Gelbach, Nicole Fortin, Thomas Lemieux & Sergio Firpo, Frank Cowell (descriptive analysis) • Survey methodology: Thomas Lumley, Steven Heeringa, Brady West & Patricia Berglund, Sharon Lohr, Leslie Kish, Kirk Wolter (survey analysis, svy) • Geospatial analysis: Sergio Rey, Dani Arribas-Bel & Levi John Wolf, Luc Anselin, Waldo Tobler, Timothy Conley, A. Stewart Fotheringham (geospatial analysis, geopandas) • Network analysis: Vincent Traag, Ludo Waltman & Nees Jan van Eck (community detection, igraph) • Panel data and IV: Badi Baltagi, William Greene, Kevin Sheppard, Douglas Staiger & James Stock (linearmodels, pyfixest) • Time series: James Hamilton, Rob Hyndman, Helmut Lütkepohl (statsmodels) • Visualization and science communication: Edward Tufte, Cole Nussbaumer Knaflic, Jonathan Schwabish, Claus Wilke, Alberto Cairo, Barbara Minto, Brent Dykes, Catherine D'Ignazio & Lauren F. Klein (visualization design, science communication) • AI agents for research: Anton Korinek (framework origin; see FAQ) • Software: Alexander Fischer & Styfen Schär (pyfixest), Skipper Seabold & Josef Perktold (statsmodels), Mamadou S. Diallo (svy), Fabian Pedregosa et al. (scikit-learn), Sergio Rey et al. (PySAL), Laurent Bergé, Kyle Butts & Grant McDermott (fixest), Kelsey Jordahl et al. (geopandas), Geoff Boeing (OSMnx), Guolin Ke et al. (LightGBM), Hadley Wickham et al. (tidyverse, ggplot2), Thomas Lumley (survey for R), Max Kuhn & Julia Silge (tidymodels), Edzer Pebesma (sf), Robert Hijmans (terra), Gábor Csárdi & Tamás Nepusz et al. (igraph), Thomas Lin Pedersen (tidygraph, ggraph), Adrien Barbaresi (trafilatura)

These researchers' contributions -- many freely available as open-access resources -- represent decades of accumulated methodological wisdom that DAAF aims to make more accessible to applied researchers.

---

DAAF is free and always will be, as the flagship project of Open Augments.