AGILab Logo
Current release v2026.06.02 Docs build 95b6401

Start

  • Newcomer guide
    • Fast adoption ladder
    • Choose one route
    • Which example should I start with?
    • Adoption evidence
    • After day 1: cluster proof
    • What to ignore on day 1
    • The five words you need
    • Common newcomer traps
    • Where to go next
  • Local first proof
    • Prerequisites
      • Upgrade or first 10 minutes
      • Recommended first proof path
      • Why this path avoids common adoption friction
      • If the first proof fails
      • Alternative install routes
      • Validation commands
      • Shared or team adoption check
      • Private apps or framework contributor setup
      • Cluster installs
      • Next steps
      • Support
      • License
  • Release proof
    • Current public release
    • What was proved
    • How to verify it again
    • Maintainer refresh
    • Scope and limits
    • Related pages
  • Beta readiness
    • Scope
    • Required local gates
    • Readiness command
    • Release boundary
  • Evidence claims policy
    • Allowed Claims
    • Forbidden Claims And Replacements
    • Verifier Claim Boundary
    • Stable Verifier Codes
    • Maintenance Rule
  • Evidence taxonomy
    • Common Event Envelope
    • Event Types
    • Redaction Rules
    • Verifier Scope
    • Roadmap Boundary
  • First-failure recovery
    • Before anything else
    • Failure 1: uv is missing
    • Failure 2: ./install.sh --install-apps fails
    • Failure 3: the built-in app path is not found
    • Failure 4: the web UI or Main Page/ORCHESTRATE smoke fails
    • Failure 5: no fresh output appears under ~/log/execute/flight_telemetry/
    • When you are past the newcomer hurdle
  • Compatibility matrix
    • Current public matrix
    • Platform coverage snapshot
    • How to use this matrix
    • Maintainer evidence commands
    • What remains roadmap work

Product

  • Product overview
    • What AGILab is
    • Historical note
    • Why the project is built this way
    • Main dependencies
    • What to read next
  • Capability map
    • Maturity labels
    • Job-to-route map
    • Evidence Core reading order
    • Adoption rule
  • Capabilities
    • agi-core
    • agilab
    • Engineering prototyping evidence
    • Production-readiness controls
  • Data connectors
    • Connector Maturity Levels
    • Catalog Shape
    • Object Storage Providers
    • SQLite Database Proof
    • Local Artifact Lane Contract
    • Account-Free Cloud Emulator Validation
    • Credential Rule
    • Evidence Reports
    • How To Read The Boundary
  • Regulatory readiness
    • Why this belongs in AGILAB
    • Current profile
    • Official sources
  • AGILAB for Excel users
    • What ships now
    • Why this is the right first bridge
    • Product direction
    • What remains roadmap
  • AGILAB for Voila users
    • What ships now
    • Why this is the right first bridge
    • Product direction
    • What remains roadmap
  • AGILAB for Quarto users
    • Export a report
    • Render when Quarto is available
    • Bridge boundary
    • Related bridges
  • Proof capsule
    • Why this matters
    • Capsule contents
    • Run Markdown evidence
    • Target CLI shape
    • Run story
    • Promotion dossier
    • Roadmap boundary
    • Adoption rule
  • Public web demo
    • Start here
    • What will happen
    • After the hosted first proof
    • What success looks like
    • Related pages
  • Advanced proof pack
    • What belongs here
    • Recommended order
    • How to demo it
    • What not to claim
    • Related pages

Notebooks and API

  • Notebook quickstart with agi-core
    • Start here
    • What will happen
    • What success looks like
    • Local PyPI fallback
    • Minimal notebook cells
    • How this maps back to the web UI
    • Advanced notebook routes
    • Related pages
  • Advanced notebook routes
    • Notebook evidence sandbox
    • Source-checkout launchers
    • Other notebook entry points
    • Published-package variants
    • Repository launch flow
    • Minimal source-checkout notebook cells
    • Related pages
  • Python API reference
    • Reference
      • main()
  • Framework API
    • Core and UI packages
      • agi-env API
        • Usage Example
        • Reference
      • agi-gui API
        • Reference
      • agi-node API
        • Path handling
        • Argument helpers
        • Managed PC path remapping
        • Output directory helpers
        • Reference
      • agi-distributor API
        • Understanding modes_enabled and mode
        • Usage Example
        • Reference
    • Working with the API
    • App structure conventions

