rauto
  • English

      • Open-source network automation

      rautoA Rust-based network automation toolkit.

      It provides CLI, Svelte Web, and agent APIs for device discovery, reusable credentials, multi-target execution, configuration drift hashes, TextFSM parsing, transactions, orchestration, session replay, and backup.

      Quick StartVisit GitHub

      Execution mesh

      exec · template · orchestrate
      Control planeready · 7 connections · last task success
      campus-access

      inventory group hosts=3

      edge-prod-01

      session records active

      task-center

      records ready

      Change preview

      rauto show route --group core --tag prod --textfsm-excel ./routes.xlsxrauto flow --template scp --connection edge-prod-01 --vars-json '{"peer":"edge-prod-02","local_path":"/tmp/rauto-demo.txt","remote_path":"/tmp/rauto-demo.txt"}'

      Replay stream

      [info] runtime loaded: 7 saved connections[show] route across core/prod targets[parse] TextFSM rows exported: routes.xlsx[ok] session replay available for last exec record
      7saved connections
      2inventory groups
      8show objects
      successlast task status
      CLI + Svelte Web + Agent APIShow + TextFSMInventory + TemplatesReplay + Orchestration

      Core capabilities

      Current capabilities in the rauto runtime.

      CLI and Svelte Web now cover automatic discovery, four authentication methods, multi-target execution, configuration fetch and drift hashes, session retries, TextFSM, orchestration, replay, backup, and policy guardrails.

      Standard delivery surface

      Use show objects, batch show queries, direct execute, template execute, and command flow from one panel with shared connection, mode, and TextFSM context.

      Orchestrated delivery surface

      Run Tx Block, Tx Workflow, and multi-stage Orchestrate plans for staged rollout and rollback-aware execution.

      Runtime asset workbench

      Manage password, private-key, private-key-file, and SSH-agent credentials alongside discovered devices, saved connections, Profiles, templates, TextFSM mappings, and inventory groups.

      Safety and operations center

      Combine opt-in session retries, command blacklist, recording levels, unified session replay, backup/restore, and task visibility in one operational loop.

      Web console

      A focused workspace for real device operations.

      The latest Svelte Web console adds password-protected access, automatic discovery, configuration fetch and drift hashes to credentials, Profiles, device groups, queries, orchestration, and replay.

      • Reuse encrypted authentication records across saved and temporary connections.
      • Search and diagnose built-in or custom Profiles in one catalog.
      • Organize saved connections with device facts, groups, labels, and credential references.
      • Build standard, transactional, and multi-device operations without changing runtime context.
      Explore Web console docsStart rauto web
      Feature views
      rauto Web interface screenshots
      rauto Web console Profile Management workspace showing the cisco_ios profile details
      Profile Management workspace · cisco_ios details

      AI-native operations

      Give your AI agent an operational model, not a shell prompt.

      The bundled rauto-usage Skill teaches Codex and Claude Code current command selection, validation, dry-run, approval, and replay workflows.

      1. 01
        Install the current Skill

        Install rauto-usage from the repository so the agent follows the current CLI and JSON models.

      2. 02
        Inspect with saved identities

        Reference saved credentials, devices, groups, labels, profiles, and show objects without placing secrets in prompts.

      3. 03
        Author and validate

        Generate complete rollback-aware plans, validate them against the current rauto binary, and run native dry-run.

      4. 04
        Approve, execute, and replay

        Review scope and rollback behavior, confirm the real change, then summarize and replay the recorded result.

      Install Skill

      npx skills add demohiiiii/rauto --skill rauto-usage

      Ask your AI agent

      Use $rauto-usage. Inspect the access group, generate a rollback-aware plan, validate it, and dry-run it. Do not execute until I approve.
      Read the AI Skill guideView Skill source

      Execution workflow

      Current execution flow.

      Typical operator path aligned with current Web and CLI execution surfaces.

      1. Set target and runtime context

        Pick a reusable credential and saved connection or inventory group, then confirm device profile, SSH security, and runtime vars.

      2. Choose delivery mode

        Select Standard delivery (show/exec/template/flow) or Orchestrated delivery (tx block/workflow/orchestrate) based on change risk.

      3. Execute with recording and guardrails

        Apply blacklist checks, choose record level, and execute with mode-aware prompts and structured task/event reporting.

      4. Review, replay, and recover

        Use Task Center and unified session records to audit or replay outcomes, and use backup/restore when runtime state must be migrated or recovered.

      Operator surfaces

      Current local runtime layout.

      Credentials, connections, inventory, profiles, templates, TextFSM mappings, custom show objects, tasks, records, and backups live under one runtime.

      The local runtime keeps operator state in one place for CLI, Svelte Web, TextFSM, replay, blacklist, and backup flows.

      Credentials and saved connections

      Reuse encrypted authentication records while saved connections keep host, credential reference, port, SSH security, facts, and Profile context.

      Templates and device profiles

      Render commands with MiniJinja, model prompt transitions and lifecycle Hooks with rneter profiles, and map built-in or custom show objects to NTC TextFSM parsing.

      Session records and replay

      Capture execution detail as structured events so review and post-change debugging stop depending on memory.

      Backup and restore

      Archive the local runtime under ~/.rauto and recover connections, profiles, templates, and records when needed, while keeping keychain-backed secrets outside the archive.

      Use cases

      Representative operator flows.

      Current command patterns and output snapshots from the runtime.

      Bulk switch changes

      Render the same intended change across multiple access devices while keeping connection state and prompt handling consistent.

      Command

      rauto orchestrate campus-vlan-orchestration.json --view

      Output

      # orchestration_plan: campus-vlan-rollout
