{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"ollama-qwq","slug":"qwq","name":"QWQ (32B)","type":"model","url":"https://ollama.com/library/qwq","page_url":"https://unfragile.ai/qwq","categories":["text-writing"],"tags":["ollama","open-source","alibaba"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"ollama-qwq__cap_0","uri":"capability://planning.reasoning.chain.of.thought.reasoning.with.reinforcement.learning.optimization","name":"chain-of-thought reasoning with reinforcement learning optimization","description":"QWQ implements scaled reinforcement learning fine-tuning on top of a pretrained transformer foundation to enable explicit reasoning and chain-of-thought generation. The model learns to decompose complex problems into intermediate reasoning steps before producing final answers, with RL training optimizing for correctness on hard reasoning tasks. This differs from standard instruction-tuned models by explicitly training the reasoning process itself rather than just the output.","intents":["I need a model that can solve multi-step math problems by showing its work","I want to understand how the model arrived at its answer, not just get a result","I need better performance on logic puzzles and constraint satisfaction problems","I'm building an agent that needs to decompose complex user requests into sub-tasks"],"best_for":["developers building reasoning-heavy AI agents for technical domains","teams solving mathematical or logical problem-solving tasks","researchers evaluating reasoning capabilities in open-source models","solo developers prototyping LLM-based tutoring or explanation systems"],"limitations":["Reasoning overhead increases inference latency — no published metrics on token-to-latency scaling for reasoning steps","40K token context window limits reasoning depth on very long problems","Reasoning quality on non-English languages undocumented — training emphasis appears English-centric","No control over reasoning verbosity — cannot suppress intermediate steps for latency-sensitive applications"],"requires":["Ollama runtime (any version with QWQ support)","24GB+ VRAM for local inference (estimated from 20GB model size × 1.2x overhead rule)","Text-only input capability (no vision preprocessing needed)"],"input_types":["text prompts","multi-turn chat messages with role-based formatting"],"output_types":["text with embedded reasoning steps","structured explanations with intermediate logic"],"categories":["planning-reasoning","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"ollama-qwq__cap_1","uri":"capability://planning.reasoning.mathematical.problem.solving.with.symbolic.reasoning","name":"mathematical problem solving with symbolic reasoning","description":"QWQ demonstrates enhanced capability on mathematical reasoning tasks through its RL-tuned reasoning process, enabling it to handle multi-step algebra, geometry, and calculus problems. The model generates symbolic intermediate steps and validates logical consistency across reasoning chains. Performance is claimed to be significantly enhanced on 'hard problems' compared to base language models, though specific benchmark scores are not published.","intents":["I need to solve SAT/ACT-style math problems programmatically","I want to generate step-by-step solutions for educational content","I need a model that can catch its own mathematical errors during reasoning","I'm building a homework helper that explains solutions, not just provides answers"],"best_for":["EdTech platforms building AI tutoring systems","researchers benchmarking mathematical reasoning in open models","developers creating STEM learning assistants","teams automating technical documentation with mathematical examples"],"limitations":["No published benchmark scores — claims of 'significantly enhanced performance' lack quantitative validation","Symbolic reasoning quality on advanced calculus/abstract algebra undocumented","No explicit support for LaTeX input/output formatting — requires text-based mathematical notation","Reasoning may fail silently on edge cases without explicit error signaling"],"requires":["Ollama runtime with QWQ model loaded","24GB+ VRAM for inference","Prompts structured to encourage step-by-step reasoning (e.g., 'show your work')"],"input_types":["text-based mathematical problems","multi-line equations in plain text or LaTeX"],"output_types":["step-by-step solutions in text format","intermediate symbolic representations","final numerical or algebraic answers"],"categories":["planning-reasoning","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"ollama-qwq__cap_10","uri":"capability://tool.use.integration.python.and.javascript.sdk.support.for.programmatic.access","name":"python and javascript sdk support for programmatic access","description":"QWQ is accessible via Ollama's Python and JavaScript SDKs, providing language-native bindings for model inference without direct HTTP calls. The SDKs handle serialization, streaming, and error handling, exposing a simple API for chat completions and streaming responses. This enables integration into Python data science workflows and JavaScript web applications.","intents":["I want to use QWQ in my Python data science or ML pipeline","I need to integrate QWQ into a Node.js or browser-based application","I want type-safe, language-native bindings instead of raw HTTP calls","I'm building a Python agent framework that needs model abstraction"],"best_for":["Python developers using Jupyter, FastAPI, or Django","JavaScript/Node.js developers building web applications","teams building language-specific agent frameworks","data scientists prototyping with QWQ in notebooks"],"limitations":["SDK feature parity with HTTP API not guaranteed — some advanced features may only be available via REST","Python SDK requires Python 3.8+ — older projects may need upgrades","JavaScript SDK requires Node.js 14+ or modern browser with fetch support","No async/await support in older SDK versions — may require callback-based patterns","Limited documentation on SDK-specific error handling and edge cases"],"requires":["Python 3.8+ (for Python SDK) or Node.js 14+ (for JavaScript SDK)","Ollama runtime running locally or cloud instance","SDK installation: `pip install ollama` or `npm install ollama`","Import and instantiate client: `from ollama import Client` or `import { Ollama } from 'ollama'`"],"input_types":["Python: dict or message objects","JavaScript: object literals or typed message objects"],"output_types":["Python: dict responses or async generators for streaming","JavaScript: Promise-based responses or async iterables for streaming"],"categories":["tool-use-integration","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"ollama-qwq__cap_11","uri":"capability://tool.use.integration.streaming.response.generation.with.server.sent.events","name":"streaming response generation with server-sent events","description":"QWQ supports streaming responses via Server-Sent Events (SSE), enabling real-time token-by-token output as the model generates text. The `/api/chat` endpoint with `stream: true` returns newline-delimited JSON events, each containing partial response content. This allows applications to display output incrementally without waiting for full completion, improving perceived latency.","intents":["I want to display model output in real-time as it's generated","I need to reduce perceived latency by showing tokens as they arrive","I'm building a chat interface that needs live streaming responses","I want to allow users to interrupt generation mid-stream"],"best_for":["web application developers building chat interfaces","teams creating real-time AI applications","developers building streaming-aware agent systems","applications where user experience depends on immediate feedback"],"limitations":["Streaming adds complexity to error handling — errors mid-stream may not be catchable","Client must handle partial JSON objects and reassemble responses","No built-in support for interrupting generation — requires separate mechanism","Streaming latency depends on network conditions — not suitable for high-latency connections","Token-by-token streaming may expose reasoning steps that users don't want to see"],"requires":["HTTP client supporting Server-Sent Events (fetch API, axios, etc.)","JSON parsing for newline-delimited events","Ollama runtime with streaming support","Request parameter: `stream: true` in chat completion request"],"input_types":["standard chat message arrays with stream: true flag"],"output_types":["Server-Sent Events stream of newline-delimited JSON","each event contains partial response content and metadata"],"categories":["tool-use-integration","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"ollama-qwq__cap_12","uri":"capability://text.generation.language.model.parameter.tuning.for.inference.behavior","name":"model parameter tuning for inference behavior","description":"QWQ inference supports adjustable parameters including temperature, top_p (nucleus sampling), top_k (top-k sampling), and num_predict (max output tokens). These parameters control randomness, diversity, and output length without retraining. Temperature scales logits before sampling; top_p and top_k filter the sampling distribution; num_predict caps generation length. This enables fine-tuning model behavior for different use cases.","intents":["I need to control the randomness/creativity of model outputs","I want to limit response length to fit UI constraints or token budgets","I need deterministic outputs for testing or reproducibility","I want to balance diversity and coherence for different tasks"],"best_for":["developers tuning model behavior for specific applications","teams optimizing inference cost by limiting output length","researchers studying parameter sensitivity in reasoning models","applications requiring deterministic or creative outputs"],"limitations":["Parameter effects on reasoning quality undocumented — no guidance on optimal settings for reasoning tasks","Low temperature may suppress reasoning diversity — model may take shortcuts","High temperature may degrade reasoning coherence — model may generate invalid logic","num_predict limits reasoning steps — may truncate reasoning before completion","No parameter validation — invalid values may cause silent failures or unexpected behavior"],"requires":["Ollama runtime","Understanding of sampling parameters (temperature, top_p, top_k)","Request format supporting optional parameters in chat completion API"],"input_types":["chat messages with optional parameters: temperature (0-2), top_p (0-1), top_k (0-100), num_predict (1-40000)"],"output_types":["text responses with adjusted randomness/length","same JSON format as standard inference"],"categories":["text-generation-language","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"ollama-qwq__cap_2","uri":"capability://text.generation.language.multi.turn.conversational.reasoning.with.context.preservation","name":"multi-turn conversational reasoning with context preservation","description":"QWQ supports standard chat completion API with role-based message formatting (system, user, assistant), enabling multi-turn conversations where reasoning context persists across exchanges. The model maintains conversation history within the 40K token window and can reference previous reasoning steps when answering follow-up questions. Integration via Ollama's REST API at `/api/chat` endpoint provides standard OpenAI-compatible message formatting.","intents":["I need a conversational AI that remembers its reasoning from previous turns","I want to ask follow-up questions that build on earlier explanations","I'm building a chatbot that can refine answers based on user feedback","I need to integrate reasoning capabilities into existing chat applications"],"best_for":["developers building conversational agents with reasoning capabilities","teams migrating from cloud-based chat APIs to local inference","customer support teams needing explainable AI responses","researchers studying multi-turn reasoning in open models"],"limitations":["40K token context window limits conversation length before context pruning becomes necessary","No built-in conversation memory or persistence — requires external database for long-term chat history","Reasoning overhead compounds across turns — later turns may have slower response times due to accumulated context","No explicit support for conversation branching or alternative reasoning paths"],"requires":["Ollama runtime (any recent version)","HTTP client or SDK to call `/api/chat` endpoint","Message formatting as JSON array with role/content fields","24GB+ VRAM for inference"],"input_types":["JSON message arrays with role (system/user/assistant) and content","text prompts in standard chat format"],"output_types":["text responses with embedded reasoning","structured chat completion objects with token counts"],"categories":["text-generation-language","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"ollama-qwq__cap_3","uri":"capability://tool.use.integration.local.inference.with.zero.latency.api.access","name":"local inference with zero-latency api access","description":"QWQ runs entirely on local hardware via Ollama, exposing a REST API at `http://localhost:11434/api/chat` for inference without network round-trips. The model is deployed as a 20GB quantized artifact (format unspecified, likely GGUF) that loads into VRAM and serves requests with sub-second time-to-first-token for typical hardware. This eliminates cloud API dependency, rate limiting, and data transmission overhead.","intents":["I need to run reasoning models without sending data to external APIs","I want to avoid API rate limits and per-token pricing for reasoning workloads","I need sub-second latency for real-time reasoning in my application","I'm building an offline-capable AI system that works without internet"],"best_for":["enterprises with data privacy requirements prohibiting cloud inference","developers building latency-sensitive reasoning applications","teams operating in air-gapped or low-bandwidth environments","solo developers prototyping without cloud infrastructure costs"],"limitations":["Requires 24GB+ VRAM — not feasible on consumer laptops or edge devices without quantization","Inference latency scales with reasoning depth — no published benchmarks on time-to-completion for complex problems","Single-machine deployment — no built-in distributed inference or load balancing","Ollama runtime dependency — requires separate installation and management","No GPU acceleration on CPU-only systems — inference becomes prohibitively slow"],"requires":["Ollama runtime installed and running","24GB+ VRAM (GPU recommended: NVIDIA with CUDA, Apple Silicon, or AMD with ROCm)","HTTP client library for REST API calls","Linux, macOS, or Windows with Ollama support"],"input_types":["HTTP POST requests with JSON payload","chat message arrays"],"output_types":["HTTP JSON responses with text content and token counts","streaming responses via Server-Sent Events (SSE)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"ollama-qwq__cap_4","uri":"capability://tool.use.integration.openai.compatible.chat.api.with.standard.message.formatting","name":"openai-compatible chat api with standard message formatting","description":"QWQ exposes its inference through Ollama's OpenAI-compatible `/api/chat` endpoint, accepting standard message arrays with role/content fields and returning chat completion objects. This compatibility layer allows existing applications built for OpenAI's API to swap in QWQ with minimal code changes. The API supports streaming responses via Server-Sent Events for real-time output.","intents":["I want to migrate from OpenAI API to local inference without rewriting my chat code","I need to support multiple model backends (OpenAI, Anthropic, local) with a single integration","I'm building a model-agnostic application that can switch between cloud and local models","I want to use existing LangChain, LlamaIndex, or other OpenAI-compatible libraries with QWQ"],"best_for":["developers with existing OpenAI API integrations seeking cost reduction","teams building multi-model applications with provider abstraction","frameworks and libraries implementing OpenAI-compatible interfaces","enterprises migrating from cloud to on-premise inference"],"limitations":["API compatibility is surface-level — advanced OpenAI features (function calling, vision, embeddings) may not be fully supported","Response format matches OpenAI but performance characteristics differ — reasoning latency not comparable to GPT-4","No authentication or rate limiting built-in — requires external gateway for production security","Streaming implementation may differ from OpenAI in edge cases (e.g., error handling mid-stream)"],"requires":["Ollama runtime running on localhost:11434","HTTP client supporting JSON and optional streaming","Code expecting OpenAI message format (role/content arrays)","Optional: OpenAI Python SDK or compatible library"],"input_types":["JSON message arrays with role (system/user/assistant) and content","optional parameters: temperature, top_p, top_k, num_predict"],"output_types":["JSON chat completion objects with choices, usage, model metadata","streaming: newline-delimited JSON events via SSE"],"categories":["tool-use-integration","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"ollama-qwq__cap_5","uri":"capability://planning.reasoning.logic.based.reasoning.and.constraint.satisfaction","name":"logic-based reasoning and constraint satisfaction","description":"QWQ's RL-trained reasoning process enables it to handle logic puzzles, constraint satisfaction problems, and formal reasoning tasks by generating explicit logical steps and validating consistency. The model learns to identify contradictions, apply logical rules, and explore solution spaces through its reasoning chain. This capability extends beyond mathematical reasoning to include symbolic logic, set theory, and rule-based inference.","intents":["I need to solve logic puzzles and constraint satisfaction problems programmatically","I want to verify logical consistency in complex rule sets or specifications","I'm building a system that reasons about dependencies and constraints","I need to generate formal proofs or logical arguments"],"best_for":["developers building constraint solvers or optimization systems","teams automating formal verification or specification checking","researchers evaluating logical reasoning in language models","educational platforms teaching logic and discrete mathematics"],"limitations":["No explicit formal logic syntax support — requires natural language or pseudo-code representation of logical statements","Reasoning quality on complex multi-constraint problems undocumented — no benchmarks vs. dedicated SAT/SMT solvers","Cannot guarantee correctness of logical proofs — model may generate plausible-sounding but invalid reasoning","No integration with formal verification tools (Z3, Coq, Lean) — output is text, not machine-verifiable"],"requires":["Ollama runtime with QWQ loaded","24GB+ VRAM","Prompts structured to encourage explicit logical reasoning (e.g., 'list all constraints', 'check for contradictions')"],"input_types":["natural language logic puzzles","constraint descriptions in text form","rule sets and logical statements"],"output_types":["step-by-step logical reasoning","identified constraints and dependencies","solutions with logical justification"],"categories":["planning-reasoning","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"ollama-qwq__cap_6","uri":"capability://planning.reasoning.instruction.following.with.reasoning.justification","name":"instruction-following with reasoning justification","description":"QWQ follows complex multi-step instructions by decomposing them into sub-tasks and generating reasoning for each step. The model can handle instructions with conditional logic, nested requirements, and ambiguous specifications by explicitly reasoning through interpretation and execution. This differs from standard instruction-tuned models by showing its reasoning process alongside task completion.","intents":["I need an AI that can follow complex, multi-part instructions and explain its interpretation","I want to verify that the model understood my instructions correctly before it executes them","I'm building a system where users need to understand why the AI made certain decisions","I need to handle ambiguous or conflicting instructions by having the model reason through them"],"best_for":["developers building AI assistants for knowledge workers","teams creating explainable AI systems for regulated industries","educational applications where understanding process matters as much as output","customer service systems that need to justify their actions"],"limitations":["Reasoning overhead increases latency — not suitable for real-time instruction execution","No explicit instruction validation — model may misinterpret complex requirements without explicit confirmation","Reasoning verbosity can make responses lengthy — no built-in summarization of justification","Ambiguous instructions may result in arbitrary reasoning paths — no mechanism to explore multiple interpretations"],"requires":["Ollama runtime with QWQ","24GB+ VRAM","Clear, well-structured instructions (ambiguity increases reasoning overhead)"],"input_types":["natural language instructions","multi-step task descriptions","conditional or branching instructions"],"output_types":["task completion with reasoning steps","structured explanations of interpretation","justification for decisions made"],"categories":["planning-reasoning","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"ollama-qwq__cap_7","uri":"capability://text.generation.language.context.aware.text.generation.with.40k.token.window","name":"context-aware text generation with 40k token window","description":"QWQ generates text with awareness of up to 40,000 tokens of context, enabling it to maintain coherence across long documents, multi-turn conversations, or large code files. The model uses standard transformer attention mechanisms to weight relevant context and generate continuations that respect long-range dependencies. This context window is fixed and not dynamically expandable, requiring explicit context management for longer documents.","intents":["I need to generate text that maintains coherence across long documents","I want to summarize or continue large code files without losing context","I'm building a system that needs to reference multiple previous turns in a conversation","I need to generate responses that respect constraints or context from earlier in a document"],"best_for":["developers building document-aware AI systems","teams creating long-form content generation tools","researchers evaluating context window utilization in reasoning models","applications requiring multi-document reasoning"],"limitations":["40K token window is fixed — cannot be extended without model retraining","Context beyond 40K tokens is automatically truncated — no sliding window or summarization built-in","Attention complexity scales quadratically with context length — inference latency increases significantly with longer contexts","No explicit mechanism to prioritize recent vs. early context — standard transformer attention may lose important early information"],"requires":["Ollama runtime with QWQ","24GB+ VRAM (larger context increases memory usage)","Token counting to manage context within 40K limit","External context management for documents exceeding 40K tokens"],"input_types":["text prompts up to 40K tokens","multi-turn conversations within 40K token budget","code files or documents up to 40K tokens"],"output_types":["text continuations","summaries","responses respecting long-range context"],"categories":["text-generation-language","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"ollama-qwq__cap_8","uri":"capability://tool.use.integration.multi.provider.integration.via.ollama.ecosystem","name":"multi-provider integration via ollama ecosystem","description":"QWQ integrates with Ollama's ecosystem of supported applications and frameworks including Claude Code, Codex, OpenCode, OpenClaw, and Hermes Agent. These integrations expose QWQ's reasoning capabilities through specialized interfaces designed for code generation, agent orchestration, and domain-specific tasks. Ollama acts as a model abstraction layer, allowing these tools to swap models without code changes.","intents":["I want to use QWQ with existing Ollama-integrated tools without custom integration work","I need to build agents that can leverage QWQ's reasoning for complex decision-making","I'm evaluating QWQ against other models in my existing Ollama-based workflow","I want to combine QWQ with specialized tools like code generation or semantic search"],"best_for":["developers already using Ollama ecosystem tools","teams building multi-model agent systems","researchers comparing reasoning models across integrated frameworks","organizations standardizing on Ollama for model management"],"limitations":["Integration quality varies by tool — some may not fully leverage QWQ's reasoning capabilities","No official documentation on QWQ-specific optimizations for each integrated tool","Tool-specific limitations may constrain QWQ's capabilities (e.g., code generation tools may not expose reasoning steps)","Ecosystem is Ollama-dependent — switching model servers requires re-integration"],"requires":["Ollama runtime running","QWQ model loaded in Ollama","Supported integration tool installed (Claude Code, Codex, OpenCode, OpenClaw, or Hermes Agent)","Configuration pointing integration to local Ollama instance"],"input_types":["tool-specific input formats (varies by integration)","standard chat messages for generic integrations"],"output_types":["tool-specific output formats","reasoning traces where supported"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"ollama-qwq__cap_9","uri":"capability://tool.use.integration.cloud.based.inference.via.ollama.pro.max.tiers","name":"cloud-based inference via ollama pro/max tiers","description":"QWQ is available for cloud-based inference through Ollama's Pro ($20/month) and Max ($100/month) subscription tiers, providing managed hosting without local hardware requirements. Cloud inference routes requests to Ollama's infrastructure, handling model loading, scaling, and availability. This option trades local control for convenience and eliminates hardware procurement.","intents":["I want to use QWQ without managing local hardware or Ollama installation","I need scalable inference that can handle variable load without provisioning","I'm prototyping with QWQ and don't want to commit to hardware investment","I need QWQ available from multiple machines without replicating the model"],"best_for":["teams prototyping reasoning applications without infrastructure","solo developers avoiding hardware costs","organizations with variable inference load","users in regions where local GPU hardware is expensive"],"limitations":["Cloud inference reintroduces network latency — not suitable for real-time applications","Subscription cost ($20-100/month) may exceed local hardware amortization for high-volume usage","Data privacy concerns — reasoning inputs/outputs transmitted to Ollama's servers","No SLA or uptime guarantees documented — cloud availability not specified","Rate limiting likely enforced — throughput constraints not published"],"requires":["Ollama account with Pro or Max subscription","Internet connectivity","API key for authentication","HTTP client for API calls"],"input_types":["standard chat messages via API","same format as local inference"],"output_types":["same JSON chat completion format as local inference","streaming responses via SSE"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":24,"verified":false,"data_access_risk":"high","permissions":["Ollama runtime (any version with QWQ support)","24GB+ VRAM for local inference (estimated from 20GB model size × 1.2x overhead rule)","Text-only input capability (no vision preprocessing needed)","Ollama runtime with QWQ model loaded","24GB+ VRAM for inference","Prompts structured to encourage step-by-step reasoning (e.g., 'show your work')","Python 3.8+ (for Python SDK) or Node.js 14+ (for JavaScript SDK)","Ollama runtime running locally or cloud instance","SDK installation: `pip install ollama` or `npm install ollama`","Import and instantiate client: `from ollama import Client` or `import { Ollama } from 'ollama'`"],"failure_modes":["Reasoning overhead increases inference latency — no published metrics on token-to-latency scaling for reasoning steps","40K token context window limits reasoning depth on very long problems","Reasoning quality on non-English languages undocumented — training emphasis appears English-centric","No control over reasoning verbosity — cannot suppress intermediate steps for latency-sensitive applications","No published benchmark scores — claims of 'significantly enhanced performance' lack quantitative validation","Symbolic reasoning quality on advanced calculus/abstract algebra undocumented","No explicit support for LaTeX input/output formatting — requires text-based mathematical notation","Reasoning may fail silently on edge cases without explicit error signaling","SDK feature parity with HTTP API not guaranteed — some advanced features may only be available via REST","Python SDK requires Python 3.8+ — older projects may need upgrades","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.05,"quality":0.35,"ecosystem":0.38999999999999996,"match_graph":0.25,"freshness":0.75,"weights":{"adoption":0.35,"quality":0.2,"ecosystem":0.1,"match_graph":0.3,"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:24.483Z","last_scraped_at":"2026-05-03T15:20:48.403Z","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=qwq","compare_url":"https://unfragile.ai/compare?artifact=qwq"}},"signature":"9ZCJSFm8yLsNVYjk8I5cPuNh0vv4kSQJbtkcqHgkrKq1lXj9932TQp3WgosmdG4ZCIivn2yb08NPbHBXLuQYAg==","signedAt":"2026-06-21T20:55:45.681Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/qwq","artifact":"https://unfragile.ai/qwq","verify":"https://unfragile.ai/api/v1/verify?slug=qwq","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"}}