Build

  • Architecture in 5 minutes
    • Global architecture map
    • One control path
    • What each layer owns
    • Manager versus worker
    • Boundary
    • Next pages
  • Product architecture
    • Three-plane mental model
    • Component view
    • Pipeline example
    • agilab.py navigation
    • Manager vs worker responsibilities
    • Runtime ownership
    • Package names versus runtime roles
    • Manager and worker dependency rule
    • Execution back-plane boundary
    • Runtime flow
    • Repository map
    • Core vs optional apps
    • Documentation map
    • See also
  • Architecture scorecard
    • Current supported score
    • Executable scorecard
    • What must stay true
    • Remaining hardening register
    • Score movement rule
  • Maintenance playbook
    • Maintenance dashboard
    • Maintenance sequence
    • Path-scoped maintenance memory
    • Shared-core discipline
    • Feature growth discipline
    • Release friction discipline
    • Bottom line
  • Extension contracts
    • Contract shape
    • Extension types
    • Adoption rule
    • Release rule
  • Architecture decisions
    • ADR 0001: Package Split Is The Publication Boundary
      • Status
      • Context
      • Decision
      • Consequences
    • ADR 0002: Evidence Core Is The Maintenance Backbone
      • Status
      • Context
      • Decision
      • Consequences
    • ADR 0003: Notebook Bridge Preserves Work In Both Directions
      • Status
      • Context
      • Decision
      • Consequences
    • ADR 0004: Extensions Grow Through Contracts
      • Status
      • Context
      • Decision
      • Consequences
    • ADR 0005: Shared Core Changes Require Explicit Blast-Radius Control
      • Status
      • Context
      • Decision
      • Consequences
  • AGI Core architecture
    • Modules at a glance
    • What belongs here
    • Execution flow
    • Repository pointers
    • Tips for contributions
    • See also
  • MLOps positioning
    • Executive review summary
    • MLflow strategy
    • Best fit and limits
    • Research experimentation evidence
    • Engineering prototyping evidence
    • Production readiness evidence
    • Strategic potential evidence
    • Where AGILab helps
    • What AGILab does not aim to cover
    • Positioning vs. other tools
    • Framework comparison
    • Selection guide
    • Suggested workflow
    • See also
  • Learning workflows
    • Training vs inference
      • Reinforcement learning (example)
      • Optimization / ILP baseline (example)
    • Continuous learning (optional)
    • Graph neural networks (message passing)
    • Federated learning (optional)
  • Project file structure
  • Agent workflows
    • What “repo-ready” means
    • Shared repo contract
    • Context routing
    • Agent run evidence
    • Agent evidence contract
    • Supported agent paths
      • Codex and Claude
      • Aider
      • OpenCode
    • Local model prerequisite
    • Where to read the repo-local files
    • When not to use this page
  • Contributor guide
    • Contributor target
    • Baseline setup
    • Choose one lane
    • Validation map
    • Pull request evidence
    • Review expectations
    • Reference

Web UI pages

  • Landing page
    • How pages are presented
    • Core pages
    • Core page tour
    • Page bundles
    • First-time navigation
    • Public navigation split
    • See also
  • PROJECT page
    • Page snapshot
    • Sidebar
    • Tutorial: create a project
    • Main Content Area
    • Troubleshooting and checks
    • See also
    • Support
  • ORCHESTRATE page
    • Introduction
    • Page snapshot
    • Sidebar
    • Main Content Area
    • Execution Mode Values
    • From UI to Snippet Fields
    • Distributed Workflow
    • Snippet Handoff to WORKFLOW
    • Service Mode Health
    • Service health JSON export
    • Troubleshooting and checks
    • See also
  • WORKFLOW page
    • Page snapshot
    • Sidebar
    • Main Content Area
      • ASSISTANT
      • Workflow graph scopes
      • Notebook import and export
      • MLflow tracking
      • HISTORY
    • Troubleshooting and checks
    • See also
  • ANALYSIS page
    • Introduction
    • Choose the right surface
    • Page snapshot
    • Sidebar
    • Main Content Area
    • Tips & Notes
    • Troubleshooting and checks
    • See also
  • Page bundles
    • App-owned multi-UI surfaces
    • What is a page bundle?
    • Tutorial: clone an existing page bundle
    • Enabling bundles (per project)
    • Included page bundles
      • view_barycentric
      • view_maps
      • view_maps_3d
      • view_maps_network
      • view_routing_model_comparison
      • view_queue_resilience
      • view_scenario_cockpit
      • view_relay_resilience
      • view_data_io_decision
      • view_forecast_analysis
      • view_inference_analysis
      • view_live_artifacts
      • view_app_ui
      • view_release_decision
      • view_shap_explanation
      • view_training_analysis
      • view_autoencoder_latentspace
    • Producer example for distributed runs
    • See also
  • Portable web components
    • Contract
    • Example
    • Current boundary
    • Visual guard