file: campus-vlan-orchestration.json
overview: fail_fast=true rollback_on_stage_failure=true rollback_completed_stages_on_failure=false stages=2 inventory_groups=2

[Stage 1/2] core
strategy=serial fail_fast=false jobs=1
  [Job 1/1] core-job
  strategy=serial fail_fast=true targets=2 action=tx_workflow (workflow_file=./core-vlan-workflow.json)
  target_groups=core
  - core-01
  - core-02

[Stage 2/2] access
strategy=serial fail_fast=false jobs=1
  [Job 1/1] access-job
  strategy=parallel fail_fast=true targets=2 action=tx_block (template=configure_vlan.j2, mode=Config)
  max_parallel=10
  target_groups=access
  - sw-01
  - sw-02

      Template-based firewall or router updates

      Drive repeatable policy or interface changes from templates and variable files instead of manually retyping each sequence.

      Command

      rauto template configure_vlan.j2 --vars templates/example_vars.json --dry-run

      Output

      --- Rendered Commands ---
conf t

vlan 10
 name Marketing

vlan 20
 name Engineering

end
-------------------------

      Replay after a noisy maintenance window

      Use unified session records and replay detail to reconstruct what happened without relying on terminal scrollback.

      Command

      rauto session list edge-prod-01 --limit 5
rauto session replay /private/tmp/website-demo-exec.jsonl --list

      Output

      # connection: edge-prod-01
- [1777824859401] template: scp mode=User level=full file=sqlite://~/.rauto/rauto.db#history/1777824859401_command_flow
- [1777824843199] touch /tmp/rauto-demo.txt mode=Root level=full file=sqlite://~/.rauto/rauto.db#history/1777824843199_exec
- [1777824800314] uname -a mode=Root level=full file=sqlite://~/.rauto/rauto.db#history/1777824800314_exec
- [1777824795188] template: scp mode=User level=full file=sqlite://~/.rauto/rauto.db#history/1777824795188_command_flow
- [1777367945542] load-and-restart mode=Root level=key-events-only file=sqlite://~/.rauto/rauto.db#history/1777367945542_orchestrate_tx_block

# context: device=<USER>@<HOST>:22 prompt=<PROMPT> fsm_prompt=root
1. mode=root success=true exit_code=0 command=uname -a

      Reusable lab-to-production workflows

      Autodetect device profiles, keep custom TextFSM mappings and show objects, and reuse the same operational assets for production runs.

      Command

      rauto profile autodetect -v --connection edge-prod-01
rauto textfsm mapping list --profile cisco_ios
rauto backup list

      Output

      selected_profile=cisco_ios source=cache confidence=0.97
ranked_candidates:
1. cisco_ios score=0.97
2. cisco_xe score=0.91
3. cisco_nxos score=0.42

profile=cisco_ios
"show version" -> campus_show_version
"show interfaces" -> campus_interfaces
"show ip route" -> campus_route

- ~/.rauto/backups/rauto-backup-1777824868.tar.gz

      Inside rauto

      Current runtime components.

      Execution, inventory-driven rollout, stored assets, audit trails, local UI, and managed agent mode.

      Delivery engine

      A single engine behind show objects, batch show queries, direct execute, template execute, command flow, tx block, tx workflow, and orchestration plans.

      State and asset stores

      Device credentials, saved connections, inventory groups, templates, prompt profiles, custom TextFSM mappings, and custom show objects stay reusable across CLI and Web.

      Audit and safety plane

      Recording, unified session replay, blacklist, retry controls, and task tracking provide pre-flight protection plus post-change auditability.

      Local and managed control

      Operate locally through `rauto web`, or run `rauto agent` to register into `rauto-manager` for centralized control.

      Open ecosystem

      Project roles in the current ecosystem.

      `rauto` is the execution runtime. `rauto-manager` is the self-hosted control plane for multiple managed agents.

      rauto

      Rust-based execution runtime with CLI, Svelte Web UI, agent APIs, reusable credentials, batch show queries, TextFSM parsing, saved connections, templates, orchestration, replay, backup, and command guardrails.

      Open GitHub

      rauto-manager

      Self-hosted control plane for multiple `rauto` agents with HTTP/gRPC agent support, shared inventory, centralized dispatch, workflow/orchestration design, live execution visibility, history, and notifications.

      View rauto-manager

      FAQ

      Current behavior notes.

      Short answers about runtime behavior and data handling.

      How do the CLI and Web console fit together?

      They share the same runtime data and execution model, so credentials, saved connections, templates, profiles, TextFSM mappings, records, and backups stay aligned.

      Can I preview commands before touching devices?

      Yes. Dry-run flows let you inspect rendered commands before execution, which is critical when templates or variable files are involved.

      Can I define my own device prompt behavior?

      Yes. rauto supports built-in profiles inherited from rneter and custom TOML profiles so you can model prompt states and execution modes for your environment.

      What data stays local?

      Runtime metadata and encrypted credential ciphertext stay in local SQLite storage; the credential master key remains in the operating system keyring.

      Repository and documentation.

      Read the docs, browse the repository, or check published releases.

      Open GitHubRead DocsReleasesCrates.io
      IssuesDiscussionsApache-2.0