{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github-uditgoenka--autoresearch","slug":"uditgoenka--autoresearch","name":"autoresearch","type":"skill","url":"https://udit.co/projects/autoresearch","page_url":"https://unfragile.ai/uditgoenka--autoresearch","categories":["ai-agents"],"tags":["ai","autonomous-agent","autoresearch","claude","claude-code","iteration","karpathy","productivity","skill"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github-uditgoenka--autoresearch__cap_0","uri":"capability://automation.workflow.constraint.driven.autonomous.iteration.loop","name":"constraint-driven autonomous iteration loop","description":"Executes a repeating cycle of code modification → git commit → mechanical verification → decision logic → result logging that continues until user interruption or iteration limit. The system uses a constraint triangle (scope glob patterns, single mechanical metric, shell verify command) to enable autonomous operation without subjective judgment. Git serves as both memory and causality tracker, with automatic rollback on verification failure.","intents":["I want Claude to autonomously improve my codebase against a measurable metric without manual intervention between iterations","I need to run 50+ iterations of code changes with automatic rollback on failure and full audit trail","I want to explore a large solution space (e.g., algorithm variants, hyperparameters) with bounded or unbounded iteration counts"],"best_for":["ML researchers and data scientists optimizing metrics (test coverage, accuracy, latency)","teams automating code quality improvements with measurable success criteria","developers exploring solution spaces where manual iteration is prohibitively slow"],"limitations":["Requires well-defined mechanical metric — subjective goals (code readability, maintainability) cannot be automated","Git-based rollback assumes clean working directory; uncommitted changes are lost on failure","Metric extraction via shell command must be deterministic and fast (>5s per iteration adds significant overhead)","No built-in handling for metrics that plateau or oscillate — requires manual intervention or custom decision logic","Scope constraints must be precise; overly broad globs risk unintended file modifications"],"requires":["Git repository initialized in working directory","Claude Code environment (Anthropic's Claude with code execution capability)","Shell command that outputs a parseable metric (numeric value, percentage, or structured output)","Glob patterns for in-scope files (e.g., src/**/*.ts, test/**/*.test.ts)","Baseline metric measurement before first iteration"],"input_types":["plain-language goal description","scope glob patterns (file paths to modify)","shell verify command (e.g., npm test -- --coverage)","bounded iteration count (optional, default unbounded)"],"output_types":["autoresearch-results.tsv (tab-separated iteration history with timestamp, metric value, git hash, status)","git commit history (one commit per iteration with Claude's modification summary)","summary report (final metric, total iterations, improvement delta)"],"categories":["automation-workflow","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-uditgoenka--autoresearch__cap_1","uri":"capability://planning.reasoning.interactive.goal.to.configuration.wizard","name":"interactive goal-to-configuration wizard","description":"Converts plain-language goals into structured autoresearch configurations via a 7-phase guided workflow. The wizard validates scope constraints, suggests mechanical metrics from a database of domain-specific examples, and generates shell verify commands. Each phase includes validation gates that ensure the configuration is executable before iteration begins.","intents":["I have a goal but don't know how to define scope, metric, and verify command for autoresearch","I want Claude to suggest appropriate metrics for my domain (test coverage, latency, accuracy, etc.)","I need to validate my configuration before committing to a long iteration loop"],"best_for":["non-expert users new to constraint-driven iteration","teams standardizing on autoresearch across multiple projects","developers prototyping new autoresearch use cases"],"limitations":["Metric suggestion database is domain-specific; novel domains may require manual metric definition","Validation gates assume shell commands are available in the environment; custom verification logic may fail validation","Wizard cannot auto-detect optimal scope boundaries; overly broad or narrow scopes require manual adjustment","No support for multi-metric optimization; only single mechanical metric per configuration"],"requires":["Claude Code environment","Git repository initialized","Plain-language description of improvement goal","Access to metric suggestion database (bundled with autoresearch)"],"input_types":["natural language goal description","project type/domain (for metric suggestions)","file paths or glob patterns (for scope definition)"],"output_types":["structured configuration (scope, metric, verify command, iteration limit)","validation report (scope coverage, metric parsability, verify command test run)","suggested metrics ranked by relevance"],"categories":["planning-reasoning","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-uditgoenka--autoresearch__cap_10","uri":"capability://automation.workflow.scope.constraint.enforcement.with.glob.patterns","name":"scope constraint enforcement with glob patterns","description":"Restricts code modifications to files matching user-defined glob patterns (e.g., src/**/*.ts, test/**/*.test.ts). The system validates scope during setup, ensures Claude only modifies in-scope files, and logs scope violations as errors. Scope constraints enable the agent to load full context into memory without overwhelming token limits and prevent unintended modifications to configuration, documentation, or other sensitive files.","intents":["I want Claude to only modify source files, not tests or configuration","I need to prevent Claude from modifying sensitive files (e.g., .env, package.json)","I want to limit the scope to a specific directory or file pattern"],"best_for":["teams with large codebases where full-codebase context is infeasible","projects with strict separation of concerns (source vs tests vs config)","developers preventing accidental modifications to sensitive files"],"limitations":["Glob patterns must be precise; overly broad patterns risk unintended modifications, overly narrow patterns limit optimization","No support for negative patterns (exclude files); only inclusion patterns are supported","Scope validation is static (checked at setup); runtime scope violations are not detected","No built-in handling for scope conflicts (e.g., overlapping patterns); users must resolve manually","Scope constraints are per-iteration; no support for dynamic scope changes based on metric feedback"],"requires":["Glob patterns for in-scope files (e.g., src/**/*.ts)","File system access to validate patterns","Clear separation between in-scope and out-of-scope files"],"input_types":["glob patterns (array of strings, e.g., [src/**/*.ts, test/**/*.test.ts])"],"output_types":["validated scope (list of files matching patterns)","scope coverage report (number of files, total lines of code)"],"categories":["automation-workflow","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-uditgoenka--autoresearch__cap_11","uri":"capability://automation.workflow.crash.recovery.and.error.resilience","name":"crash recovery and error resilience","description":"Implements strategies for recovering from iteration failures (e.g., verify command timeout, git rollback failure, metric extraction error). The system logs errors with full context (iteration number, command output, stack trace), automatically rolls back failed iterations, and continues to the next iteration. For unrecoverable errors (e.g., git corruption), the system halts and logs detailed diagnostics to enable manual recovery.","intents":["I want Claude to automatically recover from transient failures (e.g., test timeouts) without halting iteration","I need detailed error logs to debug why an iteration failed","I want automatic rollback on failure without manual git operations"],"best_for":["teams running long-iteration loops (100+ iterations) where transient failures are likely","developers debugging iteration failures","projects with flaky tests or non-deterministic verification commands"],"limitations":["Recovery strategies are limited to automatic rollback; no retry logic or exponential backoff","Unrecoverable errors (e.g., git corruption) halt iteration; manual recovery is required","Error logs are verbose; large iteration counts produce large log files","No built-in alerting; users must monitor logs to detect failures","Crash recovery assumes clean git state; corrupted repositories may fail to rollback"],"requires":["Git repository in clean state (for rollback)","Sufficient disk space for error logs","Write permissions to error log files"],"input_types":["error type (verify failure, git failure, metric extraction error)","error message and stack trace","iteration metadata (number, timestamp)"],"output_types":["error log (detailed diagnostics)","recovery action (rollback, halt, continue)","recovery status (success, failure, manual intervention required)"],"categories":["automation-workflow","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-uditgoenka--autoresearch__cap_2","uri":"capability://safety.moderation.adversarial.security.audit.loop","name":"adversarial security audit loop","description":"Executes autonomous security testing via an adversarial iteration loop that applies STRIDE threat modeling and OWASP vulnerability patterns. Each iteration generates adversarial test cases, runs them against the codebase, and logs security findings. The loop uses a threat model as the constraint and vulnerability count as the mechanical metric, enabling autonomous security hardening.","intents":["I want Claude to autonomously discover and fix security vulnerabilities in my code","I need to systematically test my application against STRIDE/OWASP threat categories","I want to track security improvements across iterations with full audit trail"],"best_for":["security teams automating vulnerability discovery and remediation","developers hardening applications before production deployment","compliance-driven projects requiring documented security testing"],"limitations":["Adversarial loop cannot discover zero-day vulnerabilities outside STRIDE/OWASP scope","Metric (vulnerability count) depends on test quality; weak tests may report false negatives","Security fixes may introduce functional regressions; requires separate regression test suite","No integration with external security scanners (SAST/DAST tools); relies on custom verify commands","Threat model must be manually defined; no auto-generation of threat models from architecture"],"requires":["Claude Code environment","Git repository initialized","STRIDE threat model or OWASP category list","Security test suite or custom vulnerability detection command","Baseline vulnerability count"],"input_types":["threat model (STRIDE categories or OWASP top 10)","security test command (e.g., npm run security-audit)","scope (files to harden)","iteration limit"],"output_types":["autoresearch-results.tsv with vulnerability counts per iteration","security audit report (threats tested, vulnerabilities found, fixes applied)","git commit history with security-focused change descriptions"],"categories":["safety-moderation","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-uditgoenka--autoresearch__cap_3","uri":"capability://memory.knowledge.git.based.iteration.memory.and.causality.tracking","name":"git-based iteration memory and causality tracking","description":"Uses Git commits as the primary memory mechanism, storing one commit per iteration with Claude's modification summary in the commit message. Each commit is tagged with iteration metadata (metric value, timestamp, decision status). On verification failure, the system automatically reverts to the previous commit, preserving causality and enabling crash recovery. The git log serves as a queryable audit trail of all attempted improvements.","intents":["I want a complete audit trail of every code change Claude attempted, including failures","I need to revert failed iterations automatically without manual git operations","I want to analyze which types of changes improved the metric vs degraded it"],"best_for":["teams requiring compliance-grade audit trails of automated changes","researchers analyzing which code modifications correlate with metric improvements","developers debugging why a particular iteration failed"],"limitations":["Requires clean git working directory before iteration; uncommitted changes are lost on rollback","Commit message parsing is fragile; malformed summaries may break iteration history analysis","Git storage overhead grows linearly with iteration count; 1000+ iterations may slow git operations","No built-in deduplication; identical changes across iterations create redundant commits","Rollback is atomic per iteration; partial rollback (e.g., revert one file) is not supported"],"requires":["Git repository initialized with at least one commit","Clean working directory (no uncommitted changes)","Write permissions to .git directory","Sufficient disk space for iteration commits"],"input_types":["code modifications (generated by Claude)","metric value (from verify command)","iteration metadata (timestamp, decision status)"],"output_types":["git commits (one per iteration with metadata in message)","git log (queryable history of all iterations)","autoresearch-results.tsv (parallel TSV log for analysis)"],"categories":["memory-knowledge","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-uditgoenka--autoresearch__cap_4","uri":"capability://data.processing.analysis.mechanical.metric.extraction.and.validation","name":"mechanical metric extraction and validation","description":"Executes a user-provided shell command to extract a single numeric metric from test output, build logs, or custom scripts. The metric is parsed deterministically (e.g., grep for percentage, regex for latency value) and compared against the previous iteration to decide Keep/Discard. The system validates metric extraction during setup and caches baseline measurements to enable fast iteration-to-iteration comparisons.","intents":["I want Claude to automatically extract test coverage from npm test output and optimize for it","I need to measure latency from a benchmark script and track improvements across iterations","I want to define a custom metric (e.g., code complexity score) and have Claude optimize it"],"best_for":["developers with measurable success criteria (coverage, latency, accuracy, complexity)","teams using CI/CD pipelines that already output metrics","researchers optimizing for domain-specific metrics"],"limitations":["Metric must be numeric and deterministic; non-deterministic outputs (e.g., flaky tests) cause decision errors","Metric extraction via regex is fragile; output format changes break parsing","No support for multi-objective optimization; only single metric per iteration","Metric command must complete in reasonable time; slow commands (>30s) block iteration","No built-in handling for metric saturation or diminishing returns; requires manual stopping criteria"],"requires":["Shell command that outputs metric (e.g., npm test -- --coverage | grep 'All files')","Deterministic metric output (same input always produces same metric value)","Baseline metric measurement before first iteration","Regex or parsing logic to extract numeric value from command output"],"input_types":["shell command string (e.g., npm test -- --coverage)","metric extraction regex or parsing logic","comparison operator (maximize vs minimize)"],"output_types":["numeric metric value (float or integer)","metric delta (improvement vs previous iteration)","decision signal (Keep if improved, Discard if degraded)"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-uditgoenka--autoresearch__cap_5","uri":"capability://automation.workflow.bounded.and.unbounded.iteration.modes","name":"bounded and unbounded iteration modes","description":"Supports two iteration strategies: bounded mode (run exactly N iterations, then stop) and unbounded mode (run until user interruption). Bounded mode is useful for exploration with a fixed budget; unbounded mode enables continuous improvement until diminishing returns. The system tracks iteration count, elapsed time, and metric trajectory to inform stopping decisions.","intents":["I want to run exactly 50 iterations and then analyze the results","I want Claude to keep improving indefinitely until I manually stop it","I want to set a time budget (e.g., 1 hour) and run as many iterations as possible"],"best_for":["researchers with fixed compute budgets (e.g., 50 iterations per experiment)","teams running autoresearch in CI/CD with time constraints","developers exploring solution spaces without predetermined stopping criteria"],"limitations":["Bounded mode requires pre-specifying iteration count; no adaptive stopping based on metric plateau","Unbounded mode can run indefinitely, consuming compute resources if metric plateaus","No built-in time budget enforcement; long-running verify commands can exceed wall-clock limits","Iteration count is not a proxy for convergence; 100 iterations may be insufficient or excessive depending on domain","No support for early stopping based on metric stagnation (e.g., no improvement for 10 iterations)"],"requires":["Iteration limit (for bounded mode) or manual interruption signal (for unbounded mode)","Sufficient compute resources for maximum iteration count","Metric that improves monotonically or has clear convergence behavior"],"input_types":["iteration limit (integer, optional; default unbounded)","time budget (optional; not enforced by system)"],"output_types":["iteration count at completion","total elapsed time","metric trajectory (improvement per iteration)"],"categories":["automation-workflow","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-uditgoenka--autoresearch__cap_6","uri":"capability://planning.reasoning.decision.logic.with.keep.discard.crash.handling","name":"decision logic with keep/discard/crash handling","description":"Implements explicit decision logic that compares the current iteration's metric against the previous best metric and decides to Keep (commit and continue), Discard (rollback and continue), or Crash (halt on unrecoverable error). Keep decisions are based on metric improvement; Discard decisions trigger automatic git rollback; Crash decisions log the error and stop iteration. The decision logic is deterministic and transparent, enabling users to understand why each iteration was accepted or rejected.","intents":["I want Claude to automatically keep improvements and discard regressions","I need to understand why each iteration was accepted or rejected","I want automatic rollback on failure without manual git operations"],"best_for":["teams requiring transparent decision logic in autonomous systems","developers debugging why iterations were discarded","researchers analyzing which changes correlate with metric improvements"],"limitations":["Decision logic is binary (Keep/Discard); no support for conditional keeps (e.g., accept small regressions if they enable future improvements)","Metric comparison is greedy; no lookahead to detect local optima","Crash handling is coarse-grained; no recovery strategies for transient failures (e.g., network timeouts)","No support for multi-objective decisions (e.g., maximize accuracy while minimizing latency)","Decision transparency requires parsing commit messages and TSV logs; no structured decision API"],"requires":["Previous iteration's metric value (for comparison)","Current iteration's metric value (from verify command)","Git repository in clean state (for rollback)"],"input_types":["current metric value","previous best metric value","error status (success, verify failure, crash)"],"output_types":["decision signal (Keep/Discard/Crash)","decision rationale (metric delta, error message)","git operation (commit or rollback)"],"categories":["planning-reasoning","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-uditgoenka--autoresearch__cap_7","uri":"capability://data.processing.analysis.results.logging.and.iteration.history.analysis","name":"results logging and iteration history analysis","description":"Logs all iteration results to autoresearch-results.tsv in a tab-separated format with columns for iteration number, timestamp, metric value, git commit hash, decision status, and error message. The TSV format enables easy parsing and analysis; users can query iteration history to identify patterns (e.g., which types of changes improved the metric). Summary reports aggregate results across iterations and compute statistics (total improvement, iterations to convergence, etc.).","intents":["I want to export iteration results for analysis in Excel or Python","I need to identify which iterations improved the metric and why","I want to compute statistics (total improvement, convergence rate) across iterations"],"best_for":["researchers analyzing optimization trajectories","teams tracking autoresearch progress in dashboards or reports","developers debugging iteration failures"],"limitations":["TSV format is flat; no hierarchical structure for complex iteration metadata","No built-in visualization; users must export to Excel or Python for plotting","Summary reports are static; no real-time dashboards or streaming updates","Iteration history is append-only; no support for deleting or modifying past iterations","No integration with external analytics tools (e.g., Datadog, CloudWatch)"],"requires":["Write permissions to autoresearch-results.tsv file","Sufficient disk space for iteration logs (typically <1MB per 1000 iterations)"],"input_types":["iteration metadata (number, timestamp, metric, commit hash, decision, error)"],"output_types":["autoresearch-results.tsv (tab-separated iteration log)","summary report (total improvement, convergence statistics)","git log (parallel commit history)"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-uditgoenka--autoresearch__cap_8","uri":"capability://tool.use.integration.mcp.server.integration.for.external.tool.orchestration","name":"mcp server integration for external tool orchestration","description":"Integrates with Model Context Protocol (MCP) servers to enable Claude to call external tools and services during iteration. The system can invoke MCP-exposed functions (e.g., custom linters, external APIs, specialized test runners) as part of the verify command or modification process. MCP integration enables autoresearch to work with heterogeneous toolchains without embedding tool-specific logic.","intents":["I want Claude to call my custom linter via MCP during each iteration","I need to integrate autoresearch with external services (e.g., cloud-based test runners, security scanners)","I want to extend autoresearch with domain-specific tools without modifying the core system"],"best_for":["teams with heterogeneous toolchains (multiple languages, platforms, services)","organizations with custom tools that need to be integrated into autoresearch","developers building domain-specific autoresearch extensions"],"limitations":["MCP server must be running and accessible during iteration; network failures halt iteration","MCP function calls add latency to each iteration; slow external services degrade iteration throughput","No built-in error handling for MCP failures; custom verify commands must handle timeouts and retries","MCP schema must be well-defined; ambiguous or complex schemas may confuse Claude's function calling","No caching of MCP results; identical function calls are re-executed each iteration"],"requires":["MCP server running and accessible (local or remote)","MCP server schema definition (tool names, parameters, return types)","Custom verify command that invokes MCP functions","Network connectivity to MCP server (if remote)"],"input_types":["MCP server endpoint (local socket or HTTP URL)","MCP function name and parameters","custom verify command that calls MCP functions"],"output_types":["MCP function results (returned to verify command)","metric value (extracted from MCP results)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-uditgoenka--autoresearch__cap_9","uri":"capability://tool.use.integration.custom.verification.command.execution.with.error.handling","name":"custom verification command execution with error handling","description":"Executes user-provided shell commands to verify improvements and extract metrics. The system handles command failures gracefully (logs error, triggers Discard decision), captures stdout/stderr, and parses metric values using regex or custom extraction logic. Verification commands can be arbitrarily complex (e.g., multi-step build + test + benchmark pipelines) as long as they output a parseable metric.","intents":["I want to run a complex test suite (build + test + coverage) and extract coverage percentage","I need to run a benchmark script and extract latency metrics","I want to define custom verification logic that Claude can't directly implement"],"best_for":["teams with complex verification pipelines (multi-step builds, distributed tests)","developers with domain-specific verification logic (custom benchmarks, specialized tests)","projects where metric extraction requires complex parsing"],"limitations":["Verification command must complete in reasonable time; slow commands block iteration","Command output must be deterministic; flaky tests or non-deterministic benchmarks cause decision errors","Metric extraction via regex is fragile; output format changes break parsing","No built-in timeout enforcement; hung commands can block iteration indefinitely","Error handling is coarse-grained; all command failures trigger Discard, even transient failures"],"requires":["Shell command that outputs metric (e.g., npm test -- --coverage)","Deterministic command output (same input always produces same metric)","Metric extraction regex or parsing logic","Timeout value (recommended: 30-60 seconds)"],"input_types":["shell command string","metric extraction regex or parsing logic","timeout value (seconds)"],"output_types":["command exit code (0 for success, non-zero for failure)","stdout/stderr (logged for debugging)","extracted metric value (numeric)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":38,"verified":false,"data_access_risk":"high","permissions":["Git repository initialized in working directory","Claude Code environment (Anthropic's Claude with code execution capability)","Shell command that outputs a parseable metric (numeric value, percentage, or structured output)","Glob patterns for in-scope files (e.g., src/**/*.ts, test/**/*.test.ts)","Baseline metric measurement before first iteration","Claude Code environment","Git repository initialized","Plain-language description of improvement goal","Access to metric suggestion database (bundled with autoresearch)","Glob patterns for in-scope files (e.g., src/**/*.ts)"],"failure_modes":["Requires well-defined mechanical metric — subjective goals (code readability, maintainability) cannot be automated","Git-based rollback assumes clean working directory; uncommitted changes are lost on failure","Metric extraction via shell command must be deterministic and fast (>5s per iteration adds significant overhead)","No built-in handling for metrics that plateau or oscillate — requires manual intervention or custom decision logic","Scope constraints must be precise; overly broad globs risk unintended file modifications","Metric suggestion database is domain-specific; novel domains may require manual metric definition","Validation gates assume shell commands are available in the environment; custom verification logic may fail validation","Wizard cannot auto-detect optimal scope boundaries; overly broad or narrow scopes require manual adjustment","No support for multi-metric optimization; only single mechanical metric per configuration","Glob patterns must be precise; overly broad patterns risk unintended modifications, overly narrow patterns limit optimization","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.3055534293762288,"quality":0.49,"ecosystem":0.6000000000000001,"match_graph":0.25,"freshness":0.75,"weights":{"adoption":0.15,"quality":0.25,"ecosystem":0.1,"match_graph":0.45,"freshness":0.05}},"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:22.064Z","last_scraped_at":"2026-05-03T13:57:09.057Z","last_commit":"2026-05-02T11:21:25Z"},"community":{"stars":4250,"forks":327,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=uditgoenka--autoresearch","compare_url":"https://unfragile.ai/compare?artifact=uditgoenka--autoresearch"}},"signature":"Zy+QU/U9bJwDLSnhVgtDd4O7uo9y2XpOlDHd2l7REW5P7HGspVhiKv5R6dogdkdHWEZdzT64OrCzoeuJtW7iDQ==","signedAt":"2026-06-20T01:39:54.560Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/uditgoenka--autoresearch","artifact":"https://unfragile.ai/uditgoenka--autoresearch","verify":"https://unfragile.ai/api/v1/verify?slug=uditgoenka--autoresearch","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"}}