Getting Started

#Requirements

• Python 3.11 or 3.12
• pipx
• An existing local directory to admit as the workspace
• A supported API or subscription model, or a local Ollama endpoint
• Optional SQLite or PostgreSQL data to attach as a cataloged source

#Install

pipx install daita-agents

The default installation is the complete application. Model SDKs, PostgreSQL and SQL support, DuckDB file analysis, keychain integration, artifact renderers, and the terminal UI do not require extras.

If pipx would select an unsupported Python version, choose one explicitly:

pipx install --python python3.12 daita-agents

#Launch the Terminal

daita

On first launch, the full-screen terminal guides you through:

1. admitting one local workspace;
2. creating a named persistent agent;
3. choosing and validating a model route;
4. storing an API or Codex subscription credential when required; and
5. optionally attaching a SQLite or PostgreSQL source.

Ask a question in plain language once setup completes:

Which products grew fastest month over month?
Find the release notes and summarize the breaking changes.
Export paid revenue by region to an XLSX file.

Run daita again to return. Daita reopens the only agent or shows a picker when several exist. Select one directly with:

daita --agent atlas

Use /help for the live command list. Type / for the command palette, @ to select a source for one question, /files <question> for a workspace-only run, and Ctrl-O to show or hide the most recent run's tool calls.

#Headless Commands

For repeatable automation, provide both the state root and workspace explicitly:

daita --root /private/tmp/daita \
  --workspace /absolute/path/project \
  create atlas
 
daita --root /private/tmp/daita \
  --workspace /absolute/path/project \
  attach atlas sqlite /absolute/path/sales.db
 
daita --root /private/tmp/daita \
  --workspace /absolute/path/project \
  run atlas "Summarize sales" --model openai:gpt-5.6-terra

run writes one JSON record. Unknown or custom model identities require explicit --context-window and --max-output limits. Use daita --help and the relevant subcommand's --help for the complete surface.

#Python API

Local Python composition requires an explicit LocalWorkspace. If the terminal already configured atlas, open it and attach a source:

import asyncio
from pathlib import Path
 
from daita import Agent, LocalWorkspace
 
 
async def main() -> None:
    workspace = LocalWorkspace(Path("/absolute/path/project"))
    agent = await Agent.open("atlas", workspace=workspace)
    try:
        source = await agent.attach_sqlite(
            Path("/absolute/path/sales.db"),
            name="Sales",
        )
        result = await agent.run(
            "Which region led revenue last quarter?",
            source_id=source.id,
        )
        print(result.final_text)
    finally:
        await agent.close()
 
 
asyncio.run(main())

Use an async context manager when convenient:

workspace = LocalWorkspace(Path("/absolute/path/project"))
 
async with await Agent.open("atlas", workspace=workspace) as agent:
    result = await agent.run("Summarize the files changed this week", files_only=True)
    print(result.final_text)

The workspace is a separate Files surface. Do not attach a CSV or JSON directory as a source; query structured local files through file_query instead.

#Next Steps

• Agent lifecycle and run results
• Local workspace guarantees
• Data sources and permissions
• Terminal and CLI reference
• Artifacts and local delivery