{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github-cloudwego--eino","slug":"cloudwego--eino","name":"eino","type":"framework","url":"https://www.cloudwego.io/docs/eino/","page_url":"https://unfragile.ai/cloudwego--eino","categories":["app-builders"],"tags":["ai","ai-application","ai-framework","langchain","langchain-for-go","langchaingo","llm-application"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github-cloudwego--eino__cap_0","uri":"capability://planning.reasoning.type.safe.graph.composition.with.generic.node.construction","name":"type-safe graph composition with generic node construction","description":"Eino provides a strongly-typed graph composition system where nodes are constructed with explicit input/output type parameters, enabling compile-time validation of edge connections between components. The framework uses Go generics to enforce that a node's output type matches the next node's input type, preventing runtime type mismatches. Graph construction happens through a fluent builder API that chains node additions and edge definitions, with a compilation phase that validates the entire DAG topology and type consistency before execution.","intents":["I want to build multi-step AI workflows where each step's output automatically matches the next step's input type","I need compile-time guarantees that my graph connections are type-safe before running agents","I want to compose complex LLM pipelines without runtime type errors from mismatched component interfaces"],"best_for":["Go developers building production LLM applications requiring type safety","Teams migrating from Python LangChain who want stronger compile-time guarantees","Builders of complex multi-agent systems where graph topology validation is critical"],"limitations":["Go generics syntax is verbose compared to Python — graph definitions require explicit type parameters for each node","Type system cannot validate dynamic branching conditions at compile time — conditional routing still requires runtime checks","No IDE autocomplete for dynamically-constructed graphs — only works with statically-defined node chains"],"requires":["Go 1.18+ (generics support)","Understanding of Go interface{} and generic constraints","Eino core framework imported"],"input_types":["Node definitions with input/output type parameters","Edge specifications between typed nodes","Graph configuration options"],"output_types":["Compiled graph object with validated topology","Type-safe execution engine bound to graph structure"],"categories":["planning-reasoning","graph-composition"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-cloudwego--eino__cap_1","uri":"capability://automation.workflow.streaming.first.message.processing.with.channel.based.task.management","name":"streaming-first message processing with channel-based task management","description":"Eino implements a streaming-first architecture where all component outputs flow through typed channels, enabling progressive token streaming from LLM responses without buffering entire outputs. The Task Manager coordinates concurrent execution of graph nodes using Go channels, with each node receiving input from upstream channels and writing output to downstream channels. This design allows real-time streaming of LLM tokens to clients while maintaining backpressure and preventing memory overflow from large responses.","intents":["I want to stream LLM responses token-by-token to users without waiting for the full response","I need to process multiple graph nodes concurrently while maintaining proper data flow and backpressure","I want to build real-time AI applications where intermediate results are available immediately"],"best_for":["Developers building streaming chat interfaces or real-time AI applications","Teams requiring low-latency token delivery for user-facing LLM features","High-throughput systems processing multiple concurrent graph executions"],"limitations":["Channel-based architecture adds complexity to error handling — errors in one node can cascade through the channel pipeline","Streaming prevents certain optimizations like batch processing multiple requests together","Backpressure handling requires careful buffer sizing — undersized buffers cause blocking, oversized buffers consume memory"],"requires":["Go 1.18+","Understanding of Go channels and goroutine concurrency","Eino core framework with streaming components"],"input_types":["Component outputs (text, structured data, embeddings)","Stream configuration (buffer sizes, timeout settings)"],"output_types":["Typed channels emitting progressive results","Token-by-token streaming data","Backpressure signals"],"categories":["automation-workflow","stream-processing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-cloudwego--eino__cap_10","uri":"capability://data.processing.analysis.workflow.field.mapping.and.data.transformation.between.nodes","name":"workflow field mapping and data transformation between nodes","description":"Eino's workflow system includes field mapping capabilities that transform data between nodes with different input/output schemas. The framework allows specifying how fields from one node's output map to the next node's input, supporting field renaming, nested field extraction, and type conversion. This enables connecting nodes with incompatible schemas without writing custom transformation code, with the framework handling the mapping logic automatically during graph execution.","intents":["I want to connect nodes with different field names without writing custom transformation code","I need to extract nested fields from complex output structures and pass them to downstream nodes","I want to transform data types (e.g., string to int) between nodes automatically"],"best_for":["Complex graphs with many nodes having incompatible schemas","Teams building reusable node libraries with different naming conventions","Systems integrating multiple external APIs with different response formats"],"limitations":["Field mapping configuration is verbose — complex transformations require detailed mapping specifications","No support for custom transformation functions — only field renaming and extraction are supported","Type conversion is limited — only basic type conversions are supported, complex transformations require custom code"],"requires":["Go 1.18+","Knowledge of node input/output schemas","Field mapping configuration","Eino core framework"],"input_types":["Node output data","Field mapping specifications","Target schema definitions"],"output_types":["Transformed data matching target schema","Mapping error reports"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-cloudwego--eino__cap_11","uri":"capability://planning.reasoning.branching.and.conditional.execution.in.graphs","name":"branching and conditional execution in graphs","description":"Eino supports conditional branching in graphs where execution paths diverge based on node output values or external conditions. The framework provides branching nodes that evaluate conditions and route execution to different downstream nodes, with support for multiple branches and merge points. Branches are defined as part of the graph topology, and the execution engine handles routing and state management for parallel or conditional execution paths.","intents":["I want to route execution to different nodes based on LLM output or tool results","I need to implement if-then-else logic in my AI workflows","I want to support multiple execution paths that converge at a later point"],"best_for":["Complex workflows with conditional logic (e.g., different handling for different query types)","Systems implementing approval workflows with different paths for approved/rejected items","Applications with fallback logic (try primary approach, fall back to alternative if it fails)"],"limitations":["Branching logic must be defined statically in the graph — dynamic branching based on runtime values is limited","Merge point semantics are unclear — when multiple branches converge, how are results combined?","No built-in support for loops — iterative execution requires explicit graph structure"],"requires":["Go 1.18+","Branching node definitions with condition logic","Graph topology supporting multiple paths","Eino core framework"],"input_types":["Node output values for condition evaluation","Branch configuration (conditions, target nodes)"],"output_types":["Execution path selection","Results from selected branch","Merged results from converging branches"],"categories":["planning-reasoning","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-cloudwego--eino__cap_12","uri":"capability://planning.reasoning.plan.execute.agent.pattern.for.structured.task.decomposition","name":"plan-execute agent pattern for structured task decomposition","description":"Eino provides a Plan-Execute agent implementation that decomposes complex tasks into structured plans before execution. The agent first generates a plan (sequence of steps), then executes each step using tools, with the framework managing the plan-execution loop and handling plan updates based on execution results. This pattern is useful for tasks requiring upfront planning before tool execution, reducing token costs compared to ReAct by batching reasoning into a planning phase.","intents":["I want to decompose complex tasks into structured plans before executing them","I need to reduce token costs by planning upfront rather than reasoning at each step","I want to implement workflows where the plan can be reviewed and modified before execution"],"best_for":["Complex tasks that benefit from upfront planning (research, content creation, analysis)","Cost-sensitive applications where reducing LLM calls is important","Systems requiring plan review and approval before execution"],"limitations":["Plans can become stale — if execution results differ from plan assumptions, the plan may no longer be valid","Plan quality depends on LLM capability — weak models may generate poor plans that waste execution steps","No built-in plan adaptation — if execution fails, the framework cannot automatically replan"],"requires":["Go 1.18+","ChatModel implementation","Tool definitions for execution","Eino ADK with Plan-Execute agent"],"input_types":["Task description or goal","Available tools","Execution context"],"output_types":["Generated plan (structured steps)","Execution results for each step","Final task completion status"],"categories":["planning-reasoning","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-cloudwego--eino__cap_13","uri":"capability://automation.workflow.configuration.and.options.system.with.middleware.style.composition","name":"configuration and options system with middleware-style composition","description":"Eino provides a flexible options system where components and agents accept functional option parameters that configure behavior without requiring large configuration objects. Options are composed middleware-style, allowing multiple options to be chained and applied in sequence. This pattern enables clean APIs where optional features are added without bloating constructor signatures, and options can be reused across different component types.","intents":["I want to configure components with optional features without large configuration objects","I need to compose multiple configuration options cleanly","I want to reuse configuration patterns across different component types"],"best_for":["Framework and library developers building extensible APIs","Teams wanting clean, composable configuration patterns","Systems with many optional features and configuration combinations"],"limitations":["Options are applied in order — if options conflict, the last one wins, which can be confusing","No validation of option combinations — incompatible options may not be caught until runtime","Debugging option application can be difficult — the order and interaction of options is not always obvious"],"requires":["Go 1.18+","Understanding of functional options pattern","Eino core framework"],"input_types":["Option function definitions","Component configuration state"],"output_types":["Configured component with applied options","Configuration state object"],"categories":["automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-cloudwego--eino__cap_2","uri":"capability://planning.reasoning.react.agent.pattern.implementation.with.tool.calling.and.reasoning.loops","name":"react agent pattern implementation with tool calling and reasoning loops","description":"Eino provides a built-in ReAct (Reasoning + Acting) agent implementation in the ADK that orchestrates reasoning steps with tool invocations in a loop until task completion. The agent maintains a message history, calls the LLM to generate reasoning and tool calls, executes tools via a ToolsNode, and feeds results back into the reasoning loop. The framework handles tool schema inference from Go function signatures, automatic tool selection based on LLM output, and interrupt points for human-in-the-loop validation of tool calls.","intents":["I want to build agents that reason about problems and call tools iteratively to solve them","I need automatic tool schema generation from my Go functions without manual JSON schema writing","I want to add human approval checkpoints before tools are executed in agent workflows"],"best_for":["Developers building autonomous agents with tool-calling capabilities","Teams implementing ReAct patterns for complex reasoning tasks","Applications requiring human-in-the-loop validation of agent actions"],"limitations":["ReAct loops can be expensive — each reasoning step calls the LLM, leading to high token costs for complex tasks","Tool schema inference from Go functions requires specific struct tags and type annotations — not all function signatures are automatically convertible","No built-in loop termination guarantees — agents can enter infinite loops if the LLM doesn't recognize task completion"],"requires":["Go 1.18+","ChatModel implementation (OpenAI, Anthropic, etc. via EinoExt)","Tool functions with proper type signatures and schema annotations","Eino ADK module"],"input_types":["User query or task description","Tool definitions (Go functions with schema metadata)","Chat history (optional)"],"output_types":["Final agent response","Tool call history with results","Reasoning trace"],"categories":["planning-reasoning","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-cloudwego--eino__cap_3","uri":"capability://automation.workflow.interrupt.and.resumption.system.for.human.in.the.loop.workflows","name":"interrupt and resumption system for human-in-the-loop workflows","description":"Eino provides a checkpoint and interrupt system that pauses graph execution at specified nodes, serializes the execution state, and allows external systems (like human reviewers) to inspect or modify state before resuming. Interrupts are defined at the node level, with the framework capturing the complete execution context including message history, tool call results, and intermediate computations. Upon resumption, the framework restores the serialized state and continues execution from the interrupt point without re-executing prior nodes.","intents":["I want to pause agent execution for human review of tool calls before they execute","I need to save and restore agent state across sessions for long-running workflows","I want to implement approval workflows where humans validate agent decisions mid-execution"],"best_for":["Applications requiring human oversight of AI agent actions (e.g., financial transactions, content moderation)","Long-running workflows that need to survive process restarts","Teams implementing approval-based automation systems"],"limitations":["Serialization overhead — checkpointing state adds latency and storage requirements, especially for large message histories","State restoration complexity — resuming from interrupts requires careful handling of external side effects (e.g., if a tool was partially executed)","No built-in conflict resolution — if state changes between interrupt and resumption, the framework cannot automatically reconcile"],"requires":["Go 1.18+","Serialization backend (JSON, Protocol Buffers, or custom)","State persistence layer (database, file system, or in-memory store)","Eino core framework with interrupt support"],"input_types":["Interrupt configuration (which nodes to interrupt at)","Serialized execution state","Human decisions or modifications to state"],"output_types":["Serialized checkpoint data","Resumed execution results","Audit trail of interrupts and resumptions"],"categories":["automation-workflow","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-cloudwego--eino__cap_4","uri":"capability://planning.reasoning.multi.agent.orchestration.with.supervisor.and.role.based.routing","name":"multi-agent orchestration with supervisor and role-based routing","description":"Eino's DeepAgent system enables multi-agent architectures where a supervisor agent routes tasks to specialized agents based on task type or content. The framework provides a MultiAgent Host that manages multiple agent instances, a Supervisor that makes routing decisions, and a message-passing protocol for inter-agent communication. Each agent can have its own tools, configuration, and reasoning patterns, with the supervisor coordinating the overall workflow and aggregating results from multiple agents.","intents":["I want to build systems with multiple specialized agents (e.g., one for research, one for writing, one for analysis)","I need a supervisor agent to route tasks to the right specialist based on task content","I want to parallelize work across multiple agents and aggregate their results"],"best_for":["Complex AI systems requiring domain-specific agents (e.g., customer support with specialized agents for billing, technical, sales)","Teams building scalable multi-agent systems with clear role separation","Applications where different tasks benefit from different LLM models or tool sets"],"limitations":["Supervisor routing decisions add latency — the supervisor must analyze each task before delegating, increasing total execution time","Coordination complexity — managing state across multiple agents requires careful synchronization and error handling","No built-in load balancing — if one agent is slow, it can block the entire workflow"],"requires":["Go 1.18+","Multiple ChatModel implementations or instances","Eino ADK with multi-agent support","Clear task routing logic or supervisor configuration"],"input_types":["User task or query","Agent definitions with roles and capabilities","Routing rules or supervisor configuration"],"output_types":["Aggregated results from multiple agents","Routing decisions and delegation history","Final synthesized response"],"categories":["planning-reasoning","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-cloudwego--eino__cap_5","uri":"capability://tool.use.integration.tool.schema.inference.and.automatic.function.binding","name":"tool schema inference and automatic function binding","description":"Eino automatically generates tool schemas from Go function signatures using reflection and struct tags, eliminating manual JSON schema writing. The framework inspects function parameters, return types, and documentation comments to build OpenAI-compatible tool schemas. Tools are registered in a schema registry that the LLM uses for function calling, and the ToolsNode automatically binds LLM tool calls to the correct Go functions, handling parameter marshaling and error propagation.","intents":["I want to expose my Go functions as LLM tools without writing JSON schemas by hand","I need automatic parameter validation and type conversion from LLM tool calls to Go function arguments","I want to keep my tool definitions in sync with my function implementations automatically"],"best_for":["Go developers building agents with many tools (schema generation saves significant effort)","Teams wanting to avoid manual JSON schema maintenance","Applications where tool definitions change frequently"],"limitations":["Schema inference only works for exported Go functions — private functions cannot be exposed as tools","Complex types (nested structs, custom types) require explicit schema annotations — inference cannot always determine the correct JSON representation","Documentation comments must follow specific conventions for schema descriptions — poorly formatted comments result in missing tool descriptions"],"requires":["Go 1.18+","Function signatures with clear parameter and return types","Optional struct tags for schema customization (e.g., `eino:\"description=...\")`","Eino tool system module"],"input_types":["Go function definitions","Struct tags with schema metadata","Documentation comments"],"output_types":["OpenAI-compatible tool schemas","Tool registry with function bindings","Parameter marshaling/unmarshaling logic"],"categories":["tool-use-integration","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-cloudwego--eino__cap_6","uri":"capability://automation.workflow.callback.and.aspect.system.for.cross.cutting.concerns","name":"callback and aspect system for cross-cutting concerns","description":"Eino provides a callback and aspect system that allows injecting custom logic at key execution points (node start/end, tool calls, agent steps) without modifying core component code. Callbacks are registered globally or per-component and receive execution context including input, output, and metadata. The framework supports multiple callback types (lifecycle, tool, agent) with a middleware-style chain that allows callbacks to observe, modify, or reject operations.","intents":["I want to log all LLM calls and tool executions for debugging and monitoring","I need to track token usage across my entire application for billing purposes","I want to implement custom validation or filtering of tool calls before execution"],"best_for":["Teams building production systems requiring comprehensive observability","Applications needing token usage tracking and cost monitoring","Systems implementing custom validation or security policies"],"limitations":["Callback overhead — every execution point triggers registered callbacks, adding latency proportional to callback count","Callback ordering is not guaranteed — if multiple callbacks modify state, the order of application may be unpredictable","Error handling in callbacks can be tricky — exceptions in callbacks may silently fail or crash the entire execution"],"requires":["Go 1.18+","Understanding of callback interfaces and execution context","Eino core framework with callback support"],"input_types":["Callback function definitions","Execution context (input, output, metadata)","Callback registration configuration"],"output_types":["Callback execution results","Modified execution context (if callbacks modify state)","Observability data (logs, metrics, traces)"],"categories":["automation-workflow","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-cloudwego--eino__cap_7","uri":"capability://text.generation.language.message.formatting.and.templating.with.variable.substitution","name":"message formatting and templating with variable substitution","description":"Eino provides a message templating system that formats prompts with variable substitution, supporting both simple string interpolation and structured message construction. Templates can include placeholders for dynamic content (user input, retrieved documents, tool results), with the framework handling escaping and type conversion. The system supports multiple message roles (user, assistant, system) and formats messages into the structure expected by different LLM providers.","intents":["I want to build dynamic prompts that insert user input, retrieved documents, or tool results into templates","I need to format messages for different LLM providers (OpenAI, Anthropic, etc.) without manual conversion","I want to reuse prompt templates across multiple agents with different variable values"],"best_for":["Developers building RAG systems that need to inject retrieved documents into prompts","Teams managing multiple prompt templates for different tasks","Applications supporting multiple LLM providers with different message formats"],"limitations":["Template syntax is limited — complex conditional logic requires custom code rather than template expressions","No built-in prompt optimization — templates must be manually tuned for quality","Variable escaping can be error-prone — special characters in user input may break template formatting if not handled carefully"],"requires":["Go 1.18+","Message template definitions","Variable values to substitute","Eino core framework"],"input_types":["Template strings with placeholders","Variable values (strings, structured data)","Message role specifications"],"output_types":["Formatted message strings","Structured message objects (for LLM APIs)","Multi-role message sequences"],"categories":["text-generation-language","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-cloudwego--eino__cap_8","uri":"capability://search.retrieval.retriever.and.indexer.abstraction.for.rag.integration","name":"retriever and indexer abstraction for rag integration","description":"Eino defines Retriever and Indexer interfaces that abstract document storage and retrieval, enabling integration with vector databases, full-text search, and hybrid retrieval systems. Retrievers accept queries and return ranked documents, while Indexers handle document ingestion and indexing. The framework provides a standard interface that allows swapping different backends (Elasticsearch, vector DBs, etc.) without changing application code. Concrete implementations are provided in EinoExt for popular backends.","intents":["I want to build RAG systems that retrieve relevant documents for LLM context","I need to switch between different vector databases or search backends without rewriting my application","I want to implement hybrid retrieval combining vector similarity and keyword search"],"best_for":["Teams building RAG applications with flexible backend requirements","Applications needing to migrate between vector databases","Systems implementing advanced retrieval strategies (hybrid, re-ranking, etc.)"],"limitations":["Abstraction overhead — the generic Retriever interface cannot express all backend-specific optimizations","Ranking and relevance tuning is backend-specific — no unified way to configure ranking across different retrievers","Batch retrieval semantics are not standardized — different backends may have different performance characteristics for batch queries"],"requires":["Go 1.18+","Document storage backend (Elasticsearch, vector DB, etc.)","Indexer implementation for your backend","Eino core framework with retriever interfaces"],"input_types":["Query strings or query objects","Documents for indexing","Retrieval configuration (top-k, filters, etc.)"],"output_types":["Ranked document results","Relevance scores","Document metadata"],"categories":["search-retrieval","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-cloudwego--eino__cap_9","uri":"capability://data.processing.analysis.embedding.model.abstraction.with.provider.agnostic.interface","name":"embedding model abstraction with provider-agnostic interface","description":"Eino provides an Embedding interface that abstracts text-to-vector conversion, allowing applications to use different embedding models (OpenAI, Ollama, local models) interchangeably. The interface accepts text inputs and returns dense vectors, with the framework handling provider-specific API calls and response parsing. Concrete implementations for popular providers are available in EinoExt, and the abstraction allows swapping embeddings without changing application code.","intents":["I want to use different embedding models (OpenAI, open-source, local) without changing my RAG code","I need to batch embed multiple texts efficiently","I want to switch embedding providers for cost optimization or latency reasons"],"best_for":["RAG applications that need flexible embedding model selection","Teams optimizing for cost or latency by switching embedding providers","Systems supporting multiple embedding models for different use cases"],"limitations":["Embedding dimensions vary across models — applications must handle variable vector sizes or normalize to a fixed dimension","Semantic similarity is not portable — vectors from different models are not comparable, so switching models requires re-embedding all documents","Batch embedding APIs differ across providers — the abstraction cannot fully hide provider-specific batching semantics"],"requires":["Go 1.18+","Embedding model API key or local model endpoint","Eino core framework with embedding interfaces","EinoExt implementations for your chosen provider"],"input_types":["Text strings to embed","Batch embedding requests"],"output_types":["Dense vectors (float arrays)","Embedding metadata (model name, dimensions)"],"categories":["data-processing-analysis","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":51,"verified":false,"data_access_risk":"high","permissions":["Go 1.18+ (generics support)","Understanding of Go interface{} and generic constraints","Eino core framework imported","Go 1.18+","Understanding of Go channels and goroutine concurrency","Eino core framework with streaming components","Knowledge of node input/output schemas","Field mapping configuration","Eino core framework","Branching node definitions with condition logic"],"failure_modes":["Go generics syntax is verbose compared to Python — graph definitions require explicit type parameters for each node","Type system cannot validate dynamic branching conditions at compile time — conditional routing still requires runtime checks","No IDE autocomplete for dynamically-constructed graphs — only works with statically-defined node chains","Channel-based architecture adds complexity to error handling — errors in one node can cascade through the channel pipeline","Streaming prevents certain optimizations like batch processing multiple requests together","Backpressure handling requires careful buffer sizing — undersized buffers cause blocking, oversized buffers consume memory","Field mapping configuration is verbose — complex transformations require detailed mapping specifications","No support for custom transformation functions — only field renaming and extraction are supported","Type conversion is limited — only basic type conversions are supported, complex transformations require custom code","Branching logic must be defined statically in the graph — dynamic branching based on runtime values is limited","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.6637083562178314,"quality":0.35,"ecosystem":0.6000000000000001,"match_graph":0.25,"freshness":0.75,"weights":{"adoption":0.3,"quality":0.2,"ecosystem":0.15,"match_graph":0.23,"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:58:24.502Z","last_commit":"2026-04-30T09:41:23Z"},"community":{"stars":11007,"forks":887,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=cloudwego--eino","compare_url":"https://unfragile.ai/compare?artifact=cloudwego--eino"}},"signature":"1CBcfjTgBlt00c3owPDAkO+AgCoLgMFzDLzDt9HxrhWZj5H43I5TC9DTTr5H5o0W49Gnoe77jONBvNl1cD0WDA==","signedAt":"2026-06-21T07:47:20.427Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/cloudwego--eino","artifact":"https://unfragile.ai/cloudwego--eino","verify":"https://unfragile.ai/api/v1/verify?slug=cloudwego--eino","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"}}