{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"npm-agentdb","slug":"agentdb","name":"agentdb","type":"repo","url":"https://agentdb.ruv.io","page_url":"https://unfragile.ai/agentdb","categories":["rag-knowledge"],"tags":["agentdb","vector-database","ai-agents","memory","causal-reasoning","reflexion","episodic-memory","skill-library","lifelong-learning","explainable-ai","provenance","hnsw","embeddings","sqlite","sql.js","wasm"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"npm-agentdb__cap_0","uri":"capability://memory.knowledge.semantic.vector.storage.with.rvf.native.format","name":"semantic-vector-storage-with-rvf-native-format","description":"Stores and indexes embeddings using a proprietary RVF (RuVector Format) native binary format optimized for agentic workloads, with HNSW (Hierarchical Navigable Small World) graph indexing for approximate nearest neighbor search. The format is designed for rapid serialization/deserialization and supports sparse vector representations, enabling 150x faster retrieval than SQLite while maintaining ACID compliance through write-ahead logging and copy-on-write branching semantics.","intents":["Store and retrieve embeddings for RAG systems without external vector DB overhead","Build semantic search over agent memory with sub-millisecond latency","Maintain vector index consistency across agent state snapshots and rollbacks","Query embeddings using both exact and approximate nearest neighbor search"],"best_for":["AI agent developers building memory-intensive systems with strict latency requirements","Teams deploying agentic systems where external vector DB dependencies are undesirable","Researchers prototyping multi-agent systems with episodic memory patterns"],"limitations":["RVF format is proprietary — limited ecosystem tooling compared to standard vector formats","HNSW indexing adds memory overhead (~10-20% of raw vector data) for graph structure","Sparse vector support requires explicit schema declaration; dense vectors are default","No built-in sharding — single-instance deployment limits horizontal scaling"],"requires":["Node.js 16+ or browser with WebAssembly support","Embeddings pre-computed from external model (OpenAI, Anthropic, local) or via RuVector","Sufficient RAM for HNSW graph structure (typically 2-3x raw embedding size)"],"input_types":["float32 arrays (dense vectors)","sparse vector representations (index-value pairs)","JSON metadata attached to vectors","text (for semantic routing via embeddings)"],"output_types":["nearest neighbor results with similarity scores","vector metadata and provenance information","graph traversal paths for explainability","batch query results with ranking"],"categories":["memory-knowledge","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm-agentdb__cap_1","uri":"capability://search.retrieval.graph.database.queries.with.cypher.syntax","name":"graph-database-queries-with-cypher-syntax","description":"Exposes a RuVector-powered graph database layer supporting Cypher query language for traversing relationships between agent memories, skills, and causal chains. Queries are compiled to optimized graph traversal operations over the underlying HNSW structure, enabling pattern matching, path finding, and relationship filtering without requiring separate graph DB infrastructure. Results include provenance chains showing how conclusions were derived.","intents":["Query causal relationships between agent decisions and observations","Find skill chains and dependencies for task decomposition","Traverse episodic memory networks to retrieve contextually similar past experiences","Analyze agent reasoning paths for explainability and debugging"],"best_for":["AI agent developers building explainable reasoning systems","Teams implementing causal reasoning or reflexion patterns in agents","Researchers studying agent behavior through memory graph analysis"],"limitations":["Cypher support is subset of Neo4j standard — some advanced features (transactions, subqueries) may be missing","Graph traversal performance degrades with very large relationship sets (>1M edges per node)","No built-in graph visualization — requires external tools for exploration","Query optimization is heuristic-based; complex multi-hop queries may require manual tuning"],"requires":["Cypher query syntax knowledge or query builder abstraction","Graph schema definition mapping agent entities to nodes/relationships","AgentDB instance with graph indexing enabled"],"input_types":["Cypher query strings","node/relationship definitions (JSON schema)","traversal parameters (depth limits, filters)"],"output_types":["matched node/relationship sets","path results with edge weights","aggregation results (counts, statistics)","provenance chains with reasoning steps"],"categories":["search-retrieval","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm-agentdb__cap_10","uri":"capability://memory.knowledge.lifelong.learning.with.memory.consolidation","name":"lifelong-learning-with-memory-consolidation","description":"Implements automated memory consolidation processes that move episodic memories (specific experiences) to semantic memory (general knowledge) as they become stable and frequently accessed. Consolidation uses clustering and abstraction to extract generalizable patterns from episodic traces, creating reusable knowledge that reduces future query latency. Procedural memory (skills) is similarly consolidated from repeated successful task executions, creating learned routines that can be invoked directly without re-reasoning.","intents":["Automatically extract generalizable knowledge from agent's experiences","Consolidate learned skills from repeated successful task executions","Reduce memory footprint by replacing many episodic traces with single semantic fact","Enable continual learning where agents improve performance over time"],"best_for":["Long-running agents that benefit from accumulated experience","Systems where memory efficiency is critical (edge devices, browsers)","Agents implementing continual or lifelong learning paradigms"],"limitations":["Consolidation is lossy — specific details are abstracted away","No automatic consolidation schedule — requires manual triggers or heuristics","Consolidation can fail if clustering/abstraction is poorly tuned","Consolidated knowledge may become stale if environment changes significantly"],"requires":["Sufficient episodic memory history for consolidation (typically 50+ similar experiences)","Clustering algorithm for grouping similar experiences","Abstraction rules for extracting generalizable patterns"],"input_types":["episodic memory traces (timestamped experiences)","task execution logs (actions, outcomes)","consolidation triggers (time-based, frequency-based, manual)"],"output_types":["consolidated semantic facts with confidence scores","learned skills with applicability conditions","consolidation reports showing what was learned"],"categories":["memory-knowledge","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm-agentdb__cap_11","uri":"capability://planning.reasoning.skill.library.with.dependency.graphs","name":"skill-library-with-dependency-graphs","description":"Maintains a structured library of learned skills with explicit dependency graphs showing prerequisites and composition relationships. Skills are stored as procedural memories with parameters, success conditions, and applicability heuristics. The dependency graph enables skill composition — complex tasks are decomposed into learned skills, with the system automatically checking prerequisites and sequencing execution. Skills can be shared across agents and versioned for reproducibility.","intents":["Build reusable skill libraries that agents can compose for complex tasks","Automatically decompose tasks into learned skills with dependency checking","Share skills across multiple agents without code duplication","Version and rollback skills for reproducibility and debugging"],"best_for":["Multi-agent systems where skill sharing reduces development effort","Agents implementing hierarchical task decomposition","Teams building skill libraries for specific domains"],"limitations":["Skill dependencies must be explicitly defined — no automatic dependency detection","Skill composition adds latency for dependency checking and sequencing","No automatic skill optimization — composed skills may be less efficient than monolithic implementations","Skill versioning requires manual management — no automatic version resolution"],"requires":["Skill definitions with parameters and success conditions","Dependency graph specification","Skill execution environment (code interpreter, API calls, etc.)"],"input_types":["skill definitions (code, parameters, preconditions)","dependency specifications","task decomposition requests"],"output_types":["skill recommendations for tasks","execution plans with skill sequences","skill composition results"],"categories":["planning-reasoning","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm-agentdb__cap_12","uri":"capability://planning.reasoning.reflexion.pattern.for.agent.self.improvement","name":"reflexion-pattern-for-agent-self-improvement","description":"Implements the Reflexion pattern where agents evaluate their own outputs, identify failures or suboptimal decisions, and update their reasoning strategies accordingly. Failed trajectories are stored with analysis of what went wrong, creating a feedback loop for self-improvement. The system tracks which reasoning patterns lead to success vs failure, gradually improving decision quality without external supervision. Reflexion operates on causal chains, enabling agents to identify specific reasoning steps that caused failures.","intents":["Enable agents to learn from their own failures without external feedback","Improve agent reasoning quality over time through self-reflection","Identify and correct systematic reasoning errors","Build agents that can adapt to new domains through self-evaluation"],"best_for":["Agents operating in domains with clear success/failure signals","Systems where external feedback is unavailable or expensive","Teams building self-improving agents"],"limitations":["Reflexion requires clear success/failure signals — ambiguous outcomes reduce effectiveness","Self-evaluation can be biased — agents may rationalize failures rather than correct them","Learning from failures is slower than supervised learning","Reflexion can lead to local optima if feedback signals are noisy"],"requires":["Success/failure evaluation mechanism","Causal chain tracking for identifying failure points","Strategy update mechanism (prompt engineering, weight adjustment, etc.)"],"input_types":["agent outputs and trajectories","success/failure evaluations","failure analysis requests"],"output_types":["failure analysis with identified error points","updated reasoning strategies","improvement metrics tracking learning progress"],"categories":["planning-reasoning","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm-agentdb__cap_2","uri":"capability://memory.knowledge.six.cognitive.memory.pattern.implementation","name":"six-cognitive-memory-pattern-implementation","description":"Implements six distinct memory patterns for agents: episodic (timestamped experiences), semantic (facts and concepts), procedural (skills and routines), working (active context), long-term (consolidated knowledge), and causal (decision chains). Each pattern uses specialized indexing and retrieval strategies — episodic uses temporal ordering, semantic uses embedding similarity, procedural uses skill graphs, causal uses provenance chains. Patterns are composable, allowing agents to query across memory types with unified interface.","intents":["Build agents with human-like memory architecture supporting different knowledge types","Retrieve relevant past experiences (episodic) for in-context learning","Access factual knowledge (semantic) and learned skills (procedural) for task execution","Maintain causal chains for explainable decision-making and debugging"],"best_for":["AI agent developers implementing lifelong learning or continual learning systems","Teams building agents that need to explain their reasoning with full provenance","Researchers studying cognitive architectures and memory consolidation in AI"],"limitations":["Memory consolidation (moving episodic to semantic) requires manual triggers or heuristics — no automatic scheduling","Working memory size is bounded by context window; overflow handling is application-specific","Cross-pattern queries add latency — each memory type has separate index traversal","No built-in forgetting/pruning — requires explicit cleanup policies to prevent unbounded growth"],"requires":["Clear schema mapping agent observations/actions to memory patterns","Timestamps for episodic memories and causal chain ordering","Embeddings for semantic memory similarity matching","Skill definitions and dependency graphs for procedural memory"],"input_types":["observations (text, structured data) for episodic storage","facts/concepts (text, embeddings) for semantic storage","skill definitions (code, parameters) for procedural storage","decision records (actions, outcomes) for causal chains"],"output_types":["retrieved memories with relevance scores","skill recommendations with applicability scores","causal chains with confidence/uncertainty estimates","consolidated knowledge summaries"],"categories":["memory-knowledge","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm-agentdb__cap_3","uri":"capability://planning.reasoning.semantic.routing.with.learned.gnn.optimization","name":"semantic-routing-with-learned-gnn-optimization","description":"Routes incoming queries and observations to appropriate memory patterns and retrieval strategies using a self-learning Graph Neural Network (GNN) that observes which memory patterns produce useful results. The GNN learns routing weights over time, optimizing which memory type (episodic, semantic, procedural, causal) to query first based on query characteristics and historical success rates. Routing decisions are cached and updated asynchronously, reducing latency for repeated query patterns.","intents":["Automatically optimize memory access patterns based on agent's historical query success","Route complex queries to most relevant memory patterns without explicit user configuration","Reduce latency by learning which memory types answer similar queries fastest","Adapt routing strategy as agent's knowledge base evolves"],"best_for":["Long-running agents that benefit from learned optimization over time","Systems where query patterns are unpredictable or domain-specific","Teams building agents that need to self-optimize memory access without manual tuning"],"limitations":["GNN training requires sufficient query history — cold-start agents use heuristic routing","Routing decisions are probabilistic; edge cases may route to suboptimal patterns","No explicit control over routing weights — difficult to debug or enforce specific routing policies","GNN updates add background compute overhead; may impact latency-sensitive deployments"],"requires":["Sufficient query volume to train GNN (typically 100+ queries per pattern)","Feedback mechanism to measure retrieval quality (relevance scores, user feedback)","Background compute resources for async GNN updates"],"input_types":["query text or embeddings","query metadata (type, domain, urgency)","historical retrieval feedback (relevance scores)"],"output_types":["routing decision with confidence score","list of candidate memory patterns ranked by predicted utility","routing explanation (which features influenced decision)"],"categories":["planning-reasoning","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm-agentdb__cap_4","uri":"capability://automation.workflow.copy.on.write.branching.with.snapshot.isolation","name":"copy-on-write-branching-with-snapshot-isolation","description":"Implements COW (Copy-on-Write) branching semantics for agent state, allowing agents to fork memory snapshots, explore alternative reasoning paths, and merge results without copying entire database. Each branch maintains isolated view of memory with lazy copying — only modified pages are copied, reducing memory overhead. Snapshot isolation ensures branches see consistent state at fork time, enabling safe parallel exploration and rollback to previous states without affecting other branches.","intents":["Explore multiple reasoning paths in parallel without memory duplication","Implement backtracking and alternative hypothesis testing in agents","Create agent checkpoints for recovery and debugging","Merge results from parallel branches with conflict resolution"],"best_for":["Agents implementing tree-search or multi-hypothesis reasoning","Systems requiring agent state snapshots for debugging or recovery","Teams building collaborative multi-agent systems with branching coordination"],"limitations":["Merge conflicts require application-level resolution logic — no automatic conflict resolution","COW overhead increases with branch depth and modification frequency","Snapshot isolation adds memory overhead for maintaining version chains","No distributed branching — branches must exist on same instance"],"requires":["Explicit branch creation/merge API calls","Conflict resolution strategy for overlapping modifications","Sufficient RAM for maintaining multiple branch versions"],"input_types":["branch identifiers","modification operations (inserts, updates, deletes)","merge strategies (last-write-wins, custom resolvers)"],"output_types":["branch snapshots with isolated state","merge results with conflict markers","branch lineage/history for debugging"],"categories":["automation-workflow","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm-agentdb__cap_5","uri":"capability://automation.workflow.acid.persistence.with.write.ahead.logging","name":"acid-persistence-with-write-ahead-logging","description":"Provides ACID (Atomicity, Consistency, Isolation, Durability) guarantees for agent memory using write-ahead logging (WAL) and transactional semantics. All modifications are logged before application, enabling recovery from crashes and ensuring no data loss. Transactions can span multiple memory patterns (episodic, semantic, causal) with isolation levels preventing dirty reads and phantom updates. Durability is configurable — synchronous for critical operations, asynchronous for performance.","intents":["Ensure agent memory survives crashes without data loss","Maintain consistency across multi-pattern memory updates","Implement transactional skill learning and memory consolidation","Provide audit trail of all memory modifications for compliance/debugging"],"best_for":["Production agents where data loss is unacceptable","Systems with regulatory requirements for audit trails","Long-running agents that need crash recovery"],"limitations":["WAL adds write latency — synchronous mode can impact throughput","Transaction isolation adds memory overhead for maintaining version chains","No distributed transactions — ACID guarantees only within single instance","Log compaction requires periodic maintenance to prevent unbounded growth"],"requires":["Persistent storage (filesystem or cloud storage) for WAL","Sufficient disk space for transaction logs (typically 10-20% of data size)","Explicit transaction boundaries in agent code"],"input_types":["memory operations (inserts, updates, deletes)","transaction boundaries (begin, commit, rollback)","isolation level specifications"],"output_types":["transaction confirmation with LSN (log sequence number)","recovery status after crash","audit log entries with timestamps and operation details"],"categories":["automation-workflow","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm-agentdb__cap_6","uri":"capability://data.processing.analysis.sparse.and.partial.vector.indexing","name":"sparse-and-partial-vector-indexing","description":"Supports both dense and sparse vector representations with specialized indexing strategies for each. Sparse vectors (common in NLP and recommendation systems) are indexed using inverted indices rather than HNSW, reducing memory overhead by 50-90%. Partial indexing allows selective indexing of vector subsets based on metadata filters, enabling efficient queries over filtered datasets without materializing full index. Hybrid queries combine sparse and dense results with learned fusion weights.","intents":["Index high-dimensional sparse vectors (TF-IDF, one-hot encodings) efficiently","Query only relevant vector subsets using metadata filters without full index scan","Combine sparse and dense vector results for hybrid search","Reduce memory footprint for large-scale agent memory systems"],"best_for":["Agents working with sparse representations (bag-of-words, explicit features)","Systems with large memory where selective indexing reduces overhead","Hybrid search scenarios combining keyword and semantic matching"],"limitations":["Sparse indexing requires explicit sparsity pattern — dense vectors cannot be automatically sparsified","Partial indexing adds metadata filtering overhead — queries with complex filters may be slower","Hybrid fusion weights require tuning — no automatic optimization","Sparse vector updates are slower than dense (inverted index maintenance)"],"requires":["Explicit sparse vector format (COO, CSR, or index-value pairs)","Metadata schema for partial indexing filters","Fusion strategy for combining sparse/dense results"],"input_types":["dense float32 vectors","sparse vectors (index-value pairs or CSR format)","metadata for filtering (tags, timestamps, categories)","fusion weights or strategies"],"output_types":["sparse vector search results with similarity scores","dense vector results","fused results combining both with ranking"],"categories":["data-processing-analysis","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm-agentdb__cap_7","uri":"capability://planning.reasoning.self.learning.gnn.for.memory.optimization","name":"self-learning-gnn-for-memory-optimization","description":"Trains a Graph Neural Network on agent's memory access patterns to learn which memory structures and retrieval strategies are most effective. The GNN observes query types, memory patterns accessed, and retrieval quality, then optimizes index structures and caching strategies accordingly. Learning is continuous and asynchronous — the system adapts to changing query patterns without requiring manual tuning or downtime.","intents":["Automatically optimize memory access patterns based on agent's actual usage","Learn which memory patterns are most useful for different query types","Adapt index structures and caching to evolving knowledge base","Reduce latency through learned prefetching and index reorganization"],"best_for":["Long-running agents with stable or slowly-changing query patterns","Systems where manual tuning is impractical or domain-specific","Teams building self-optimizing agent infrastructure"],"limitations":["GNN training requires sufficient query history — cold-start systems use defaults","Learning is heuristic-based — no guarantees of optimality","Background training adds compute overhead; may impact latency-sensitive workloads","Learned optimizations are opaque — difficult to debug or understand why specific choices were made"],"requires":["Query telemetry collection (types, patterns, success metrics)","Background compute resources for async GNN training","Feedback mechanism for measuring retrieval quality"],"input_types":["query logs with metadata (type, pattern, latency)","retrieval quality metrics (relevance, user feedback)","memory structure information (sizes, access patterns)"],"output_types":["optimized index configurations","caching strategies with learned weights","prefetch predictions for common query patterns","memory reorganization recommendations"],"categories":["planning-reasoning","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm-agentdb__cap_8","uri":"capability://safety.moderation.explainable.ai.with.provenance.chains","name":"explainable-ai-with-provenance-chains","description":"Tracks full provenance of agent decisions and retrieved memories through causal chains showing how conclusions were derived. Each memory retrieval, reasoning step, and decision is linked to source observations and intermediate inferences, creating an auditable chain from raw input to final output. Provenance chains support multiple explanation types: causal (why was this decision made), counterfactual (what if different input), and contrastive (why this over alternatives).","intents":["Explain agent decisions with full causal chains from observations to conclusions","Debug agent behavior by tracing which memories and reasoning steps led to errors","Generate counterfactual explanations showing how different inputs would change decisions","Provide audit trails for compliance and trust verification"],"best_for":["High-stakes applications (medical, legal, financial) requiring explainability","Teams debugging complex agent behavior","Researchers studying agent reasoning and decision-making"],"limitations":["Provenance tracking adds memory overhead (~20-30% per decision)","Explanation generation is post-hoc — cannot guarantee explanations match actual reasoning","Counterfactual explanations require rerunning agent with modified inputs","Provenance chains can be very long for complex reasoning — summarization required for readability"],"requires":["Explicit tracking of memory accesses and reasoning steps","Causal relationship definitions between observations and decisions","Storage for provenance chains (typically 2-3x decision size)"],"input_types":["agent decisions and outputs","memory accesses and retrieval results","reasoning steps and intermediate inferences","explanation type requests (causal, counterfactual, contrastive)"],"output_types":["provenance chains with linked steps","causal explanations with confidence scores","counterfactual scenarios with predicted outcomes","contrastive explanations comparing alternatives"],"categories":["safety-moderation","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm-agentdb__cap_9","uri":"capability://automation.workflow.wasm.based.local.execution.with.sql.js.fallback","name":"wasm-based-local-execution-with-sql-js-fallback","description":"Executes AgentDB in browser or Node.js using WebAssembly (WASM) for performance-critical operations (HNSW indexing, GNN inference), with SQL.js fallback for environments without WASM support. WASM modules are pre-compiled and bundled, enabling instant startup without build steps. SQL.js provides SQLite-compatible interface for queries, allowing agents to run entirely client-side without server dependency. Data is persisted to IndexedDB (browser) or filesystem (Node.js).","intents":["Run agent memory systems entirely client-side without external services","Deploy agents to browsers with full vector search and graph query capabilities","Reduce latency by eliminating network round-trips to remote database","Maintain data privacy by keeping all agent memory local"],"best_for":["Browser-based agents and AI applications","Edge deployments where external services are unavailable","Privacy-sensitive applications requiring local data storage","Developers prototyping agents without infrastructure setup"],"limitations":["WASM performance is 2-5x slower than native C++ for compute-intensive operations","Browser storage is limited (typically 50MB-1GB depending on browser) — large agent memories may not fit","SQL.js is slower than native SQLite — complex queries may timeout","No built-in sync between browser and server — requires application-level replication"],"requires":["Browser with WebAssembly support (all modern browsers) or Node.js 14+","Sufficient storage quota (IndexedDB for browser, filesystem for Node.js)","Fallback to SQL.js for environments without WASM"],"input_types":["agent code (JavaScript/TypeScript)","embeddings and vectors","memory operations"],"output_types":["query results from WASM or SQL.js backend","persisted state in IndexedDB or filesystem"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":39,"verified":false,"data_access_risk":"high","permissions":["Node.js 16+ or browser with WebAssembly support","Embeddings pre-computed from external model (OpenAI, Anthropic, local) or via RuVector","Sufficient RAM for HNSW graph structure (typically 2-3x raw embedding size)","Cypher query syntax knowledge or query builder abstraction","Graph schema definition mapping agent entities to nodes/relationships","AgentDB instance with graph indexing enabled","Sufficient episodic memory history for consolidation (typically 50+ similar experiences)","Clustering algorithm for grouping similar experiences","Abstraction rules for extracting generalizable patterns","Skill definitions with parameters and success conditions"],"failure_modes":["RVF format is proprietary — limited ecosystem tooling compared to standard vector formats","HNSW indexing adds memory overhead (~10-20% of raw vector data) for graph structure","Sparse vector support requires explicit schema declaration; dense vectors are default","No built-in sharding — single-instance deployment limits horizontal scaling","Cypher support is subset of Neo4j standard — some advanced features (transactions, subqueries) may be missing","Graph traversal performance degrades with very large relationship sets (>1M edges per node)","No built-in graph visualization — requires external tools for exploration","Query optimization is heuristic-based; complex multi-hop queries may require manual tuning","Consolidation is lossy — specific details are abstracted away","No automatic consolidation schedule — requires manual triggers or heuristics","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.3179718353664835,"quality":0.5,"ecosystem":0.6000000000000001,"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-05-24T12:16:23.328Z","last_scraped_at":"2026-04-22T08:08:13.652Z","last_commit":null},"community":{"stars":null,"forks":null,"weekly_downloads":75629,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=agentdb","compare_url":"https://unfragile.ai/compare?artifact=agentdb"}},"signature":"VIndW/1YbQqcrhr1ZvhTG4QrCbx3enQwHeAObLKbaKLVYhdQ+L8jpKPm0Q0uqCto8xoxyT2w2W5yWxmlsxxgCg==","signedAt":"2026-06-22T02:19:56.849Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/agentdb","artifact":"https://unfragile.ai/agentdb","verify":"https://unfragile.ai/api/v1/verify?slug=agentdb","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"}}