DAITA

• 

  DAITA_logo

Inspiration

DAITA began in a machine learning course, where I noticed how much code repeated across projects. Loading data, checking its quality, creating charts, preparing features, and comparing models often followed familiar patterns. I wanted to make those workflows reusable and accessible through conversation, while keeping the code visible for anyone who wanted to understand or reproduce the results.

What it does

DAITA lets users upload a dataset and explore it through natural-language questions. They can ask what the columns likely mean, view records, create visualizations, or build and compare predictive models. The agent interprets the request, asks for clarification when needed, and uses a constrained set of data science tools to carry out the work. Results appear alongside expandable Python code in a notebook-style conversation. Model comparisons show the evaluation metric, baseline performance, and limitations so users can understand what the results support.

How we built it

I built DAITA through iterative development with Codex Pro, combining a conversational interface with reusable Python workflows and locally running language models. The application separates the agent’s interpretation of a request from the code that executes it. The model proposes actions, while the surrounding harness validates tool calls, manages approvals, tracks results, and preserves the steps needed to reproduce an analysis. Testing with regression, classification, and time-series datasets helped reveal where the application misunderstood requests or failed to carry them through.

Challenges we ran into

The biggest challenges came when building the harness for the agent in this application. The hardest part was balancing flexibility with control. An overly restrictive harness could force a simple question into the wrong workflow. Too little structure allowed the agent to make unsupported claims or describe work it had not actually performed. Getting that balance right meant testing ordinary, sometimes vague prompts—not just carefully written technical instructions. It also meant distinguishing conversation from execution, preserving the user’s latest intent, and grounding reported results in completed calculations.

Accomplishments that we're proud of

I’m proud of turning a course-inspired idea into a working application that can explore data, compare models, and preserve the evidence behind its results. My favorite feature is the notebook-style chat. Users can interact in plain language, then expand the code behind an individual result. That makes the same interface useful for someone seeking an answer and someone who wants to inspect, learn from, or reproduce the analysis.

What we learned

I learned that choosing a model starts with understanding the question. The outcome being predicted, the information available at prediction time, and the cost of different mistakes all shape the right approach. That pushed me to prioritize a smaller set of understandable, testable workflows. I also learned that a plausible explanation is not enough: the application needs to show what ran, how it was evaluated, and where uncertainty remains.

What's next for DAITA

I want to develop DAITA into an interactive data science learning environment. Users would upload a dataset, choose a modeling approach to learn, and work through exploration, preparation, training, and evaluation with explanations at each step. The conversation and code would become a notebook they could revisit and question. Longer term, I’d like to help businesses explore their data through conversation, with clearer guidance about which questions the available data can answer. Before expanding that scope, the priority is improving response speed, reliability, and the quality of explanations.

Built With

• codex
• css
• gpt-oss
• javascript
• matplotlib
• node.js
• numpy
• ollama
• pandas
• pyodide
• python
• scikit-learn
• seaborn
• statsmodels
• vite
• yfinance