Operations

  • Cluster setup
    • Overview
    • Principle
    • Normal AGILAB Workflow
    • Kubernetes scope
    • Repeatable cluster proof
      • Shared storage contract
      • Discover candidate workers
      • Set up and check the shared filesystem
      • SSHFS prerequisites by operating system
        • Linux worker
        • macOS worker
        • Windows manager or scheduler
      • Cleanup or scheduler switch
      • Run the cluster proof
    • SSH key setup
  • Trusted shared deployment
    • Go gate
    • Public UI evidence
    • Cluster evidence
    • What remains no-go
  • Kubernetes Job preview
    • What is supported
    • What is intentionally not claimed yet
    • Generate a Job manifest
    • Run another AGILAB command
    • Artifact handoff
  • Parallel stages
    • Choose a split rule
    • Create a contract
    • Check a contract
    • What actually happens at runtime
    • Try the packaged example
    • Recommended sequence
    • When files are fewer than cores
    • Reducers
    • Current boundary
  • Distributed workers
    • Prerequisites
    • Stage 1: Configure Distributed Execution in ORCHESTRATE
    • Stage 2: Let ORCHESTRATE Generate the Snippet
    • Reading mode and modes_enabled
    • Quick UI Walkthrough
    • Equivalent Generated Snippets
    • Stage 3: Validate the Distribution Before Running
    • Stage 4: Reuse the Generated Snippet in WORKFLOW
    • Best Practices
    • Troubleshooting
  • SSH keys for workers
    • 1. Generate the keys
    • 2. Loading the private key in SSH Agent
      • 2.1 Load the private key
      • 2.2 Verify the key Addition
    • 3. Copy the public key to the server
      • 3.1 Allow your key
      • 3.2 Verification
      • Bidirectional trust between worker Macs
      • Reverse SSH for SSHFS-backed cluster shares
      • Node reinstalled or host key changed
    • Troubleshooting
      • SSHD Service
        • Check the service status:
        • Check the configuration
        • Restart the SSHD service
        • Permissions
    • Useful links
  • Service mode
    • Service queue security contract
    • When to use it
    • Fast path in ORCHESTRATE (web interface)
    • Action semantics
    • What service mode is, and what it is not
    • End-to-end CLI example
    • SLA thresholds
    • Operational checks
    • Common pitfalls
    • Related pages
  • Service install paths
    • Terminology
    • Key Files And Environment Variables
    • How App Symlinks Are Resolved
    • Updating App Links
    • Compatible Venv Linking
    • Practical Checklist
  • Service health schema
    • Overview
    • Core fields
    • Optional fields
    • Minimal monitoring rule
    • CLI example
  • Environment variables
    • Cluster isolation note
    • Security note
  • Troubleshooting
    • A - Prerequisite:
    • B - Run/Debug configurations (PyCharm and shell):
    • C - Exemple of Tests Sequence:
    • D - agilab_run_dev vs agilab_run_enduser vs lab_run:
    • E - macOS NFS server checklist:
  • Known Limitations And Deprecations
    • <install.sh> does not generate Run/Debug configurations after worker install failure
    • <install.sh> appears frozen while building heavy dependencies
    • <UV> VIRTUAL_ENV Warning
    • <Python> pip resolver warning during ensurepip
    • <UV> Sync Failed
    • <DASK> Debug Issue
    • <PYCHARM> Run/Debug Configuration is Broken
    • <PYCHARM> Can’t open your project
    • Failed to read pydantic metadata
  • FAQ
    • Adoption and scope
      • What is AGILAB uniquely useful for?
      • When should I not use AGILAB?
      • Does AGILAB replace MLflow?
      • Does public release evidence certify my environment?
      • What should I run first?
      • Which packaged examples match the public docs?
    • First proof and notebooks
      • Can I start from a notebook instead of the built-in app?
      • How does notebook import choose manager versus worker code?
      • What is notebook export, and why does it matter?
      • What is the difference between notebook import and notebook export?
    • Packages, apps, and release evidence
      • Which install surface should I choose?
      • Why are apps and pages separate packages?
      • Do app and page versions always match the AGILAB version?
      • What does a proof pack mean today?
      • Why does PyPI sometimes show several AGILAB packages for one release?
    • Runtime and cluster behavior
      • Do I need PyCharm?
      • Do I need a cluster or shared folder for the first proof?
      • What limits AGILAB when scaling compute?
      • Can I run Dask again inside one AGILAB worker and see it in the outer dashboard?
      • Who manages parallelism when Dask is disabled?
      • Do we already have DAG/task orchestration?
      • Why does a run create distribution.json?
    • Install, dependencies, and logs
      • Missing worker packages during a run
      • Why do installers still build eggs?
      • Do I need to run tests during install?
      • Where are installer logs written?
      • What does the VIRTUAL_ENV warning mean?
      • Why did my local coverage run not change the README badge?
      • Why can agi-gui be at 99% while global agilab coverage is lower?
    • Contributor and documentation maintenance
      • Which local tool should I run when?
      • Which docs repo should I edit?
      • Docs drift after touching core APIs
      • Switching PyCharm to another source checkout
      • Regenerating IDE run configurations
      • What does tools/newcomer_first_proof.py actually prove?

