{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"awesome-demogpt","slug":"demogpt","name":"DemoGPT","type":"repo","url":"https://github.com/melih-unsal/DemoGPT","page_url":"https://unfragile.ai/demogpt","categories":["app-builders"],"tags":[],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"awesome-demogpt__cap_0","uri":"capability://code.generation.editing.natural.language.to.streamlit.application.transpilation","name":"natural-language-to-streamlit-application-transpilation","description":"Transforms unstructured natural language instructions into executable Streamlit applications through a four-stage plan-based pipeline: planning (instruction analysis), task creation (functional decomposition), code generation (task-specific code synthesis), and assembly (Streamlit app construction). Uses LangChain integration for LLM orchestration and maintains semantic fidelity between user intent and generated UI/logic components.","intents":["I want to describe an app idea in plain English and get a working prototype without writing code","I need to rapidly iterate on app concepts by describing changes in natural language","I want to generate a Streamlit dashboard from a description of what data it should display and how users interact with it"],"best_for":["non-technical founders and product managers prototyping MVP applications","rapid application development teams needing quick UI scaffolding","LLM application developers building agent-based Streamlit frontends"],"limitations":["Generated code quality depends on LLM capability and instruction clarity — complex business logic may require manual refinement","Limited to Streamlit framework constraints — cannot generate native mobile or desktop applications","No built-in version control or rollback for generated applications — requires manual Git integration","Self-refinement loop adds latency (multiple LLM calls per generation cycle) — not suitable for real-time code generation"],"requires":["Python 3.8+","LangChain library (0.0.x or 0.1.x compatible)","Streamlit 1.0+","API key for OpenAI, Anthropic, or compatible LLM provider","Internet connectivity for LLM API calls"],"input_types":["natural language text (user instruction/description)","optional: existing Streamlit code for refinement"],"output_types":["Python code (Streamlit application)","executable .py file","structured task plan (intermediate representation)"],"categories":["code-generation-editing","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-demogpt__cap_1","uri":"capability://planning.reasoning.plan.based.instruction.decomposition.with.validation","name":"plan-based-instruction-decomposition-with-validation","description":"Analyzes natural language instructions to generate structured execution plans, then validates plans through controller feedback loops before task creation. The planning chain extracts user requirements, identifies application components, and sequences them logically. Controllers validate plan feasibility and provide refinement prompts to the LLM if plans are incomplete or contradictory.","intents":["I want the system to understand my app requirements and break them into logical steps before generating code","I need validation that my app idea is technically feasible before code generation begins","I want to see the system's interpretation of my requirements as a structured plan before code is written"],"best_for":["teams wanting explainability in code generation (visible plan stage)","iterative development workflows where plan refinement precedes implementation","complex applications requiring multi-step decomposition"],"limitations":["Plan quality depends on instruction clarity — ambiguous requirements produce suboptimal decompositions","Controller validation is rule-based and may miss semantic inconsistencies in complex plans","No user interaction during planning stage — feedback loop is LLM-to-controller only, not human-in-the-loop"],"requires":["LLM API access (OpenAI or Anthropic)","LangChain chains module","Python 3.8+"],"input_types":["natural language instruction (text)"],"output_types":["structured plan (list of sequential steps)","validation feedback (text)","task list (intermediate representation)"],"categories":["planning-reasoning","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-demogpt__cap_10","uri":"capability://code.generation.editing.task.template.system.with.extensibility","name":"task-template-system-with-extensibility","description":"Implements a task template registry where each task type (UI element, document processor, chat interface, etc.) has a corresponding template defining code structure, required imports, and parameter placeholders. Users and developers can add new task templates to extend the system's capabilities. The code generation pipeline looks up task templates and fills in parameters based on task specifications, enabling modular and extensible code synthesis.","intents":["I want to extend DemoGPT with new task types without modifying the core generation pipeline","I need to define custom task templates for domain-specific functionality","I want to contribute new task types to the DemoGPT community"],"best_for":["developers extending DemoGPT with custom task types","organizations with domain-specific code generation needs","community contributors building task template libraries"],"limitations":["Task template creation requires understanding DemoGPT's template format and parameter system","No automatic validation of task templates — malformed templates may produce broken code","Template parameters are static — cannot adapt to user-specific requirements dynamically","Limited documentation on task template creation — steep learning curve for contributors"],"requires":["DemoGPT source code access","Understanding of task template format (YAML or Python)","Python 3.8+","Knowledge of target domain (e.g., Streamlit, LangChain patterns)"],"input_types":["task template definition (YAML or Python)","template parameters and placeholders"],"output_types":["registered task template","code generated from template"],"categories":["code-generation-editing","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-demogpt__cap_11","uri":"capability://planning.reasoning.multi.step.llm.chain.orchestration.with.langchain","name":"multi-step-llm-chain-orchestration-with-langchain","description":"Orchestrates complex multi-step LLM workflows using LangChain's chain abstractions, combining planning chains, task chains, and refinement chains into a coordinated pipeline. The system manages prompt templates, chain composition, and intermediate state passing between steps. Chains are composed using LangChain's pipe operator and sequential composition, enabling flexible workflow definition and reuse.","intents":["I want to orchestrate complex multi-step LLM workflows (planning → task creation → code generation → refinement)","I need to manage state and context across multiple LLM calls in a structured way","I want to compose reusable LLM chains into larger workflows"],"best_for":["complex code generation pipelines requiring multiple LLM steps","systems needing structured multi-step reasoning","workflows with intermediate validation and feedback loops"],"limitations":["Chain composition adds complexity — debugging multi-step workflows is difficult","State passing between chains requires careful prompt engineering — context loss is common","LangChain chain abstractions have overhead — each chain step adds ~100-200ms latency","No built-in observability — difficult to trace which chain step produced errors or unexpected results"],"requires":["LangChain 0.0.x or 0.1.x with chain abstractions","LLM API access","Python 3.8+","Understanding of LangChain chain composition patterns"],"input_types":["chain definitions (LangChain chain objects)","prompt templates","intermediate state (text, structured data)"],"output_types":["chain execution results","final output (code, plans, etc.)"],"categories":["planning-reasoning","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-demogpt__cap_12","uri":"capability://automation.workflow.error.recovery.and.fallback.mechanisms","name":"error-recovery-and-fallback-mechanisms","description":"Implements error handling and fallback strategies for code generation failures, including syntax error recovery, import resolution, and graceful degradation. When code generation fails (syntax errors, missing imports, validation failures), the system attempts recovery through re-generation with error context, fallback to simpler code patterns, or user notification with suggestions. Fallback mechanisms ensure applications remain functional even if some features cannot be generated.","intents":["I want the system to recover from code generation errors automatically without user intervention","I need graceful degradation when certain features cannot be generated","I want clear error messages and suggestions when generation fails"],"best_for":["production systems requiring high reliability","non-technical users who cannot debug code generation failures","applications where partial functionality is acceptable"],"limitations":["Error recovery adds latency and complexity — multiple re-generation attempts slow down generation","Fallback mechanisms may produce suboptimal code — simpler patterns may lack desired functionality","Error messages may be unclear to non-technical users — requires good UX design for error communication","Some errors (logic errors, semantic issues) cannot be recovered automatically"],"requires":["Error detection and classification system","Fallback code patterns for common failures","LLM API access for re-generation","Python 3.8+"],"input_types":["generated code (with potential errors)","error messages and stack traces"],"output_types":["recovered/fixed code","error reports with suggestions","fallback code patterns"],"categories":["automation-workflow","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-demogpt__cap_13","uri":"capability://tool.use.integration.python.api.and.command.line.interface.for.programmatic.access","name":"python-api-and-command-line-interface-for-programmatic-access","description":"Exposes DemoGPT functionality through both Python API and command-line interface, enabling programmatic integration and scripted usage. The Python API provides classes and functions for instruction parsing, plan generation, code synthesis, and application execution. The CLI supports batch processing, configuration files, and output formatting options. Both interfaces abstract away internal complexity, providing clean entry points for different usage patterns.","intents":["I want to integrate DemoGPT into my Python application or workflow programmatically","I need to generate applications from a command-line script or CI/CD pipeline","I want to batch-generate multiple applications from a list of instructions"],"best_for":["developers integrating DemoGPT into larger systems","CI/CD pipelines automating application generation","batch processing and bulk application generation"],"limitations":["Python API requires understanding of DemoGPT's internal classes and abstractions","CLI has limited customization options compared to programmatic API","No built-in authentication or access control — requires external security layer for multi-user scenarios","Output formatting options are limited — complex customization requires code modification"],"requires":["Python 3.8+","DemoGPT installed as Python package","LLM API keys configured","Optional: configuration files (YAML or JSON)"],"input_types":["natural language instructions (text or file)","configuration parameters (Python dict or CLI arguments)","optional: existing code for refinement"],"output_types":["generated Python code","Streamlit application","execution logs and reports"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-demogpt__cap_2","uri":"capability://code.generation.editing.task.specific.code.generation.with.specialized.chains","name":"task-specific-code-generation-with-specialized-chains","description":"Generates code snippets for distinct task types (UI elements, document processing, chat functionality, web search integration) using specialized task chains that contain domain-specific prompts and templates. Each task chain encapsulates the code generation logic for a particular capability, enabling modular synthesis and reusability. Task chains receive task specifications and output Python code ready for assembly into the final application.","intents":["I want the system to generate different types of code (UI, backend logic, integrations) using specialized templates for each","I need code generation that understands domain-specific patterns (e.g., LangChain chat chains, Streamlit widgets)","I want to extend the system with new task types without rewriting the entire code generation pipeline"],"best_for":["developers building extensible code generation systems","teams needing modular, reusable code synthesis for specific domains","applications requiring consistent code patterns across multiple task types"],"limitations":["Task chains are pre-defined — new task types require manual chain implementation and prompt engineering","Generated code follows template patterns, limiting creative or unconventional implementations","No cross-task optimization — each task generates code independently without considering interactions with other tasks","Task chain prompts are static — cannot adapt to user-specific coding style or conventions"],"requires":["LangChain library with chain abstractions","LLM API access","Task template definitions (YAML or Python)","Python 3.8+"],"input_types":["task specification (structured data: task type, parameters, dependencies)","task template (code skeleton)"],"output_types":["Python code snippet (task-specific implementation)","code with placeholders for user customization"],"categories":["code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-demogpt__cap_3","uri":"capability://code.generation.editing.self.refinement.loop.with.code.validation","name":"self-refinement-loop-with-code-validation","description":"Implements an iterative refinement cycle where generated code is validated (syntax, import availability, logical consistency), and validation failures trigger automatic re-generation with error feedback injected into LLM prompts. The system executes generated code in a sandboxed environment, catches errors, and prompts the LLM to fix issues without user intervention. Refinement continues until code passes validation or max iterations reached.","intents":["I want the system to automatically fix code errors and regenerate if the first attempt has syntax or import issues","I need generated code to be validated before delivery to ensure it's executable","I want the system to learn from errors and improve code quality across multiple generation attempts"],"best_for":["automated code generation pipelines requiring high reliability","non-technical users who cannot manually debug generated code","systems where code quality and executability are critical"],"limitations":["Refinement loop adds latency — each iteration requires LLM API call and code validation (typically 2-5 seconds per iteration)","Sandboxed execution cannot validate runtime behavior beyond syntax — logic errors may pass validation","Max iteration limit prevents infinite loops but may leave code in partially-broken state if limit reached","Validation feedback is LLM-interpreted, not human-reviewed — may miss subtle logical errors or security issues"],"requires":["LLM API access with low latency","Python sandbox environment (exec() with restricted globals or containerized execution)","Code parser/validator (ast module or similar)","Error message parsing and injection into prompts"],"input_types":["generated Python code (string)","validation error messages (text)"],"output_types":["validated Python code (executable)","refinement history (log of iterations and errors)"],"categories":["code-generation-editing","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-demogpt__cap_4","uri":"capability://tool.use.integration.langchain.based.llm.abstraction.and.provider.agnostic.integration","name":"langchain-based-llm-abstraction-and-provider-agnostic-integration","description":"Abstracts LLM interactions through LangChain's unified interface, enabling support for multiple LLM providers (OpenAI, Anthropic, Ollama, local models) without changing core generation logic. The system uses LangChain chains, prompts, and memory abstractions to orchestrate multi-step LLM workflows. Provider switching is configuration-driven (environment variables or config files), allowing users to swap LLMs without code changes.","intents":["I want to use different LLM providers (OpenAI, Anthropic, local models) without rewriting the generation pipeline","I need to switch LLM providers based on cost, latency, or capability requirements","I want to use open-source or self-hosted LLMs instead of proprietary APIs"],"best_for":["organizations with multi-provider LLM strategies","cost-conscious teams wanting to switch between expensive and cheap models","privacy-focused deployments using self-hosted or local LLMs"],"limitations":["LangChain abstraction adds ~50-100ms latency per LLM call due to wrapper overhead","Not all LLM providers support identical feature sets — some chains may fail with certain models","Prompt engineering is often provider-specific — prompts optimized for GPT-4 may underperform with Anthropic Claude","Local/open-source models may produce lower-quality code than proprietary models, requiring more refinement iterations"],"requires":["LangChain 0.0.x or 0.1.x","API keys for chosen LLM providers (OpenAI, Anthropic, etc.) OR local LLM server (Ollama, vLLM)","Python 3.8+","Network connectivity for cloud LLM APIs (or local network for self-hosted)"],"input_types":["LLM provider configuration (environment variables or config file)","prompts and chains (LangChain objects)"],"output_types":["LLM responses (text, structured data)","chain execution results"],"categories":["tool-use-integration","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-demogpt__cap_5","uri":"capability://code.generation.editing.streamlit.ui.code.generation.with.widget.synthesis","name":"streamlit-ui-code-generation-with-widget-synthesis","description":"Generates Streamlit-specific Python code that creates interactive web UIs, including widget synthesis (text inputs, sliders, buttons, file uploaders, chat interfaces). The system understands Streamlit's reactive execution model and generates code that properly manages state, handles user interactions, and displays outputs. Generated code includes proper imports, layout organization, and integration with LangChain for backend logic.","intents":["I want to generate a complete Streamlit UI from a description of what the app should display and how users interact with it","I need the system to understand Streamlit's execution model and generate code that properly manages state and reactivity","I want generated UIs that include proper error handling, input validation, and user feedback"],"best_for":["rapid prototyping of data applications and dashboards","teams building LLM-powered web interfaces without frontend expertise","non-technical users wanting to create interactive web apps"],"limitations":["Limited to Streamlit's built-in widgets — cannot generate custom React components or advanced CSS styling","Streamlit's reactive execution model can produce unexpected behavior if generated code doesn't properly manage state","No support for complex multi-page applications or advanced routing — limited to Streamlit's page structure","Generated UIs may have performance issues with large datasets due to Streamlit's re-execution on every interaction"],"requires":["Streamlit 1.0+","Python 3.8+","LangChain for backend integration","LLM API access"],"input_types":["UI description (natural language or structured specification)","data schema (optional, for input/output types)"],"output_types":["Python code with Streamlit widgets and layout","executable Streamlit application"],"categories":["code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-demogpt__cap_6","uri":"capability://code.generation.editing.document.processing.and.rag.integration.code.generation","name":"document-processing-and-rag-integration-code-generation","description":"Generates code for document ingestion, processing, and retrieval-augmented generation (RAG) workflows using LangChain's document loaders, text splitters, and vector store integrations. The system synthesizes code that loads documents (PDF, TXT, CSV), chunks them, embeds them into vector databases, and integrates retrieval into chat or search interfaces. Supports multiple vector store backends (FAISS, Pinecone, Weaviate) through LangChain abstractions.","intents":["I want to generate a document Q&A application that can ingest PDFs and answer questions about them","I need the system to generate RAG pipelines that retrieve relevant documents and feed them to LLMs","I want to create a knowledge base application that processes multiple documents and enables semantic search"],"best_for":["teams building document-based AI applications (Q&A, summarization, search)","organizations needing to quickly prototype RAG systems","non-technical users wanting to create searchable document repositories"],"limitations":["Document processing quality depends on document format and structure — scanned PDFs or complex layouts may require manual preprocessing","Embedding quality and retrieval relevance depend on chosen embedding model and vector store — no automatic tuning","Large document collections may require significant storage and compute for embedding and retrieval","Generated code may not handle edge cases (corrupted files, unsupported formats, encoding issues) gracefully"],"requires":["LangChain with document loader and vector store integrations","Embedding model API (OpenAI, Hugging Face, or local)","Vector store (FAISS for local, or cloud service like Pinecone)","Document processing libraries (PyPDF2, python-docx, etc.)","Python 3.8+"],"input_types":["document processing requirements (natural language description)","document types and formats (PDF, TXT, CSV, etc.)","vector store configuration"],"output_types":["Python code for document loading, chunking, embedding, and retrieval","RAG pipeline code integrating with LLM chains"],"categories":["code-generation-editing","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-demogpt__cap_7","uri":"capability://code.generation.editing.web.search.integration.code.generation","name":"web-search-integration-code-generation","description":"Generates code that integrates web search capabilities into applications using LangChain's search tools (Google Search, Bing Search, DuckDuckGo) and search result processing chains. The system synthesizes code that queries the web, processes search results, and feeds them into LLM chains for answer generation or summarization. Supports both direct search integration and search-augmented reasoning chains.","intents":["I want to generate an application that can search the web and answer questions using current information","I need the system to create search-augmented LLM chains that retrieve and synthesize web results","I want to build a research assistant that gathers web information and summarizes it"],"best_for":["applications requiring current information beyond training data cutoff","research and information gathering tools","question-answering systems needing real-time web data"],"limitations":["Web search quality depends on search engine and query formulation — may return irrelevant or low-quality results","Search result processing adds latency (typically 2-5 seconds per search) — not suitable for real-time applications","Search API rate limits and costs (Google Search API, Bing Search API) may constrain usage","Generated code may not handle search result parsing robustly — HTML structure changes can break extraction"],"requires":["LangChain with search tool integrations","Web search API key (Google Custom Search, Bing Search, or DuckDuckGo API)","Python 3.8+","Internet connectivity"],"input_types":["search integration requirements (natural language description)","search tool configuration (API keys, search parameters)"],"output_types":["Python code for web search integration","search-augmented LLM chain code"],"categories":["code-generation-editing","search-retrieval"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-demogpt__cap_8","uri":"capability://code.generation.editing.chat.interface.and.conversation.memory.code.generation","name":"chat-interface-and-conversation-memory-code-generation","description":"Generates code for conversational interfaces with conversation memory management, using LangChain's ConversationChain and memory abstractions. The system synthesizes code that maintains conversation history, manages context windows, and integrates memory into LLM chains for coherent multi-turn conversations. Supports multiple memory backends (in-memory, persistent storage, vector-based semantic memory) and conversation summarization for long-running chats.","intents":["I want to generate a chatbot application that remembers conversation history and maintains context","I need the system to create chat interfaces with proper memory management for multi-turn conversations","I want to build a conversational AI that can reference previous messages and maintain coherent dialogue"],"best_for":["chatbot and conversational AI applications","customer support and assistance tools","interactive applications requiring context awareness"],"limitations":["Memory management adds latency and token consumption — long conversations may exceed LLM context windows","In-memory storage doesn't persist across application restarts — requires external persistence for production use","Conversation summarization (for long chats) requires additional LLM calls, increasing costs and latency","No built-in privacy or data retention policies — conversation history may contain sensitive information"],"requires":["LangChain with memory and conversation chain abstractions","LLM API access","Optional: persistent storage backend (database, file system) for conversation history","Python 3.8+"],"input_types":["chat interface requirements (natural language description)","memory configuration (memory type, context window size)"],"output_types":["Python code for chat interface with memory management","Streamlit chat UI code with conversation history display"],"categories":["code-generation-editing","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-demogpt__cap_9","uri":"capability://code.generation.editing.agent.hub.and.reusable.agent.templates","name":"agent-hub-and-reusable-agent-templates","description":"Provides a library of pre-built agent templates and reusable agent components that can be composed into applications. The AgentHub contains templates for common agent patterns (ReAct, tool-using agents, planning agents) that users can reference in natural language instructions. The system synthesizes code by instantiating and composing these templates rather than generating agents from scratch, improving code quality and consistency.","intents":["I want to use pre-built agent patterns (ReAct, tool-using agents) without implementing them from scratch","I need to compose multiple agents together to solve complex tasks","I want to leverage community-contributed agent templates in my generated applications"],"best_for":["developers building agent-based applications","teams wanting to standardize on proven agent patterns","rapid prototyping of multi-agent systems"],"limitations":["Limited to pre-built templates — custom agent patterns require manual implementation","Template composition may not handle all edge cases or complex interactions between agents","AgentHub maintenance and versioning — outdated templates may not work with latest LangChain versions","No automatic agent selection — users must specify which templates to use in instructions"],"requires":["AgentHub library (bundled with DemoGPT)","LangChain with agent abstractions","Python 3.8+"],"input_types":["agent template references (natural language or template names)","agent composition specifications"],"output_types":["Python code instantiating and composing agent templates","executable agent code"],"categories":["code-generation-editing","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":25,"verified":false,"data_access_risk":"high","permissions":["Python 3.8+","LangChain library (0.0.x or 0.1.x compatible)","Streamlit 1.0+","API key for OpenAI, Anthropic, or compatible LLM provider","Internet connectivity for LLM API calls","LLM API access (OpenAI or Anthropic)","LangChain chains module","DemoGPT source code access","Understanding of task template format (YAML or Python)","Knowledge of target domain (e.g., Streamlit, LangChain patterns)"],"failure_modes":["Generated code quality depends on LLM capability and instruction clarity — complex business logic may require manual refinement","Limited to Streamlit framework constraints — cannot generate native mobile or desktop applications","No built-in version control or rollback for generated applications — requires manual Git integration","Self-refinement loop adds latency (multiple LLM calls per generation cycle) — not suitable for real-time code generation","Plan quality depends on instruction clarity — ambiguous requirements produce suboptimal decompositions","Controller validation is rule-based and may miss semantic inconsistencies in complex plans","No user interaction during planning stage — feedback loop is LLM-to-controller only, not human-in-the-loop","Task template creation requires understanding DemoGPT's template format and parameter system","No automatic validation of task templates — malformed templates may produce broken code","Template parameters are static — cannot adapt to user-specific requirements dynamically","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.05,"quality":0.35,"ecosystem":0.39999999999999997,"match_graph":0.25,"freshness":0.52,"weights":{"adoption":0.3,"quality":0.2,"ecosystem":0.15,"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-06-17T09:51:03.037Z","last_scraped_at":"2026-05-03T14:00:10.321Z","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=demogpt","compare_url":"https://unfragile.ai/compare?artifact=demogpt"}},"signature":"mtw1ttqZHp9TLDkJK+JQenXPNfBCYfl9HzWC1HIohOmUUe0tP2ItIzXy9LMtsGdH8pYEMw2Ts1WudoIexhqeCA==","signedAt":"2026-07-09T11:32:12.055Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/demogpt","artifact":"https://unfragile.ai/demogpt","verify":"https://unfragile.ai/api/v1/verify?slug=demogpt","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"}}