{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"tool_refraction-ai","slug":"refraction-ai","name":"Refraction AI","type":"agent","url":"https://www.refraction.dev","page_url":"https://unfragile.ai/refraction-ai","categories":["ai-agents"],"tags":[],"pricing":{"model":"freemium","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"tool_refraction-ai__cap_0","uri":"capability://code.generation.editing.cross.language.code.translation.with.syntactic.conversion","name":"cross-language code translation with syntactic conversion","description":"Transforms code snippets between 50+ programming languages by parsing source syntax into an intermediate representation, then generating idiomatic target-language code using large language models fine-tuned on language-specific patterns. The system maintains semantic equivalence while adapting to target language conventions, handling type systems, naming conventions, and framework-specific idioms through contextual awareness of both source and target language ecosystems.","intents":["I need to convert a Python utility function to JavaScript for a Node.js project without manually rewriting it","Our team is migrating from Java to Go and needs to translate core business logic while preserving behavior","I want to understand how a C++ algorithm would be implemented in Rust with proper memory safety patterns","I need to port legacy COBOL code to Python for modernization without losing functional correctness"],"best_for":["Developers maintaining polyglot codebases across multiple languages","Teams executing legacy system modernization with language migrations","Solo developers learning new languages by translating familiar code patterns","Organizations consolidating technical stacks and need bulk code conversion"],"limitations":["Struggles with framework-specific abstractions (e.g., Django ORM to Spring Data JPA) and may produce suboptimal patterns in target language","Cannot translate domain-specific languages (DSLs) or proprietary syntax without explicit training","Performance characteristics may not translate—Python list comprehensions converted to Java may lack equivalent efficiency","Requires sufficient context in snippet; very short fragments (<5 lines) may lose semantic intent","No support for translating build configuration files, package managers, or deployment-specific code"],"requires":["VS Code 1.80+ or JetBrains IDE (IntelliJ, PyCharm, WebStorm, etc.) 2023.1+","Active internet connection for API calls to LLM backend","Source code snippet in supported language (Python, JavaScript, Java, C++, Go, Rust, C#, PHP, Ruby, Swift, Kotlin, TypeScript, etc.)","Free tier: up to 50 conversions per day; paid tier for higher volume"],"input_types":["code snippet (plain text, 1-500 lines typical)","source language identifier (explicit or inferred)","target language identifier"],"output_types":["code snippet (plain text, formatted for target language)","confidence score or quality indicators (if available)","optional explanation of conversion choices"],"categories":["code-generation-editing","language-translation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"tool_refraction-ai__cap_1","uri":"capability://code.generation.editing.ide.integrated.code.snippet.capture.and.translation.workflow","name":"ide-integrated code snippet capture and translation workflow","description":"Provides native plugins for VS Code and JetBrains IDEs that intercept selected code, send it to the translation backend, and return converted code with inline preview or clipboard integration. The workflow eliminates context switching by embedding the translation UI directly in the editor, supporting keyboard shortcuts, context menus, and side-panel workflows for rapid iteration.","intents":["I want to translate a function without leaving my IDE or opening a web browser","I need to quickly compare how the same logic looks in two different languages side-by-side","I want to set up a keyboard shortcut to translate selected code to my target language instantly","I need to translate multiple code snippets in sequence without manual copy-pasting between tool and editor"],"best_for":["Professional developers who spend 6+ hours daily in IDEs and value workflow efficiency","Teams using standardized IDE stacks (JetBrains or VS Code) across the organization","Developers working on rapid prototyping or proof-of-concept migrations"],"limitations":["Plugin availability limited to VS Code and JetBrains ecosystem; no support for Vim, Emacs, Sublime Text, or other editors","Requires IDE restart after plugin installation; no hot-reload capability","Network latency (typically 2-5 seconds per translation) may feel slow for rapid iteration workflows","No offline mode; translation requires active internet connection to Refraction backend"],"requires":["VS Code 1.80+ with Extension Marketplace access, or JetBrains IDE 2023.1+ (IntelliJ IDEA, PyCharm, WebStorm, etc.)","Active internet connection","Refraction account (free or paid tier)","IDE plugin installed from official marketplace"],"input_types":["selected code text in editor","target language selection (dropdown or command palette)","optional: source language (auto-detected or user-specified)"],"output_types":["translated code snippet (displayed in preview panel or copied to clipboard)","optional: side-by-side diff view of source and target"],"categories":["code-generation-editing","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"tool_refraction-ai__cap_10","uri":"capability://code.generation.editing.testing.and.assertion.pattern.translation","name":"testing and assertion pattern translation","description":"Converts unit test code and assertions between testing frameworks (e.g., JUnit to pytest, NUnit to unittest, Jest to Vitest). Translates assertion syntax, test structure, mocking patterns, and test lifecycle hooks, maintaining test semantics while adapting to target framework conventions.","intents":["I need to convert JUnit tests to pytest while preserving test structure and assertions","I want to translate Jest test suites to Vitest with proper mocking and setup/teardown","I need to convert NUnit tests to unittest for Python projects","I want to translate assertion syntax and test organization between different testing frameworks"],"best_for":["Developers migrating test suites between languages or testing frameworks","Teams ensuring test coverage is maintained during language migrations","QA engineers translating test automation code between frameworks"],"limitations":["Testing framework conventions vary significantly; direct translation may not follow target framework best practices","Mocking and stubbing patterns differ between frameworks; complex mocks may not translate accurately","Test fixtures and setup/teardown patterns have different semantics across frameworks","Assertion libraries have different capabilities; some assertions may not have direct equivalents","Test organization and file structure conventions differ between languages and frameworks"],"requires":["Test code written in recognized testing framework (JUnit, pytest, Jest, NUnit, etc.)","Target testing framework specification","Optional: test configuration or setup files"],"input_types":["test code snippet or test file","source testing framework","target testing framework"],"output_types":["translated test code with target framework syntax","optional: test organization recommendations","optional: warnings about assertion or mocking changes"],"categories":["code-generation-editing","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"tool_refraction-ai__cap_11","uri":"capability://code.generation.editing.api.and.library.binding.translation.with.version.compatibility","name":"api and library binding translation with version compatibility","description":"Converts code that uses external APIs and libraries to equivalent APIs in target language, handling version-specific differences and API changes. Maps function signatures, parameter types, return types, and error handling across library versions, ensuring compatibility with target library versions while maintaining functional equivalence.","intents":["I need to convert code using the old NumPy API to the new NumPy 2.0 API","I want to translate code using an old version of a library to the current version with API changes","I need to convert code using one HTTP client library to another with different API","I want to translate database query code from one ORM version to another with API changes"],"best_for":["Developers updating code to work with new library versions","Teams migrating between different libraries with similar functionality","Developers translating code that depends on external libraries to different languages"],"limitations":["Requires knowledge of library APIs and version-specific changes; may be incomplete for niche libraries","Cannot handle libraries with no direct equivalent in target language","Behavioral changes between library versions may not be captured by API translation alone","Performance characteristics and optimization opportunities may differ between library versions","Custom library extensions or monkey-patching cannot be translated"],"requires":["Code using recognized external libraries or APIs","Source library and version specification","Target library and version specification","Optional: library documentation or API reference"],"input_types":["code snippet using external library","source library name and version","target library name and version"],"output_types":["translated code using target library API","optional: API mapping (e.g., old_function → new_function)","optional: migration guide or breaking changes"],"categories":["code-generation-editing","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"tool_refraction-ai__cap_2","uri":"capability://code.generation.editing.multi.language.syntax.pattern.recognition.and.idiomatic.conversion","name":"multi-language syntax pattern recognition and idiomatic conversion","description":"Analyzes source code to identify language-specific idioms, design patterns, and conventions (e.g., Python list comprehensions, Java streams, Rust ownership patterns), then applies target-language equivalents during translation. The system maintains semantic correctness while adapting to target language best practices, handling type inference, null safety patterns, and framework conventions through pattern matching and LLM-guided code generation.","intents":["I want to convert Python code to Java while using Java streams instead of loops for idiomatic Java style","I need to translate JavaScript async/await patterns to Rust futures and async/await syntax correctly","I want to convert nullable Python code to Rust with proper Option<T> and Result<T, E> types","I need to translate a functional programming pattern from Haskell to Scala while preserving functional idioms"],"best_for":["Developers learning new languages and wanting to understand idiomatic patterns in target language","Teams migrating codebases who want to adopt target language best practices, not just literal translations","Code reviewers who need to validate that translated code follows target language conventions"],"limitations":["Idiomatic conversion quality varies by language pair; well-established pairs (Python↔JavaScript) perform better than niche pairs (Haskell↔Rust)","May over-apply idioms in cases where literal translation is more appropriate for performance or compatibility","Cannot infer architectural patterns beyond single-function scope; multi-file refactoring requires manual coordination","Idiom detection relies on training data; emerging language features or recent framework updates may not be recognized"],"requires":["Source code with clear, recognizable patterns (not obfuscated or highly optimized code)","Target language version specification (e.g., Python 3.10+, Java 17+) for version-specific idioms","Refraction account with access to idiomatic conversion features (may be premium-tier)"],"input_types":["code snippet with identifiable patterns","source language","target language","optional: target language version or framework context"],"output_types":["idiomatic code snippet in target language","optional: explanation of idiom choices and why they were applied"],"categories":["code-generation-editing","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"tool_refraction-ai__cap_3","uri":"capability://automation.workflow.batch.code.translation.with.conversion.history.and.rollback","name":"batch code translation with conversion history and rollback","description":"Supports translating multiple code snippets in sequence or bulk, maintaining a conversion history with metadata (source language, target language, timestamp, user). Enables rollback to previous versions and comparison between conversion attempts, allowing developers to iterate on translation quality without manual version control. History is persisted per user account and accessible via IDE plugin or web dashboard.","intents":["I need to translate 50+ functions from Python to Go and want to track which ones I've already converted","I want to compare two different translation attempts for the same code to pick the better version","I need to revert a translation and try a different target language without losing the original","I want to see a log of all translations I've done this week for audit or documentation purposes"],"best_for":["Teams executing large-scale code migrations with dozens or hundreds of functions to translate","Developers iterating on translation quality and comparing multiple conversion strategies","Organizations needing audit trails of code translation activities for compliance or knowledge management"],"limitations":["History storage limited by account tier; free tier may have 30-day retention or 100-conversion limit","No automatic diff visualization between conversion attempts; comparison requires manual side-by-side review","Rollback restores previous translation but doesn't automatically update dependent code or imports","History is per-user; no team-level collaboration features for shared translation projects"],"requires":["Refraction account (free or paid)","Access to conversion history via IDE plugin or web dashboard","Optional: API key for programmatic access to history (if available)"],"input_types":["multiple code snippets (sequential or bulk upload)","source and target language specifications","optional: batch metadata (project name, migration phase)"],"output_types":["translated code snippets with metadata (timestamp, source/target language, conversion ID)","conversion history log (CSV, JSON, or web dashboard view)","optional: diff view between conversion attempts"],"categories":["automation-workflow","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"tool_refraction-ai__cap_4","uri":"capability://code.generation.editing.context.aware.code.translation.with.framework.and.library.detection","name":"context-aware code translation with framework and library detection","description":"Analyzes code snippets to detect framework usage (e.g., Django, Spring, React), library imports, and dependency patterns, then applies framework-specific translation rules during conversion. For example, translating Django ORM queries to SQLAlchemy or Spring Data, or React hooks to Vue composition API. The system maintains framework-specific semantics and API compatibility during translation.","intents":["I need to convert a Django view function to a FastAPI endpoint while preserving ORM patterns","I want to translate React component hooks to Vue 3 composition API equivalents","I need to convert a Spring Boot service class to a FastAPI service with equivalent dependency injection","I want to translate a Flask route handler to Express.js with proper middleware and error handling"],"best_for":["Developers migrating between frameworks within the same language (Django→FastAPI, React→Vue)","Teams consolidating framework choices across projects and needing bulk framework-specific translations","Architects evaluating framework migrations and needing code samples in target framework"],"limitations":["Framework detection requires explicit imports or recognizable patterns; implicit or dynamic framework usage may not be detected","Framework-specific translation quality varies; well-established frameworks (Django, Spring, React) have better support than niche frameworks","Cannot translate custom framework extensions or proprietary abstractions built on top of frameworks","May produce suboptimal patterns if framework versions differ significantly (e.g., Django 2.x to 4.x API changes)","Dependency management (requirements.txt, package.json, pom.xml) is not automatically updated; manual dependency mapping required"],"requires":["Code with explicit framework imports or recognizable framework patterns","Framework version specification (e.g., Django 4.2, React 18, Spring Boot 3.0) for version-specific API translation","Refraction account with framework-specific translation features (may be premium-tier)"],"input_types":["code snippet with framework imports or usage","source framework and version","target framework and version","optional: additional context (middleware, decorators, configuration)"],"output_types":["translated code snippet with target framework APIs","optional: list of required dependencies for target framework","optional: migration guide or notes on framework-specific changes"],"categories":["code-generation-editing","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"tool_refraction-ai__cap_5","uri":"capability://code.generation.editing.type.system.and.null.safety.pattern.conversion","name":"type system and null safety pattern conversion","description":"Translates type annotations and null-safety patterns between languages with different type systems (e.g., Python's optional types to Rust's Option<T>, Java's nullable references to Kotlin's nullable types, TypeScript's union types to Rust's enums). Handles type inference, generic types, and null-coalescing patterns, ensuring type correctness in target language while maintaining semantic equivalence.","intents":["I need to convert Python code with Optional[T] types to Rust with proper Option<T> and Result<T, E> handling","I want to translate Java code with @Nullable annotations to Kotlin with nullable type syntax","I need to convert TypeScript union types and type guards to Rust pattern matching","I want to translate Python duck-typing code to Go with explicit interface definitions"],"best_for":["Developers migrating from dynamically-typed to statically-typed languages (Python→Rust, JavaScript→Go)","Teams adopting stricter type safety and null-safety practices during modernization","Developers learning type systems by seeing how patterns translate between languages"],"limitations":["Type inference may be incomplete if source code lacks type annotations; requires explicit type hints for accurate conversion","Generic type constraints and variance (covariance, contravariance) may not translate directly between languages","Null-safety patterns vary significantly; some languages (Rust) enforce at compile-time, others (Python) rely on conventions","Cannot infer types from runtime behavior; static analysis only","Complex type hierarchies or circular type dependencies may produce incorrect translations"],"requires":["Source code with explicit or inferable type information","Target language with explicit type system (not suitable for untyped languages like Lua or Scheme)","Optional: type annotations or hints in source code for improved accuracy"],"input_types":["code snippet with type annotations or type-related patterns","source language with type system","target language with type system"],"output_types":["translated code with target language type annotations","optional: type conversion mapping (e.g., Optional[T] → Option<T>)","optional: warnings about type safety changes or potential issues"],"categories":["code-generation-editing","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"tool_refraction-ai__cap_6","uri":"capability://code.generation.editing.performance.aware.code.translation.with.optimization.hints","name":"performance-aware code translation with optimization hints","description":"Identifies performance-critical patterns in source code (loops, recursion, memory allocation) and applies target-language optimizations during translation (e.g., list comprehensions in Python to streams in Java, recursive functions to iterative in C++). Provides optional hints or warnings about performance implications of the translation, such as algorithmic complexity changes or memory overhead.","intents":["I need to translate a Python loop to Java while using streams for better performance","I want to convert a recursive algorithm to an iterative version in C++ to avoid stack overflow","I need to translate memory-intensive Python code to Rust with proper ownership and borrowing for efficiency","I want to understand how performance characteristics change when translating from Python to Go"],"best_for":["Developers optimizing code during language migrations where performance is critical","Teams translating performance-sensitive code (algorithms, data processing, real-time systems)","Architects evaluating language choices based on performance characteristics of translated code"],"limitations":["Performance optimization is heuristic-based; actual performance depends on runtime, compiler, and hardware","Cannot optimize across function boundaries without full codebase context","Optimization hints may be conservative or overly aggressive depending on target language and use case","No profiling or benchmarking; recommendations are based on static analysis only","Language-specific optimizations (JIT compilation, garbage collection) cannot be predicted statically"],"requires":["Code with identifiable performance-critical patterns (loops, recursion, memory allocation)","Target language with different performance characteristics (e.g., Python→C++ for speed, JavaScript→Rust for memory efficiency)","Optional: performance requirements or constraints for context"],"input_types":["code snippet with performance-critical patterns","source language","target language","optional: performance constraints or optimization goals"],"output_types":["translated code with performance optimizations applied","optional: performance hints or warnings (e.g., 'Java streams may be slower than loops for small datasets')","optional: algorithmic complexity analysis (Big O notation)"],"categories":["code-generation-editing","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"tool_refraction-ai__cap_7","uri":"capability://code.generation.editing.error.handling.and.exception.pattern.translation","name":"error handling and exception pattern translation","description":"Converts error handling patterns between languages with different exception models (e.g., try-catch-finally in Java to Result<T, E> in Rust, Python exceptions to Go error returns, JavaScript promises to async/await). Maintains error semantics while adapting to target language error handling conventions, including custom exception types, error propagation, and recovery strategies.","intents":["I need to convert Java try-catch-finally blocks to Rust Result<T, E> with proper error propagation","I want to translate Python exception handling to Go error returns with proper error checking","I need to convert JavaScript promise chains to async/await with proper error handling","I want to translate custom exception types from one language to another while preserving error semantics"],"best_for":["Developers migrating code between languages with fundamentally different error models (exceptions vs. error returns)","Teams ensuring robust error handling during language migrations","Architects evaluating error handling trade-offs between languages"],"limitations":["Error semantics may not translate directly; some languages (Rust) enforce error handling at compile-time, others (Python) rely on conventions","Custom exception hierarchies may not have direct equivalents in target language","Error recovery strategies may differ significantly between languages (e.g., panic vs. exception vs. error return)","Cannot infer error types from runtime behavior; static analysis only","Nested error handling or complex error propagation chains may produce verbose or incorrect translations"],"requires":["Code with explicit error handling (try-catch, error returns, promise chains)","Target language with defined error handling model","Optional: custom exception or error type definitions"],"input_types":["code snippet with error handling patterns","source language error model","target language error model"],"output_types":["translated code with target language error handling","optional: error type mapping (e.g., IOException → io::Error)","optional: warnings about error handling changes or potential issues"],"categories":["code-generation-editing","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"tool_refraction-ai__cap_8","uri":"capability://code.generation.editing.concurrent.and.asynchronous.pattern.translation","name":"concurrent and asynchronous pattern translation","description":"Converts concurrency and asynchronous patterns between languages with different concurrency models (e.g., Python asyncio to JavaScript async/await, Java threads to Go goroutines, Rust async/await to Kotlin coroutines). Handles synchronization primitives, channel communication, and concurrency abstractions, ensuring thread-safety and deadlock-free translations where applicable.","intents":["I need to convert Python asyncio code to JavaScript async/await for a Node.js project","I want to translate Java thread-based concurrency to Go goroutines with proper channel communication","I need to convert Rust async/await to Kotlin coroutines while maintaining concurrency semantics","I want to translate callback-based asynchronous code to promise-based or async/await patterns"],"best_for":["Developers migrating concurrent code between languages with different concurrency models","Teams ensuring thread-safety and deadlock-free code during language migrations","Architects evaluating concurrency trade-offs between languages"],"limitations":["Concurrency models vary significantly; some languages (Go) have lightweight goroutines, others (Java) use heavier threads","Synchronization primitives may not translate directly (mutexes, semaphores, channels)","Deadlock detection and prevention are not guaranteed; static analysis has limitations","Performance characteristics of concurrency differ significantly between languages (e.g., goroutines vs. threads)","Cannot infer concurrency requirements from single-function scope; multi-file context needed for accurate translation"],"requires":["Code with explicit concurrency or asynchronous patterns (threads, async/await, callbacks, channels)","Target language with defined concurrency model","Optional: concurrency constraints or requirements"],"input_types":["code snippet with concurrency or asynchronous patterns","source language concurrency model","target language concurrency model"],"output_types":["translated code with target language concurrency patterns","optional: concurrency model mapping (e.g., threads → goroutines)","optional: warnings about concurrency changes or potential deadlock risks"],"categories":["code-generation-editing","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"tool_refraction-ai__cap_9","uri":"capability://code.generation.editing.memory.management.and.resource.cleanup.pattern.translation","name":"memory management and resource cleanup pattern translation","description":"Converts memory management patterns between languages with different memory models (e.g., manual memory management in C++ to garbage collection in Java, Rust ownership to Python reference counting, RAII to try-with-resources). Handles resource cleanup, lifetime management, and deallocation patterns, ensuring proper resource management in target language.","intents":["I need to convert C++ RAII patterns to Java try-with-resources for proper resource cleanup","I want to translate manual memory management in C to Rust with proper ownership and borrowing","I need to convert Python reference counting patterns to Rust lifetime annotations","I want to translate garbage-collected code to languages with manual memory management"],"best_for":["Developers migrating code between languages with different memory models (C++ to Java, C to Rust)","Teams ensuring proper resource management and preventing memory leaks during migrations","Architects evaluating memory safety trade-offs between languages"],"limitations":["Memory models vary significantly; some languages (Rust) enforce memory safety at compile-time, others (Python) rely on garbage collection","Lifetime annotations and ownership rules may not translate directly between languages","Resource cleanup patterns (destructors, finalizers, defer statements) have different semantics","Cannot guarantee memory safety without full codebase context and type information","Performance implications of memory management differ significantly (GC pauses, allocation overhead)"],"requires":["Code with explicit memory management or resource cleanup patterns","Target language with defined memory model","Optional: resource types and lifetime requirements"],"input_types":["code snippet with memory management or resource cleanup patterns","source language memory model","target language memory model"],"output_types":["translated code with target language memory management","optional: memory model mapping (e.g., RAII → try-with-resources)","optional: warnings about memory safety changes or potential issues"],"categories":["code-generation-editing","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":46,"verified":false,"data_access_risk":"low","permissions":["VS Code 1.80+ or JetBrains IDE (IntelliJ, PyCharm, WebStorm, etc.) 2023.1+","Active internet connection for API calls to LLM backend","Source code snippet in supported language (Python, JavaScript, Java, C++, Go, Rust, C#, PHP, Ruby, Swift, Kotlin, TypeScript, etc.)","Free tier: up to 50 conversions per day; paid tier for higher volume","VS Code 1.80+ with Extension Marketplace access, or JetBrains IDE 2023.1+ (IntelliJ IDEA, PyCharm, WebStorm, etc.)","Active internet connection","Refraction account (free or paid tier)","IDE plugin installed from official marketplace","Test code written in recognized testing framework (JUnit, pytest, Jest, NUnit, etc.)","Target testing framework specification"],"failure_modes":["Struggles with framework-specific abstractions (e.g., Django ORM to Spring Data JPA) and may produce suboptimal patterns in target language","Cannot translate domain-specific languages (DSLs) or proprietary syntax without explicit training","Performance characteristics may not translate—Python list comprehensions converted to Java may lack equivalent efficiency","Requires sufficient context in snippet; very short fragments (<5 lines) may lose semantic intent","No support for translating build configuration files, package managers, or deployment-specific code","Plugin availability limited to VS Code and JetBrains ecosystem; no support for Vim, Emacs, Sublime Text, or other editors","Requires IDE restart after plugin installation; no hot-reload capability","Network latency (typically 2-5 seconds per translation) may feel slow for rapid iteration workflows","No offline mode; translation requires active internet connection to Refraction backend","Testing framework conventions vary significantly; direct translation may not follow target framework best practices","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.31666666666666665,"quality":0.72,"ecosystem":0.2,"match_graph":0.25,"freshness":0.9,"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:33.094Z","last_scraped_at":"2026-04-05T13:23:42.560Z","last_commit":null},"community":{"stars":null,"forks":null,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=refraction-ai","compare_url":"https://unfragile.ai/compare?artifact=refraction-ai"}},"signature":"Vw3Rydo+0KtRAbbcg3qR7QoXoOVZcDIpXLJV2OvrXS6mXjzW4r7c7Pb7L06565CKnyp/wuHE+CMLHImNbhiXCA==","signedAt":"2026-06-17T18:16:24.764Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/refraction-ai","artifact":"https://unfragile.ai/refraction-ai","verify":"https://unfragile.ai/api/v1/verify?slug=refraction-ai","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"}}