Examples

  • Demo chooser
    • AGILAB Video Tutorial Guide
      • Recommended tutorial package
      • Which format to use
      • Fastest live workflow
        • Mission Decision autonomous decision demo
      • Self-generated fallback
      • Storyboard
        • Flight 30-second version
        • Flight 45-second version
        • Weather forecast 45-second version
        • Flight 60-second version
        • Flight 3-minute version
        • UAV queue 45-second version
        • UAV Relay Queue 3-minute version
      • Recording and visual rules
      • Quality checklist
      • Default tagline
    • Choose a demo
    • What each route is for
    • Short demo routes
      • Robot/proof coverage
    • Demo naming
    • See also
  • Packaged examples
    • Catalog
    • Execution Map
    • Related Pages
  • Public app catalog
    • Recommended first choices
    • Package truth source
  • PyTorch Playground
    • Positioning
    • What It Adds Over A Classic Playground
    • One-Minute Demo Route
    • Hosted Route
    • Scope
  • Execution playground
    • What is included
    • Where you see it in the UI
    • Why this example matters
    • What the benchmark shows
    • Measured local benchmark
    • Typed Cython kernel proof
    • Optional Rust/PyO3 worker preview
    • 2-node 16-mode matrix
      • Mode families
      • How to read the matrix quickly
      • ORCHESTRATE table snapshot
      • execution_pandas_project
      • execution_polars_project
    • How to run it
    • What to look for
  • Industrial optimization examples
    • What this proves
    • How to run it
    • What not to claim
    • Why it matters
    • Related pages
  • Notebook migration example
    • Repository material
    • Why migrate
    • Migrated pipeline shape
    • Real built-in project
    • ANALYSIS page
    • Suggested migration path
  • Minimal App project
    • Overview
    • Scientific placeholders
    • Manager (minimal_app.minimal_app)
    • Args (minimal_app.app_args)
    • Worker (minimal_app_worker.minimal_app_worker)
    • Reducer contract status
    • Assets & Tests
    • API Reference
      • MinimalApp
        • MinimalApp.__init__()
        • MinimalApp.as_dict()
        • MinimalApp.build_distribution()
        • MinimalApp.from_toml()
        • MinimalApp.pool_init()
        • MinimalApp.stop()
        • MinimalApp.to_toml()
        • MinimalApp.work_done()
        • MinimalApp.work_pool()
        • MinimalApp.worker_vars
      • MinimalAppApp
      • ArgsModel
      • ArgsOverrides
      • MinimalAppArgs
        • MinimalAppArgs.data_in
        • MinimalAppArgs.data_out
        • MinimalAppArgs.files
        • MinimalAppArgs.model_config
        • MinimalAppArgs.nfile
        • MinimalAppArgs.nread
        • MinimalAppArgs.nskip
        • MinimalAppArgs.reset_target
      • MinimalAppArgsTD
        • MinimalAppArgsTD.data_in
        • MinimalAppArgsTD.data_out
        • MinimalAppArgsTD.files
        • MinimalAppArgsTD.nfile
        • MinimalAppArgsTD.nread
        • MinimalAppArgsTD.nskip
        • MinimalAppArgsTD.reset_target
      • dump_args()
      • ensure_defaults()
      • load_args()
      • merge_args()
      • MinimalAppWorker
  • Flight telemetry project
    • Overview
    • Scientific highlights
    • Public scope
    • Manager (flight_telemetry.flight_telemetry)
    • Args (flight_telemetry.flight_args)
    • Worker (flight_telemetry_worker.flight_telemetry_worker)
    • Assets & Tests
    • API Reference
      • FlightTelemetry
        • FlightTelemetry.__init__()
        • FlightTelemetry.as_dict()
        • FlightTelemetry.build_distribution()
        • FlightTelemetry.extract_plane_from_file_name()
        • FlightTelemetry.from_toml()
        • FlightTelemetry.get_data_from_files()
        • FlightTelemetry.get_data_from_hawk()
        • FlightTelemetry.get_partition_by_planes()
        • FlightTelemetry.ivq_logs
        • FlightTelemetry.to_toml()
      • FlightTelemetryApp
      • ArgsModel
      • ArgsOverrides
      • FlightArgs
        • FlightArgs.data_in
        • FlightArgs.data_out
        • FlightArgs.data_source
        • FlightArgs.datemax
        • FlightArgs.datemin
        • FlightArgs.files
        • FlightArgs.model_config
        • FlightArgs.nfile
        • FlightArgs.nread
        • FlightArgs.nskip
        • FlightArgs.output_format
        • FlightArgs.reset_target
        • FlightArgs.sampling_rate
        • FlightArgs.to_toml_payload()
      • FlightArgsTD
        • FlightArgsTD.data_in
        • FlightArgsTD.data_out
        • FlightArgsTD.data_source
        • FlightArgsTD.datemax
        • FlightArgsTD.datemin
        • FlightArgsTD.files
        • FlightArgsTD.nfile
        • FlightArgsTD.nread
        • FlightArgsTD.nskip
        • FlightArgsTD.output_format
        • FlightArgsTD.reset_target
        • FlightArgsTD.sampling_rate
      • apply_source_defaults()
      • dump_args()
      • dump_args_to_toml()
      • ensure_defaults()
      • load_args()
      • load_args_from_toml()
      • merge_args()
      • FlightTelemetryWorker
        • FlightTelemetryWorker.calculate_speed()
        • FlightTelemetryWorker.pool_init()
        • FlightTelemetryWorker.pool_vars
        • FlightTelemetryWorker.preprocess_df()
        • FlightTelemetryWorker.start()
        • FlightTelemetryWorker.stop()
        • FlightTelemetryWorker.work_done()
        • FlightTelemetryWorker.work_init()
        • FlightTelemetryWorker.work_pool()

