{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github-inclusionai--areal","slug":"inclusionai--areal","name":"AReaL","type":"agent","url":"https://inclusionai.github.io/AReaL/","page_url":"https://unfragile.ai/inclusionai--areal","categories":["ai-agents"],"tags":["agent","llm","llm-agent","llm-reasoning","machine-learning-systems","mlsys","reinforcement-learning","rl"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github-inclusionai--areal__cap_0","uri":"capability://automation.workflow.distributed.rl.training.orchestration.with.multiple.parallelism.strategies","name":"distributed-rl-training-orchestration-with-multiple-parallelism-strategies","description":"Orchestrates large-scale reinforcement learning training across distributed clusters using pluggable training engines (FSDP, Megatron, Archon) that support multiple parallelism strategies including tensor parallelism, pipeline parallelism, sequence parallelism (Ulysses), and MoE expert parallelism. The system abstracts away distributed training complexity through a unified TrainEngine API while managing device meshes, process groups, and weight synchronization protocols across heterogeneous hardware configurations.","intents":["Train large language models with RL algorithms across multi-node GPU clusters without manual distributed training boilerplate","Switch between different parallelism strategies (FSDP vs Megatron vs Archon) without rewriting training logic","Optimize memory utilization and throughput by selecting appropriate parallelism constraints for specific model architectures","Scale training from single-node to multi-node setups with automatic job scheduling and worker management"],"best_for":["ML teams training large language models (7B-70B+ parameters) on RL tasks","Researchers experimenting with different parallelism strategies for agent training","Organizations with heterogeneous GPU clusters (A100, H100, etc.) requiring flexible scheduling"],"limitations":["Requires careful memory estimation and allocation_mode configuration to avoid OOM errors on complex multi-node setups","FSDP, Megatron, and Archon engines have different performance characteristics; no automatic selection of optimal engine","Distributed training debugging complexity increases significantly with number of nodes; requires SLURM or Ray cluster setup","Weight synchronization overhead scales with model size and number of training steps; no built-in gradient compression"],"requires":["Python 3.9+","PyTorch 2.0+ with distributed training support","CUDA 11.8+ for GPU training","SLURM, Ray, or SkyPilot for multi-node job scheduling","Shared storage (NFS, S3) for checkpoint persistence across nodes"],"input_types":["training configuration (YAML/dataclass)","model weights (HuggingFace format)","training data (tokenized sequences)"],"output_types":["trained model checkpoints","training metrics and logs","weight update metadata"],"categories":["automation-workflow","distributed-training"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-inclusionai--areal__cap_1","uri":"capability://automation.workflow.asynchronous.inference.with.pluggable.backends.and.weight.updates","name":"asynchronous-inference-with-pluggable-backends-and-weight-updates","description":"Manages high-throughput inference serving through pluggable backends (SGLang, vLLM) with asynchronous rollout execution that decouples inference from training. The InferenceEngine API abstracts backend-specific details while supporting dynamic weight updates via a protocol-based system that allows training engines to push updated weights to inference servers without service interruption. Handles server lifecycle management, async request batching, and multi-turn conversation state tracking.","intents":["Run inference at scale while training is happening, with weights synchronized from training engines","Switch between SGLang and vLLM backends without changing application code","Collect rollout trajectories from agent interactions asynchronously for RL training","Maintain multi-turn conversation state and session tracking across distributed inference servers"],"best_for":["Teams running continuous inference-training loops for agentic RL","Applications requiring high-throughput inference with dynamic model updates","Researchers collecting diverse rollout data from agent interactions in parallel"],"limitations":["Weight update latency depends on model size and network bandwidth; large models may have stale weights during inference","Backend-specific optimizations (e.g., SGLang's RadixAttention) not automatically leveraged; requires explicit configuration","No built-in load balancing across multiple inference servers; requires external orchestration (Ray, Kubernetes)","Session state stored in-memory; no persistence across server restarts without external state store"],"requires":["Python 3.9+","SGLang or vLLM installed and configured","GPU with sufficient VRAM for model inference (varies by model size)","Network connectivity between training and inference servers for weight updates"],"input_types":["prompts (text)","generation hyperparameters (temperature, top_p, etc.)","weight update payloads (model state dicts)"],"output_types":["generated text completions","token logits and probabilities","interaction trajectories with rewards"],"categories":["automation-workflow","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-inclusionai--areal__cap_10","uri":"capability://automation.workflow.configuration.system.with.cli.and.dataclass.validation","name":"configuration-system-with-cli-and-dataclass-validation","description":"Implements a comprehensive configuration system using Python dataclasses with CLI argument parsing and validation. The system supports hierarchical configuration with allocation_mode syntax for specifying parallelism strategies, training engine parameters, inference configurations, and algorithm-specific settings. Configuration validation ensures compatibility between different components (e.g., parallelism constraints) before training starts. Supports configuration inheritance and overrides through CLI arguments.","intents":["Specify complex training configurations (parallelism, batch sizes, algorithms) through CLI or config files","Validate configurations for compatibility and correctness before training","Override configuration values through CLI arguments without modifying config files","Document all configuration options with type hints and validation rules"],"best_for":["Teams managing multiple training configurations for different models and tasks","Researchers experimenting with different hyperparameter combinations","Organizations automating training job submission with configuration management"],"limitations":["Complex allocation_mode syntax has steep learning curve; documentation required for new users","Configuration validation is static; doesn't catch runtime incompatibilities","CLI argument parsing doesn't support nested configuration; requires config files for complex setups","Configuration changes require restarting training; no dynamic reconfiguration during training"],"requires":["Python 3.9+","Understanding of allocation_mode syntax and configuration structure"],"input_types":["CLI arguments","YAML/JSON configuration files","environment variables"],"output_types":["validated configuration dataclass","configuration documentation","error messages for invalid configurations"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-inclusionai--areal__cap_11","uri":"capability://automation.workflow.multi.node.training.with.automatic.shared.storage.validation","name":"multi-node-training-with-automatic-shared-storage-validation","description":"Enables multi-node training across SLURM, Ray, and SkyPilot clusters with automatic validation of shared storage accessibility and performance. The system checks that all nodes can access shared storage before training starts, preventing silent failures due to misconfigured NFS or S3 paths. Supports different storage backends (NFS, S3) with backend-specific validation. Handles checkpoint and data synchronization across nodes through shared storage.","intents":["Train models across multiple nodes with automatic validation of shared storage setup","Detect storage configuration issues before training starts rather than failing mid-training","Support different storage backends (NFS, S3) without code changes","Ensure checkpoint consistency across distributed training engines"],"best_for":["Teams training large models on multi-node clusters","Organizations with heterogeneous storage backends (NFS + S3)","Researchers scaling training from single-node to multi-node"],"limitations":["Shared storage validation only checks accessibility; doesn't verify performance or consistency guarantees","S3 storage has higher latency than NFS; may become bottleneck for frequent checkpoint operations","Storage bandwidth is shared across all nodes; may limit training throughput for I/O-intensive workloads","No automatic storage failover; single storage node failure stops all training"],"requires":["Python 3.9+","Shared storage (NFS or S3) accessible from all nodes","Proper permissions for reading/writing to shared storage","Network connectivity between all nodes and storage"],"input_types":["shared storage path","storage backend type (NFS or S3)"],"output_types":["validation results","storage performance metrics","error messages for misconfigured storage"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-inclusionai--areal__cap_2","uri":"capability://planning.reasoning.multi.turn.agentic.rl.with.tool.integration.and.reward.assignment","name":"multi-turn-agentic-rl-with-tool-integration-and-reward-assignment","description":"Enables reinforcement learning training for multi-turn agent interactions through an ArealOpenAI client that proxies OpenAI-compatible APIs, capturing tool calls, multi-turn conversations, and intermediate rewards. The system tracks interaction sessions via InteractionCache, assigns rewards with configurable discounting schemes, and exports complete trajectories for RL training. Tool call integration allows agents to use external functions while maintaining full observability of the interaction flow for reward assignment.","intents":["Train agents on multi-turn tasks where rewards are assigned at intermediate steps or episode end","Capture tool calls and function execution results as part of agent trajectories for RL training","Implement custom reward functions that depend on intermediate agent actions and observations","Export agent interaction data in formats compatible with RL training pipelines"],"best_for":["Teams building agentic systems that need RL fine-tuning on task-specific behaviors","Researchers studying multi-turn reasoning and tool use in language models","Applications where agent quality improves through interaction-based reward signals"],"limitations":["Reward assignment requires manual definition of reward functions; no automatic reward inference","Multi-turn conversation state must fit in memory; no built-in streaming for very long conversations","Tool call integration assumes OpenAI-compatible API format; custom tool schemas require adapter code","Discounting schemes are fixed at configuration time; dynamic reward adjustment during training not supported"],"requires":["Python 3.9+","OpenAI-compatible API endpoint (local or remote)","Reward function implementation (custom Python code)","Tool definitions in OpenAI function calling format"],"input_types":["user prompts (text)","tool definitions (JSON schema)","reward signals (numeric values)"],"output_types":["interaction trajectories (states, actions, rewards)","tool call logs with results","session metadata and statistics"],"categories":["planning-reasoning","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-inclusionai--areal__cap_3","uri":"capability://planning.reasoning.configurable.rl.algorithm.implementation.with.ppo.and.grpo.variants","name":"configurable-rl-algorithm-implementation-with-ppo-and-grpo-variants","description":"Implements multiple reinforcement learning algorithms (PPO, GRPO and variants) with configurable hyperparameters, reference model management, and critic networks. The system supports asynchronous training orchestration where multiple rollout workers feed trajectories into a centralized trainer that computes policy gradients, value function losses, and KL divergence penalties. Reference models and critic networks are managed separately to enable efficient computation of advantage estimates and policy divergence constraints.","intents":["Train language models using PPO or GRPO algorithms with customizable hyperparameters","Manage reference models and critic networks for advantage estimation and KL penalty computation","Orchestrate asynchronous training where rollout collection and gradient updates happen in parallel","Experiment with algorithm variants (e.g., different reward normalization, advantage estimation schemes)"],"best_for":["ML teams implementing custom RL training pipelines for language models","Researchers experimenting with PPO/GRPO variants and hyperparameter tuning","Organizations training models on task-specific reward signals"],"limitations":["Reference model and critic network must fit in GPU memory alongside training model; no automatic offloading","Algorithm hyperparameters (learning rate, entropy coefficient, KL penalty) require manual tuning; no automatic scheduling","Advantage estimation assumes on-policy data; off-policy corrections not implemented","No built-in support for importance sampling or other variance reduction techniques beyond baseline subtraction"],"requires":["Python 3.9+","PyTorch 2.0+","Sufficient GPU memory for model + reference model + critic (typically 2-3x model size)","Trajectory data with rewards and values"],"input_types":["trajectories (states, actions, rewards, values)","algorithm hyperparameters (learning rate, entropy coeff, etc.)","reference model weights"],"output_types":["policy gradients","training metrics (loss, KL divergence, entropy)","updated model weights"],"categories":["planning-reasoning","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-inclusionai--areal__cap_4","uri":"capability://data.processing.analysis.microbatch.processing.with.sequence.packing.and.memory.optimization","name":"microbatch-processing-with-sequence-packing-and-memory-optimization","description":"Implements efficient data processing through a MicroBatchSpec system that handles sequence packing, padding strategies, and memory-aware batching. The system normalizes and estimates memory requirements for different batch configurations, enabling automatic selection of batch sizes that maximize GPU utilization without OOM errors. Supports variable-length sequences with configurable packing strategies (e.g., pack multiple sequences into single training example) and normalization schemes for fair comparison across different batch configurations.","intents":["Automatically determine optimal batch sizes for training based on available GPU memory","Pack multiple variable-length sequences into single training examples to reduce padding overhead","Normalize training metrics across different batch configurations for fair comparison","Estimate memory requirements before training to catch configuration errors early"],"best_for":["Teams training on diverse datasets with variable-length sequences","Researchers optimizing GPU memory utilization and training throughput","Applications where padding overhead significantly impacts training efficiency"],"limitations":["Memory estimation is approximate; actual memory usage may vary by 10-20% depending on hardware and PyTorch version","Sequence packing changes effective batch size; requires careful normalization when comparing metrics across configurations","Padding strategy selection is manual; no automatic optimization based on sequence length distribution","Microbatch system adds ~5-10ms overhead per batch for packing and normalization"],"requires":["Python 3.9+","PyTorch 2.0+","Tokenized training data with sequence lengths"],"input_types":["raw sequences or token IDs","sequence lengths","batch size configuration"],"output_types":["packed and padded batches","memory estimates","normalization factors"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-inclusionai--areal__cap_5","uri":"capability://planning.reasoning.workflow.abstraction.for.custom.rollout.and.training.loops","name":"workflow-abstraction-for-custom-rollout-and-training-loops","description":"Provides a RolloutWorkflow API that abstracts the interaction between rollout collection and training, enabling custom implementations for different agent types and task structures. The system supports multi-turn and vision workflows through pluggable workflow implementations that define how agents interact with environments, how rewards are assigned, and how trajectories are exported. Rollout coordination ensures proper synchronization between multiple rollout workers and the training engine.","intents":["Implement custom rollout logic for specific agent architectures or task types without modifying core training code","Support multi-turn conversations and vision-based agent interactions through specialized workflow implementations","Coordinate multiple rollout workers collecting trajectories in parallel","Export trajectories in custom formats for downstream analysis or training"],"best_for":["Teams with custom agent architectures or non-standard task structures","Researchers implementing novel rollout strategies or reward assignment schemes","Applications combining multiple modalities (text, vision) in agent interactions"],"limitations":["Custom workflow implementation requires understanding of RolloutWorkflow API and trajectory format","Rollout coordination overhead increases with number of workers; no automatic load balancing","Vision workflows require additional dependencies (image processing libraries); not included by default","Trajectory export format is fixed; custom export formats require adapter code"],"requires":["Python 3.9+","Understanding of RolloutWorkflow API","Custom workflow implementation (Python code)","Environment or task definition compatible with workflow"],"input_types":["workflow configuration","agent prompts or observations","environment state"],"output_types":["trajectories (states, actions, rewards)","interaction logs","workflow metrics"],"categories":["planning-reasoning","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-inclusionai--areal__cap_6","uri":"capability://automation.workflow.distributed.job.scheduling.with.multiple.launcher.backends","name":"distributed-job-scheduling-with-multiple-launcher-backends","description":"Manages distributed training job scheduling through pluggable launcher backends (Local, Ray, SLURM, SkyPilot) that abstract away cluster-specific details. The Scheduler API coordinates worker allocation, job lifecycle management, and RPC communication between training and inference engines. Supports automatic shared storage validation to ensure checkpoints and data are accessible across all nodes. Each launcher backend handles cluster-specific job submission, resource allocation, and failure recovery.","intents":["Submit training jobs to different cluster types (local, Ray, SLURM, cloud) without changing training code","Automatically validate that shared storage is accessible before starting distributed training","Manage worker lifecycle including startup, health checks, and graceful shutdown","Enable RPC communication between training engines and inference servers across cluster nodes"],"best_for":["Teams running training on heterogeneous clusters (local + SLURM + cloud)","Organizations migrating between cluster management systems","Researchers prototyping on single-node and scaling to multi-node without code changes"],"limitations":["Launcher backend selection is manual; no automatic detection of optimal launcher for given cluster","Shared storage validation only checks accessibility; doesn't verify performance or consistency","RPC communication adds latency (~10-50ms per call); not suitable for high-frequency communication","Failure recovery is basic; no automatic job restart or checkpoint recovery across launcher types"],"requires":["Python 3.9+","Cluster management system (Ray, SLURM, or SkyPilot)","Shared storage (NFS, S3) for multi-node training","Network connectivity between all nodes"],"input_types":["job configuration (workers, resources, launcher type)","training script and dependencies","shared storage path"],"output_types":["job ID and status","worker addresses for RPC communication","logs and error messages"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-inclusionai--areal__cap_7","uri":"capability://automation.workflow.checkpoint.management.with.distributed.recovery.and.metadata.tracking","name":"checkpoint-management-with-distributed-recovery-and-metadata-tracking","description":"Implements distributed checkpoint saving and recovery with automatic metadata tracking for training state, model weights, and optimizer state. The system supports incremental checkpointing where only changed weights are saved, reducing storage overhead. Checkpoint metadata includes training step, algorithm state, and configuration information, enabling resumption from any checkpoint with full reproducibility. Handles checkpoint coordination across distributed training engines to ensure consistency.","intents":["Save and resume training from arbitrary checkpoints without losing training progress","Reduce checkpoint storage overhead through incremental saving of only changed weights","Track training metadata (step, loss, algorithm state) for analysis and debugging","Ensure checkpoint consistency across distributed training engines"],"best_for":["Teams training large models where checkpoint storage is a significant cost","Long-running training jobs that need frequent checkpointing for fault tolerance","Researchers analyzing training dynamics across different checkpoints"],"limitations":["Incremental checkpointing requires tracking weight changes; adds ~5-10% overhead to training","Checkpoint recovery requires exact matching of training configuration; config changes may break recovery","Distributed checkpoint coordination adds latency (~100-500ms per checkpoint depending on model size)","No automatic checkpoint cleanup; requires manual deletion of old checkpoints to manage storage"],"requires":["Python 3.9+","Shared storage with sufficient capacity for model checkpoints","Checkpoint metadata schema matching training configuration"],"input_types":["model weights","optimizer state","training metadata (step, loss, etc.)"],"output_types":["checkpoint files (model + optimizer + metadata)","checkpoint metadata (JSON)","recovery information"],"categories":["automation-workflow","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-inclusionai--areal__cap_8","uri":"capability://automation.workflow.performance.tracing.and.session.visualization.for.debugging","name":"performance-tracing-and-session-visualization-for-debugging","description":"Provides integrated performance tracing and session visualization tools for debugging distributed training and inference. The system captures detailed traces of training steps, inference requests, and inter-engine communication, enabling identification of bottlenecks and performance issues. Session tracing tracks multi-turn agent interactions with timing information, allowing analysis of agent behavior and reward assignment. Trace visualization tools help developers understand system behavior and optimize configurations.","intents":["Identify performance bottlenecks in distributed training (communication, computation, I/O)","Debug multi-turn agent interactions by visualizing session traces with timing information","Analyze training dynamics by comparing traces across different configurations","Optimize system configuration based on detailed performance metrics"],"best_for":["Teams debugging performance issues in distributed training setups","Researchers analyzing agent behavior through session traces","Organizations optimizing training efficiency and reducing costs"],"limitations":["Tracing adds 5-15% overhead to training performance; not suitable for production inference","Trace files can be very large (GBs) for long training runs; requires careful storage management","Visualization tools require specific trace format; custom tracing requires adapter code","Session tracing only captures high-level events; low-level kernel profiling requires separate tools"],"requires":["Python 3.9+","Sufficient disk space for trace files","Visualization tools (included in AReaL)"],"input_types":["training/inference execution","session interactions"],"output_types":["trace files (JSON/binary format)","performance metrics (latency, throughput)","visualization data"],"categories":["automation-workflow","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-inclusionai--areal__cap_9","uri":"capability://tool.use.integration.huggingface.model.integration.with.automatic.architecture.detection","name":"huggingface-model-integration-with-automatic-architecture-detection","description":"Provides seamless integration with HuggingFace model hub through automatic architecture detection and model loading utilities. The system detects model architecture (LLaMA, Qwen, Mistral, etc.) and automatically selects appropriate training engine configurations and parallelism strategies. Supports LoRA fine-tuning as an alternative to full model training, reducing memory requirements and training time. Handles model tokenizer loading and configuration validation.","intents":["Load and train HuggingFace models without manual architecture-specific configuration","Automatically select optimal training engine and parallelism strategy based on model architecture","Use LoRA fine-tuning for memory-efficient training of large models","Validate model configurations before training to catch incompatibilities early"],"best_for":["Teams training standard HuggingFace models without custom architectures","Researchers experimenting with different models and architectures","Organizations with limited GPU memory using LoRA fine-tuning"],"limitations":["Automatic architecture detection only works for models in HuggingFace hub; custom models require manual configuration","LoRA fine-tuning reduces model capacity; not suitable for tasks requiring significant architectural changes","Tokenizer loading assumes standard HuggingFace format; custom tokenizers require adapter code","Architecture detection is heuristic-based; may fail for unusual model variants"],"requires":["Python 3.9+","HuggingFace transformers library","Model weights (downloaded from HuggingFace hub or local path)"],"input_types":["model name or path","training configuration"],"output_types":["loaded model and tokenizer","training engine configuration","parallelism strategy"],"categories":["tool-use-integration","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":45,"verified":false,"data_access_risk":"high","permissions":["Python 3.9+","PyTorch 2.0+ with distributed training support","CUDA 11.8+ for GPU training","SLURM, Ray, or SkyPilot for multi-node job scheduling","Shared storage (NFS, S3) for checkpoint persistence across nodes","SGLang or vLLM installed and configured","GPU with sufficient VRAM for model inference (varies by model size)","Network connectivity between training and inference servers for weight updates","Understanding of allocation_mode syntax and configuration structure","Shared storage (NFS or S3) accessible from all nodes"],"failure_modes":["Requires careful memory estimation and allocation_mode configuration to avoid OOM errors on complex multi-node setups","FSDP, Megatron, and Archon engines have different performance characteristics; no automatic selection of optimal engine","Distributed training debugging complexity increases significantly with number of nodes; requires SLURM or Ray cluster setup","Weight synchronization overhead scales with model size and number of training steps; no built-in gradient compression","Weight update latency depends on model size and network bandwidth; large models may have stale weights during inference","Backend-specific optimizations (e.g., SGLang's RadixAttention) not automatically leveraged; requires explicit configuration","No built-in load balancing across multiple inference servers; requires external orchestration (Ray, Kubernetes)","Session state stored in-memory; no persistence across server restarts without external state store","Complex allocation_mode syntax has steep learning curve; documentation required for new users","Configuration validation is static; doesn't catch runtime incompatibilities","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.5901787648452457,"quality":0.34,"ecosystem":0.6000000000000001,"match_graph":0.25,"freshness":0.75,"weights":{"adoption":0.25,"quality":0.25,"ecosystem":0.1,"match_graph":0.28,"freshness":0.12}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-05-24T12:16:21.550Z","last_scraped_at":"2026-05-03T13:57:11.504Z","last_commit":"2026-05-03T13:46:45Z"},"community":{"stars":5132,"forks":486,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=inclusionai--areal","compare_url":"https://unfragile.ai/compare?artifact=inclusionai--areal"}},"signature":"rXiHDNE6LU/8aCbrVagYbKloYdoe6PXI5nzhBNICVq4TJJCEYy/s6qgJK2qv7b19zmxmt7NtarNfam4Pr7aWAg==","signedAt":"2026-06-21T17:09:27.084Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/inclusionai--areal","artifact":"https://unfragile.ai/inclusionai--areal","verify":"https://unfragile.ai/api/v1/verify?slug=inclusionai--areal","publicKey":"https://unfragile.ai/api/v1/trust-passport-public-key","spec":"https://unfragile.ai/trust","schema":"https://unfragile.ai/schema.json","docs":"https://unfragile.ai/docs"}}