{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github-aaif-goose--goose","slug":"aaif-goose--goose","name":"goose","type":"agent","url":"https://goose-docs.ai/","page_url":"https://unfragile.ai/aaif-goose--goose","categories":["ai-agents","testing-quality"],"tags":["acp","ai","ai-agents","mcp"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github-aaif-goose--goose__cap_0","uri":"capability://tool.use.integration.multi.provider.llm.abstraction.with.canonical.model.registry","name":"multi-provider llm abstraction with canonical model registry","description":"Goose implements a canonical model registry that normalizes API differences across 20+ LLM providers (OpenAI, Anthropic, Ollama, local models, etc.) through a declarative provider layer. The registry maps provider-specific model names to canonical identifiers and handles wire protocol translation, allowing seamless provider switching without code changes. Built on Rust's type system with compile-time provider validation and runtime fallback chains.","intents":["I want to switch between Claude, GPT-4, and local Ollama models without rewriting agent logic","I need my agent to work offline with local models but fall back to cloud providers when needed","I want to add a new LLM provider without modifying core agent code"],"best_for":["teams building multi-model AI agents","developers needing provider-agnostic LLM abstractions","organizations with hybrid cloud/on-premise deployments"],"limitations":["Canonical registry requires manual mapping for new providers — no auto-discovery","Provider-specific features (vision, function calling variants) may not map cleanly across all providers","Latency varies significantly by provider; no built-in load balancing or latency optimization"],"requires":["Rust 1.70+","API keys for cloud providers (OpenAI, Anthropic, etc.) OR local Ollama instance","Network access to provider endpoints or local model server"],"input_types":["provider name (string)","model identifier (string)","LLM request (messages, system prompt, parameters)"],"output_types":["normalized LLM response","token usage metadata","provider-agnostic error codes"],"categories":["tool-use-integration","provider-abstraction"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-aaif-goose--goose__cap_1","uri":"capability://tool.use.integration.mcp.server.integration.and.extension.system","name":"mcp server integration and extension system","description":"Goose implements a full MCP (Model Context Protocol) client and transport layer that discovers, connects to, and orchestrates external MCP servers as extensions. The system handles stdio/HTTP transport, schema validation, and capability negotiation. Built-in MCP extensions (goose-mcp crate) provide file operations, shell execution, and system tools; external servers can be registered via configuration. Includes security permission system with allowlisting for dangerous operations.","intents":["I want to extend Goose with custom tools without modifying core code","I need to connect Goose to existing MCP servers (e.g., Anthropic's file server, web search tools)","I want to sandbox tool execution and control which operations the agent can perform"],"best_for":["teams building extensible AI agent platforms","developers integrating Goose with existing MCP ecosystems","organizations requiring fine-grained permission control over agent actions"],"limitations":["MCP transport overhead adds ~50-200ms per tool call depending on stdio vs HTTP","No built-in tool result caching — repeated tool calls incur full transport cost","Permission system is allowlist-based; denying specific operations requires explicit configuration","External MCP servers must implement MCP spec correctly; no validation or sandboxing of server code"],"requires":["MCP server implementation (stdio or HTTP endpoint)","Configuration file listing MCP servers and their capabilities","Rust 1.70+ for building custom MCP extensions"],"input_types":["MCP server endpoint (stdio command or HTTP URL)","tool schema (JSON schema describing tool inputs/outputs)","tool invocation request (tool name + arguments)"],"output_types":["tool execution result (text, structured data, or error)","capability metadata (available tools and their schemas)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-aaif-goose--goose__cap_10","uri":"capability://planning.reasoning.multi.agent.orchestration.and.subagent.spawning","name":"multi-agent orchestration and subagent spawning","description":"Goose supports spawning subagents to parallelize task execution or create hierarchical agent structures. Parent agents can delegate subtasks to subagents, collect results, and coordinate overall workflow. Subagents run in isolated contexts with their own sessions and tool access. The system supports both synchronous coordination (wait for all subagents) and asynchronous coordination (collect results as they arrive). Subagent communication uses message passing through the session store.","intents":["I want to parallelize agent work (e.g., test multiple components simultaneously)","I need to create a hierarchy of agents (e.g., manager agent coordinating worker agents)","I want to isolate agent contexts to prevent interference"],"best_for":["teams automating large-scale tasks that benefit from parallelization","organizations building complex agent workflows","developers needing agent isolation and context separation"],"limitations":["Subagent coordination adds complexity; debugging multi-agent workflows is difficult","No built-in load balancing — subagents may not be evenly distributed across resources","Message passing through session store adds latency; no direct inter-agent communication","Failure handling is basic — no built-in retry logic or circuit breakers for subagent failures"],"requires":["Parent agent with subagent spawning capability","Session store for message passing","Sufficient resources (LLM API quota, compute) for multiple concurrent agents"],"input_types":["subtask description (for subagent)","subagent configuration (tools, model, parameters)","coordination strategy (synchronous or asynchronous)"],"output_types":["subagent results (collected from all subagents)","coordination metadata (timing, status)"],"categories":["planning-reasoning","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-aaif-goose--goose__cap_11","uri":"capability://safety.moderation.security.permission.system.with.allowlisting.and.audit.logging","name":"security permission system with allowlisting and audit logging","description":"Goose implements a security permission system that allowlists dangerous operations (shell execution, file deletion, network access) and logs all agent actions for audit trails. The system uses a declarative allowlist (ALLOWLIST.md) that specifies which operations are permitted and under what conditions. All agent actions are logged with timestamps, user context, and results. The system supports role-based access control (RBAC) for multi-user deployments.","intents":["I want to prevent the agent from executing dangerous commands (e.g., 'rm -rf /')","I need to audit all agent actions for compliance and debugging","I want to grant different permissions to different users or agents"],"best_for":["organizations deploying Goose in production environments","teams with compliance requirements (SOC 2, HIPAA, etc.)","developers who want to prevent accidental or malicious agent actions"],"limitations":["Allowlist is static; dynamic permission changes require configuration reload","Audit logging adds overhead; high-volume agent execution may impact performance","RBAC is basic; fine-grained permission control requires custom implementation","Allowlist is declarative; complex permission logic may be difficult to express"],"requires":["ALLOWLIST.md configuration file","Audit log storage (local file or external service)","User authentication system (for RBAC)"],"input_types":["agent action (tool call, command execution, etc.)","user context (user ID, role)","operation type (shell, file, network, etc.)"],"output_types":["permission decision (allow/deny)","audit log entry (action, user, timestamp, result)"],"categories":["safety-moderation","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-aaif-goose--goose__cap_12","uri":"capability://data.processing.analysis.model.evaluation.and.benchmarking.framework","name":"model evaluation and benchmarking framework","description":"Goose includes an Open Model Gym benchmarking framework for evaluating agent performance across different LLM models and configurations. The framework defines standardized tasks (coding challenges, refactoring, debugging) with expected outputs, runs agents against these tasks, and measures success rates, latency, and cost. Results are aggregated and compared across models, enabling data-driven model selection. Benchmarks are extensible — users can add custom tasks.","intents":["I want to compare agent performance across different LLM models (GPT-4, Claude, Llama)","I need to measure the cost-effectiveness of different model choices","I want to evaluate how well agents perform on specific task types"],"best_for":["teams evaluating LLM models for agent deployment","organizations optimizing cost vs. performance","researchers studying agent capabilities and limitations"],"limitations":["Benchmarks are task-specific; results may not generalize to other domains","Evaluation requires running agents multiple times; can be expensive (LLM API costs)","Success metrics are predefined; custom evaluation logic requires code changes","Benchmark results are sensitive to prompt engineering and agent configuration"],"requires":["Benchmark task definitions (YAML or JSON)","LLM provider API keys for models being evaluated","Expected outputs for tasks (for success measurement)"],"input_types":["benchmark task (description, inputs, expected outputs)","model configuration (model name, parameters)","evaluation metrics (success rate, latency, cost)"],"output_types":["benchmark results (per-task and aggregated)","comparison report (across models)","cost analysis (per-model and per-task)"],"categories":["data-processing-analysis","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-aaif-goose--goose__cap_13","uri":"capability://automation.workflow.configuration.management.and.environment.variable.handling","name":"configuration management and environment variable handling","description":"Goose uses a declarative configuration system (YAML-based) for specifying agent behavior, tool access, LLM provider settings, and security policies. Configuration supports environment variable substitution, allowing sensitive values (API keys) to be injected at runtime. The system supports multiple configuration profiles (development, staging, production) and validates configuration at startup. Configuration can be loaded from files, environment variables, or programmatically.","intents":["I want to configure Goose without hardcoding API keys or sensitive values","I need different configurations for development and production environments","I want to validate configuration before starting the agent"],"best_for":["teams deploying Goose across multiple environments","organizations with strict security policies around secrets management","developers who want to avoid configuration drift"],"limitations":["YAML syntax can be error-prone; no built-in validation for complex configurations","Environment variable substitution is simple string replacement; no type coercion","Configuration changes require restart; no hot-reload capability","No built-in secrets management integration (e.g., HashiCorp Vault); requires manual setup"],"requires":["Configuration file (YAML format)","Environment variables for sensitive values","Goose instance to load and validate configuration"],"input_types":["configuration file (YAML)","environment variables (key-value pairs)","configuration profile (development, staging, production)"],"output_types":["validated configuration (parsed and type-checked)","configuration errors (validation failures)"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-aaif-goose--goose__cap_2","uri":"capability://automation.workflow.context.aware.code.execution.and.shell.integration","name":"context-aware code execution and shell integration","description":"Goose provides native shell execution capabilities through MCP-based tool servers that understand the current working directory, environment variables, and project context. The agent can execute arbitrary shell commands, capture output, and parse results. Built-in tools include file operations (read/write/delete), directory traversal, and command execution with environment isolation. Execution context is tracked across agent steps, enabling stateful workflows (e.g., install dependencies, then run tests).","intents":["I want the agent to install dependencies, run tests, and commit changes in sequence","I need the agent to understand the current project structure and execute commands in the right directory","I want to capture command output and use it to inform the agent's next action"],"best_for":["developers automating CI/CD workflows","teams using Goose for end-to-end project automation","engineers building agents that need to interact with system tools and package managers"],"limitations":["Shell execution is inherently unsafe — requires explicit allowlisting of commands or directories","No built-in output parsing; agent must interpret raw command output (stdout/stderr)","Environment isolation is limited — agent inherits parent process environment; no containerization","Long-running commands (e.g., build processes) may timeout; no built-in streaming or progress tracking"],"requires":["Unix-like shell (bash, zsh) or Windows PowerShell","File system access to project directory","Appropriate permissions to execute commands (e.g., sudo for system-level operations)"],"input_types":["shell command (string)","working directory (path)","environment variables (key-value pairs)"],"output_types":["command exit code (integer)","stdout (text)","stderr (text)"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-aaif-goose--goose__cap_3","uri":"capability://planning.reasoning.agentic.reasoning.loop.with.tool.use.planning","name":"agentic reasoning loop with tool-use planning","description":"Goose implements a planning-reasoning loop where the agent decomposes user requests into subtasks, selects appropriate tools (MCP servers), executes them, observes results, and iterates. The loop uses chain-of-thought reasoning to decide when to use tools vs. when to ask for clarification. Built on a state machine that tracks agent state (thinking, tool-calling, waiting for user input) and manages context across iterations. Supports both synchronous execution (wait for tool result before next step) and asynchronous workflows (schedule tasks, return to user).","intents":["I want the agent to break down a complex task (e.g., 'refactor this codebase') into steps and execute them autonomously","I need the agent to decide which tools to use and in what order without explicit instructions","I want to observe the agent's reasoning and intervene if needed"],"best_for":["teams building autonomous AI agents for engineering tasks","developers who want agents to handle multi-step workflows without human intervention","organizations automating repetitive engineering work (testing, deployment, refactoring)"],"limitations":["Reasoning loop adds latency — each iteration requires LLM inference; complex tasks may take minutes","Agent may get stuck in loops or make poor tool choices; requires good prompt engineering and guardrails","No built-in backtracking or error recovery — agent must learn from failures within a single session","Context window limits reasoning depth; very complex tasks may exceed token limits"],"requires":["LLM provider with function calling support (OpenAI, Anthropic, etc.)","Tool definitions (MCP servers) for agent to choose from","Sufficient context window (8K+ tokens recommended for complex tasks)"],"input_types":["user request (natural language)","available tools (MCP server schemas)","execution history (previous tool calls and results)"],"output_types":["agent action (tool call or final response)","reasoning trace (chain-of-thought explanation)","execution result (tool output or agent response)"],"categories":["planning-reasoning","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-aaif-goose--goose__cap_4","uri":"capability://automation.workflow.recipe.based.task.automation.and.scheduling","name":"recipe-based task automation and scheduling","description":"Goose provides a recipe system where developers define multi-step workflows as YAML configurations that specify task sequences, tool invocations, and conditional logic. Recipes can be scheduled to run on a cron-like schedule or triggered by events. The system supports subagents (spawning child agents for parallel or hierarchical task execution) and recipe composition (recipes calling other recipes). Execution is tracked in a session store with full history and rollback capability.","intents":["I want to define a recurring task (e.g., 'run tests every hour and notify on failure') without writing code","I need to orchestrate complex workflows with conditional logic (e.g., 'if tests fail, run debug script')","I want to spawn multiple agents to work on different parts of a task in parallel"],"best_for":["teams automating repetitive engineering workflows","developers building CI/CD pipelines with AI agents","organizations needing scheduled, event-driven agent execution"],"limitations":["Recipe syntax is YAML-based; complex logic requires careful structuring or falls back to agent reasoning","Scheduling is local to the Goose instance; no distributed scheduling or cluster support","Subagent coordination is basic — no built-in load balancing or failure handling across subagents","Recipe versioning and rollback are manual; no built-in version control integration"],"requires":["Recipe definition file (YAML format)","Goose server running to execute recipes","Tool definitions (MCP servers) referenced in recipes"],"input_types":["recipe definition (YAML)","trigger event (cron schedule, webhook, manual invocation)","input parameters (variables passed to recipe)"],"output_types":["execution result (success/failure)","execution log (full history of steps)","output artifacts (files, reports, etc.)"],"categories":["automation-workflow","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-aaif-goose--goose__cap_5","uri":"capability://memory.knowledge.context.compaction.and.token.optimization","name":"context compaction and token optimization","description":"Goose implements context management that tracks token usage across agent iterations and automatically compacts context when approaching token limits. The system uses summarization, relevance filtering, and history pruning to reduce context size while preserving critical information. Context compaction is transparent to the agent — it observes the same interface but with optimized context. Supports both automatic compaction (triggered by token threshold) and manual compaction (user-initiated).","intents":["I want the agent to work on large codebases without hitting token limits","I need to reduce LLM costs by optimizing context usage","I want the agent to maintain long-running sessions without degrading performance"],"best_for":["teams working with large codebases or long-running agent sessions","cost-conscious organizations optimizing LLM API spend","developers building agents that need to maintain context over many iterations"],"limitations":["Compaction may lose important context — summarization is lossy and may miss edge cases","Automatic compaction adds latency (summarization requires LLM inference)","No built-in strategy for selecting which context to preserve; relies on heuristics","Compacted context is not reversible — once pruned, information is lost for the session"],"requires":["LLM provider for summarization (same provider as agent or separate)","Token counting library (integrated into Goose)","Configuration specifying compaction thresholds and strategies"],"input_types":["execution history (previous messages, tool calls, results)","token budget (maximum tokens for context)","compaction strategy (summarization, filtering, pruning)"],"output_types":["compacted context (reduced history)","compaction metadata (what was removed, why)","token savings (before/after token count)"],"categories":["memory-knowledge","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-aaif-goose--goose__cap_6","uri":"capability://tool.use.integration.rest.api.and.openapi.schema.generation","name":"rest api and openapi schema generation","description":"Goose exposes a REST API (goose-server crate) that allows external clients to invoke agents, manage sessions, and query execution history. The API is automatically documented via OpenAPI 3.0 schema, with TypeScript SDK generation for type-safe client integration. Endpoints support both synchronous (wait for result) and asynchronous (poll for status) execution patterns. Authentication uses OIDC for enterprise deployments.","intents":["I want to integrate Goose agents into my existing application via REST API","I need to build a custom UI that invokes Goose agents and displays results","I want to automate agent invocation from CI/CD pipelines or webhooks"],"best_for":["teams integrating Goose into larger systems","developers building custom UIs on top of Goose","organizations deploying Goose as a service"],"limitations":["REST API adds network latency compared to in-process agent calls","Asynchronous execution requires polling or webhook callbacks; no built-in WebSocket support for real-time updates","Authentication is OIDC-based; no built-in API key or token-based auth for simple deployments","OpenAPI schema generation is automatic but may not capture all edge cases or custom extensions"],"requires":["goose-server running and accessible","HTTP client library (any language)","OIDC provider for authentication (optional, for enterprise)"],"input_types":["HTTP request (POST /agents/{agent_id}/invoke with task description)","session ID (for polling results)","query parameters (filters, pagination)"],"output_types":["HTTP response (execution result, status, logs)","OpenAPI schema (JSON)","TypeScript SDK (generated code)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-aaif-goose--goose__cap_7","uri":"capability://text.generation.language.desktop.application.with.chat.interface.and.voice.input","name":"desktop application with chat interface and voice input","description":"Goose provides a desktop application (Electron-based UI, with Tauri rewrite in progress) that offers a chat interface for interacting with agents, session management, and settings configuration. The UI supports voice dictation for hands-free task specification and real-time rendering of agent reasoning and tool execution. Desktop app communicates with goose-server via REST API, allowing local or remote agent execution.","intents":["I want a user-friendly interface to interact with Goose agents without using CLI","I need to see the agent's reasoning and tool execution in real-time","I want to use voice commands to specify tasks"],"best_for":["non-technical users who prefer GUI over CLI","developers who want to observe agent behavior visually","teams using Goose as a productivity tool"],"limitations":["Desktop app requires Electron runtime; adds ~100MB to installation size","Voice input requires microphone and speech-to-text service (external dependency)","Real-time rendering of agent reasoning may lag for complex tasks","Tauri rewrite is in progress; Electron version may be deprecated"],"requires":["macOS, Windows, or Linux","goose-server running (local or remote)","Microphone for voice input (optional)"],"input_types":["text input (chat message)","voice input (audio, converted to text)","file upload (for context)"],"output_types":["chat message (agent response)","reasoning trace (visualized chain-of-thought)","tool execution log (real-time updates)","session history (saved conversations)"],"categories":["text-generation-language","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-aaif-goose--goose__cap_8","uri":"capability://automation.workflow.cli.with.interactive.repl.and.session.management","name":"cli with interactive repl and session management","description":"Goose provides a command-line interface (goose-cli crate) with an interactive REPL for real-time agent interaction, session management (save/load/resume), and command execution. The CLI supports both interactive mode (chat-like interaction) and batch mode (execute recipe or single task). Sessions are persisted to disk with full execution history, allowing users to resume interrupted tasks or audit past executions.","intents":["I want to interact with Goose agents from the terminal without a GUI","I need to save and resume agent sessions across multiple invocations","I want to run Goose in CI/CD pipelines or scripts"],"best_for":["developers comfortable with CLI tools","teams integrating Goose into CI/CD pipelines","users who prefer keyboard-driven workflows"],"limitations":["REPL interaction is synchronous — user must wait for agent response before next input","Terminal rendering of complex output (e.g., code diffs) may be difficult to read","Session persistence is local to the machine; no cloud sync or multi-device support","No built-in paging or output filtering for large results"],"requires":["Unix-like shell or Windows PowerShell","goose-cli binary installed","Terminal emulator with ANSI color support (recommended)"],"input_types":["CLI command (e.g., 'goose invoke --task \"refactor this file\"')","REPL input (chat message)","session ID (for resuming)"],"output_types":["agent response (text)","execution log (formatted for terminal)","session metadata (saved to disk)"],"categories":["automation-workflow","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-aaif-goose--goose__cap_9","uri":"capability://code.generation.editing.code.aware.file.operations.and.project.context.understanding","name":"code-aware file operations and project context understanding","description":"Goose integrates file operations (read, write, delete, list) as MCP tools with awareness of project structure, language-specific conventions, and code semantics. The agent can understand directory hierarchies, identify configuration files, and infer project type (Python, Node.js, Rust, etc.). File operations preserve formatting and indentation, and support atomic writes to prevent corruption. Built-in tools include file search, diff generation, and syntax-aware editing.","intents":["I want the agent to understand my project structure and edit files without breaking formatting","I need the agent to find relevant files based on semantic understanding (e.g., 'find all test files')","I want the agent to generate diffs before applying changes"],"best_for":["developers automating code refactoring and maintenance","teams using Goose for code generation and editing","organizations automating large-scale codebase changes"],"limitations":["File operations are synchronous — large file reads/writes may block the agent","Syntax-aware editing is limited to popular languages; less common languages may not be supported","No built-in version control integration — agent must manually handle git operations","Atomic writes are best-effort; concurrent edits from multiple agents may cause conflicts"],"requires":["File system access to project directory","Appropriate read/write permissions","Project structure must be discoverable (standard conventions)"],"input_types":["file path (relative or absolute)","file content (for write operations)","search query (for file discovery)"],"output_types":["file content (for read operations)","file list (for directory listing)","diff (for change preview)"],"categories":["code-generation-editing","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":55,"verified":false,"data_access_risk":"high","permissions":["Rust 1.70+","API keys for cloud providers (OpenAI, Anthropic, etc.) OR local Ollama instance","Network access to provider endpoints or local model server","MCP server implementation (stdio or HTTP endpoint)","Configuration file listing MCP servers and their capabilities","Rust 1.70+ for building custom MCP extensions","Parent agent with subagent spawning capability","Session store for message passing","Sufficient resources (LLM API quota, compute) for multiple concurrent agents","ALLOWLIST.md configuration file"],"failure_modes":["Canonical registry requires manual mapping for new providers — no auto-discovery","Provider-specific features (vision, function calling variants) may not map cleanly across all providers","Latency varies significantly by provider; no built-in load balancing or latency optimization","MCP transport overhead adds ~50-200ms per tool call depending on stdio vs HTTP","No built-in tool result caching — repeated tool calls incur full transport cost","Permission system is allowlist-based; denying specific operations requires explicit configuration","External MCP servers must implement MCP spec correctly; no validation or sandboxing of server code","Subagent coordination adds complexity; debugging multi-agent workflows is difficult","No built-in load balancing — subagents may not be evenly distributed across resources","Message passing through session store adds latency; no direct inter-agent communication","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.813840851552077,"quality":0.5,"ecosystem":0.62,"match_graph":0.25,"freshness":0.75,"weights":{"adoption":0.25,"quality":0.25,"ecosystem":0.1,"match_graph":0.28,"freshness":0.12}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-05-24T12:16:21.549Z","last_scraped_at":"2026-05-03T13:57:01.479Z","last_commit":"2026-05-03T13:52:02Z"},"community":{"stars":43702,"forks":4469,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=aaif-goose--goose","compare_url":"https://unfragile.ai/compare?artifact=aaif-goose--goose"}},"signature":"fGOHhNZ3BR8umgvOFhlgriTyvX9TpBmkr/SRG+JigXlY2L5QilWovLy7x1XNAuWYPiNKnl2i1Rse4XpLr1pYDw==","signedAt":"2026-06-20T22:56:37.580Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/aaif-goose--goose","artifact":"https://unfragile.ai/aaif-goose--goose","verify":"https://unfragile.ai/api/v1/verify?slug=aaif-goose--goose","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"}}