Reference

  • Project and packages
    • AGILab components
  • Security and adoption
    • Vulnerability reporting
    • Adoption boundary
    • Operational checks
    • Untrusted content boundary
    • See also
  • Package publishing policy
    • User-facing install surfaces
    • Internal runtime packages
    • Published UI support packages
    • Published page-bundle packages
    • Published page-bundle umbrella package
    • App project packages
    • Published app/example umbrella package
    • Why keep them published
    • Release rule
    • Release synchronization contract
    • Publishing authentication
    • GitHub deployment environments
    • Release cadence and post releases
    • Typing policy
    • Packaging notes
  • Framework submodule contract
    • Recommended default
    • Why this is the default
    • Supported resolution order
    • Local workflow
    • Consequences
  • Module reference
    • Canonical pages
  • Strategic potential
    • Audit verdict
    • Current score
    • Score movement rule
    • Unique value thesis
    • Evidence scorecard
    • What AGILAB enables
    • Where the value is strongest
    • Strategic wedge
    • Score update criteria
    • Evidence gaps
    • Community validation wanted
    • Recommended positioning
    • Related pages
  • Licenses
    • Review notes
    • Vendored third-party assets
    • Top-level package
      • agilab
    • Runtime packages
      • agi-env
      • agi-node
      • agi-cluster
      • agi-core
    • UI and page packages
      • agi-gui
      • agi-web
      • agi-page-app-ui
      • agi-page-simplex-map
      • agi-page-decision-evidence
      • agi-page-timeseries-forecast
      • agi-page-inference-report
      • agi-page-live-artifacts
      • agi-page-geospatial-map
      • agi-page-geospatial-3d
      • agi-page-network-map
      • agi-page-routing-model-comparison
      • agi-page-queue-health
      • agi-page-relay-health
      • agi-page-scenario-cockpit
      • agi-page-promotion-gate
      • agi-page-feature-attribution
      • agi-page-training-report
      • agi-pages
    • App packages
      • agi-app-mission-decision
      • agi-app-pandas-execution
      • agi-app-polars-execution
      • agi-app-flight-telemetry
      • agi-app-multi-dag
      • agi-app-weather-forecast
      • agi-app-sklearn-pipeline
      • agi-app-data-quality-gate
      • agi-app-pytorch-playground
      • agi-app-tescia-diagnostic
      • agi-app-uav-queue
      • agi-app-uav-relay-queue
      • agi-apps

