Customize Otto

Otto becomes more useful the more it knows about how your team works. This page describes the ways you can customize Otto so that every engineer on the team benefits from shared conventions, reusable workflows, and team-wide permission rules.

When Otto is customized, new engineers get your conventions from day one, corrections one engineer makes compound across the team, and operational knowledge stops living only in senior engineers’ heads.

What you can customize

Otto draws on four categories of team-specific customization. Each lives in files you commit to your repository, so updates propagate through your standard Git workflow.

• Memory — team conventions, naming patterns, connection configs, retry policies, approved operators, and other knowledge you want Otto to apply automatically. Memory files live in .astro/memory/. See Memory.
• Skills — reusable, structured workflows the team runs often, such as deploy patterns, testing patterns, and migration playbooks. Skills live in .astro/otto/skills/. See Skills.
• Permissions — allow, ask, and deny rules that control what Otto can do, including file rules, command patterns, and permission modes. Rules live in .astro/otto/permissions.json. See Permissions.
• Extensions — toggles for bundled Otto features such as Dag validation, memory commands, and hosted skills. Extension settings live in .astro/otto/extensions.json. See Extensions.

Recommended project layout

A customized Astro project typically looks like:

my-astro-project/
  dags/
  .astro/
    memory/
      MEMORY.md
      conventions.md
      connections.md
      operators.md
    otto/
      skills/
        deploy-to-staging/
          SKILL.md
      permissions.json
      extensions.json

Commit these files to your repository. When team members pull the latest main branch, their next Otto session loads the updated customizations automatically.

Get started

Customize Otto by working through the agent. Describe what you want Otto to remember, write, or enforce, and Otto produces the corresponding files in .astro/. Each file is plain Markdown or JSON, so you can review, edit, and commit changes in your Git diff like any other code change.

Seed memory from an established project

Best for teams whose conventions live in code and conversations but aren’t documented yet.

Run Otto in your project folder:

$
astro otto

Then run /bootstrap in the Otto interface. Otto reviews your git history and available GitHub context to extract durable learnings, then writes memory files for the durable patterns it finds. Every read and write happens as a visible tool call, so you can see what Otto pulls from history and what it persists.

Add memory from existing standards

Best for teams that already have conventions documented elsewhere, such as a wiki page, a STANDARDS.md file, or an onboarding guide.

Paste the content into an Otto session and ask Otto to extract memory files from it. For example:

> Here is our team's convention doc. Read it and propose memory files for the parts that should apply to every Dag we write.

Otto produces draft memory files for review, following the same review pattern as /bootstrap.

Capture learnings with /remember

During an active session, run /remember to have Otto review the conversation and generate memory files from durable points. Use /remember to grow your team’s memory organically as you work.

Ask Otto to write skills and permission rules

For workflows you run often, describe the workflow to Otto. For example:

> Write a skill for our staging deploy that runs make test, deploys to the staging Deployment, and tails the scheduler logs.

Otto generates a SKILL.md under .astro/otto/skills/ for you to review. The same pattern applies to permission rules. Describe what Otto should and shouldn’t do, and Otto produces or updates .astro/otto/permissions.json.

Commit and roll out

After Otto writes a customization, the changes appear in your Git diff. Review, edit if needed, and commit them. On the next pull, every engineer’s Otto sessions load the new customizations automatically.

Choose a model

You can pick your own model for an Otto session. Otto supports models from OpenAI, Anthropic, and Google through the Astronomer Gateway. Run /model in an interactive session to browse what’s available to you and switch the active model mid-session. To pin a model at launch, pass --model <id>.

See astro otto model selection for the full reference.

Next steps

• Memory — Memory tiers, file format, and how Otto loads context.
• Skills — How to author local skills for reusable workflows.
• Permissions — Configure allow, ask, and deny rules for tool calls.
• Settings — Configuration files, environment variables, and settings precedence.