Roadmap

  • Roadmap
    • AGILab future work
      • Professional target
        • Professional scorecard
        • Phase plan
        • Sequencing rules
      • Professionalization priority order
        • P0. Release and runtime integrity
        • P1. First-run product experience
        • P2. Notebook interop and no-lock-in
        • P3. Security and supply-chain posture
        • P4. Team and cluster operation
        • P5. Evidence-driven MLOps bridge
        • P6. Extension architecture and maintainability
        • P7. Ecosystem and distribution
      • Professional execution backlog
        • Priority 1. Clean release lane
        • Priority 2. Notebook import parity
        • Priority 3. First-run wizard contract
        • Priority 4. Runtime failure diagnostics
        • Priority 5. Security and shared-use hardening
        • Priority 6. Cluster and team operation
        • Priority 7. Evidence and promotion workflow
        • Priority 8. Connector-backed data access
        • Priority 9. Extension and design-pattern guardrails
        • Priority 10. Curated app ecosystem
        • Priority 11. Multi-app DAG productization
        • Priority 12. Observability and MLOps handoff
        • Explicit non-priorities until the above is stable
      • Feature sequencing after the professional baseline
      • Streamlit-inspired AGILab views
        • 1. Experiment Cockpit
        • 2. Evidence / Release View
        • 3. Scenario Playback View
        • 4. Realtime Analytical and Geospatial Views
        • 5. Run Diff / Counterfactual Analysis
        • 6. Multi-app DAG orchestration
        • 7. Multi-app DAG orchestration productization
        • 8. Bidirectional notebook interop
      • Logging modernization
      • Backend observability and audit architecture
        • 1. Elastic or OpenSearch + Grafana
        • 2. OpenSearch + OpenSearch Dashboards
        • 3. Postgres + Superset
      • Connectors and integration
        • Audience bridge strategy
        • 1. Connector framework hardening
      • Distributed execution and reduction
        • 1. Reduce contract adoption
        • 2. Data connector facility
        • 3. Connector-aware views
        • 4. DeepWiki/Open-style repository knowledge layer
      • Decision guidance
      • Final consolidated poll
        • Comment template for issues/2
        • Current candidate priorities
      • Reference URLs
    • Audience bridges
      • Executive recommendation
      • Shipped MVP baseline
      • Bridge priority ranking
      • 1. Quarto / R bridge first
        • Quarto MVP
      • 2. R users
      • 3. MCP and agent evidence bridge, read-first
      • 4. Hugging Face bridge
      • 5. MLflow bridge
      • 6. VS Code and devcontainers
      • 7. DuckDB / dbt / SQL bridge
      • 8. Airflow / Dagster exporter
      • Recommended implementation order
      • Implementation baseline
      • Product story
    • Workflow Maintainability Patterns
      • Design Patterns
      • Roadmap Item: Pattern-Gated Workflow Changes
      • Current Status
      • Recommended Sequence
      • First Slice Acceptance Criteria
    • Feature: versioned pipeline stage templates
      • Problem
      • Current product stance
      • Proposal
      • Example shape
      • Expected behaviour
      • Why this is better
      • Transition plan
        • Phase 1
        • Phase 2
        • Phase 3
        • Phase 4
      • Non-goals
      • Product impact
AGILab
  • Overview: module code

All modules for which code is available

  • agi_node.agi_dispatcher.base_worker
  • agi_node.dag_worker.dag_worker
  • agi_node.pandas_worker.pandas_worker
  • agi_node.polars_worker.polars_worker
  • agilab.lab_run
  • flight_telemetry.flight_args
  • flight_telemetry.flight_telemetry
  • flight_telemetry_worker.flight_telemetry_worker
  • minimal_app.app_args
  • minimal_app.minimal_app
  • minimal_app_worker.minimal_app_worker

© Copyright 2026, THALES SIX GTS France SAS.

Built with Sphinx using a theme provided by Read the Docs.