{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github-lastmile-ai--mcp-agent","slug":"lastmile-ai--mcp-agent","name":"mcp-agent","type":"mcp","url":"https://github.com/lastmile-ai/mcp-agent","page_url":"https://unfragile.ai/lastmile-ai--mcp-agent","categories":["mcp-servers","automation"],"tags":["agents","ai","ai-agents","llm","llms","mcp","model-context-protocol","python"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github-lastmile-ai--mcp-agent__cap_0","uri":"capability://tool.use.integration.multi.provider.llm.abstraction.with.unified.tool.calling.interface","name":"multi-provider llm abstraction with unified tool-calling interface","description":"Abstracts OpenAI, Anthropic, Azure OpenAI, AWS Bedrock, and Google AI behind a unified AugmentedLLM interface that normalizes tool-calling schemas, token tracking, and cost management across providers. Uses provider-specific adapters to translate between native function-calling formats (OpenAI's tools array, Anthropic's tool_use blocks) into a canonical internal representation, enabling seamless model swapping without workflow changes.","intents":["Switch between LLM providers without rewriting agent logic","Track token usage and costs across multiple provider APIs","Use provider-specific features (e.g., Anthropic's extended thinking) while maintaining portability","Build multi-model workflows that route tasks to optimal providers"],"best_for":["Teams building multi-provider agent systems to avoid vendor lock-in","Cost-conscious builders needing to optimize model selection per task","Enterprises with existing relationships across multiple LLM providers"],"limitations":["Provider-specific features (e.g., vision, structured output) require conditional logic in workflows","Token counting accuracy depends on provider's tokenizer; estimates may drift for edge cases","Rate limiting and quota management delegated to provider SDKs — no built-in circuit breaker"],"requires":["Python 3.9+","API keys for at least one provider (OpenAI, Anthropic, Azure, AWS, or Google)","mcp-agent package installed via pip"],"input_types":["text prompts","tool schemas (JSON)","conversation history (messages array)"],"output_types":["text responses","tool calls (structured JSON)","token usage metrics (input/output/total tokens, cost)"],"categories":["tool-use-integration","multi-provider-abstraction"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-lastmile-ai--mcp-agent__cap_1","uri":"capability://tool.use.integration.mcp.server.lifecycle.management.with.transport.abstraction","name":"mcp server lifecycle management with transport abstraction","description":"Manages the full lifecycle of Model Context Protocol servers (startup, connection, tool discovery, shutdown) across three transport mechanisms: STDIO, Server-Sent Events (SSE), and WebSocket. The MCPApp container automatically initializes MCP connections, discovers available tools/resources, and handles connection pooling and error recovery without requiring manual transport configuration in agent code.","intents":["Connect agents to local MCP servers via STDIO without managing subprocess lifecycle","Integrate remote MCP servers over HTTP/WebSocket for distributed tool access","Automatically discover and expose MCP tools to agents without manual schema definition","Handle MCP connection failures and reconnection logic transparently"],"best_for":["Developers building agents that need access to multiple MCP servers","Teams deploying MCP servers across different infrastructure (local, cloud, edge)","Organizations standardizing on MCP for tool integration across AI systems"],"limitations":["STDIO transport limited to local processes — no network isolation or multi-tenancy","SSE transport is unidirectional (server→client) — requires HTTP polling for client→server messages","WebSocket transport requires additional infrastructure (reverse proxy, TLS termination)","No built-in authentication/authorization for MCP server access — relies on network security"],"requires":["Python 3.9+","MCP servers compatible with stdio, sse, or websocket transports","For SSE/WebSocket: network connectivity to MCP server endpoints"],"input_types":["MCP server configuration (command, args, transport type)","Tool invocation requests (tool name, arguments)"],"output_types":["Tool results (JSON-serializable data)","Resource contents (text, binary)","Connection status and error messages"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-lastmile-ai--mcp-agent__cap_10","uri":"capability://tool.use.integration.mcp.server.creation.framework.with.tool.resource.definition","name":"mcp server creation framework with tool/resource definition","description":"Provides a framework for building MCP servers that expose tools and resources to agents. Developers define tools as Python functions with type hints, and the framework automatically generates MCP tool schemas and handles tool invocation. Supports both simple function-based tools and complex stateful tools with initialization. Resources can expose file contents, API responses, or other data to agents.","intents":["Build MCP servers that expose custom tools to agents","Define tools with type hints and automatic schema generation","Create stateful tools that maintain connection pools or caches","Expose resources (files, APIs) to agents via MCP protocol"],"best_for":["Developers building custom MCP servers for proprietary tools","Teams standardizing on MCP for tool integration","Organizations exposing internal APIs/services to agents"],"limitations":["Tool schema generation is limited to Python type hints — complex types may not translate well","No built-in authentication for MCP servers — requires custom implementation","Resource streaming is not supported — large resources must fit in memory","Tool invocation errors are not automatically retried — requires agent-level retry logic"],"requires":["Python 3.9+","mcp-agent package with server framework","Understanding of MCP protocol and tool schemas"],"input_types":["Python function definitions with type hints","Resource definitions"],"output_types":["MCP server binary/process","Tool schemas (JSON)","Tool execution results"],"categories":["tool-use-integration","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-lastmile-ai--mcp-agent__cap_11","uri":"capability://automation.workflow.workflow.composition.with.context.passing.and.state.management","name":"workflow composition with context passing and state management","description":"Enables workflows to pass context and state between agents through a shared execution context. Each workflow step can access outputs from previous steps, and agents can read/write to a shared state dictionary. The WorkflowExecutionSystem manages context isolation between concurrent workflows to prevent state leakage, using Python context variables to maintain execution context across async boundaries.","intents":["Pass results from one agent to the next in sequential workflows","Share state between agents working on the same task","Implement conditional logic based on previous agent outputs","Build workflows with feedback loops where agents refine previous results"],"best_for":["Teams building complex multi-step agent workflows","Developers implementing agent feedback loops and refinement","Systems where agents need to coordinate on shared state"],"limitations":["State management is in-memory — no persistence across application restarts","No built-in state versioning or rollback — requires external state store","Context passing is implicit — easy to accidentally reference wrong context in concurrent workflows","No conflict resolution for concurrent state updates — last write wins"],"requires":["Python 3.9+","Workflow definition with context passing","Understanding of workflow execution model"],"input_types":["Workflow definition with context references","Agent outputs"],"output_types":["Workflow execution context (dict)","Final workflow result"],"categories":["automation-workflow","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-lastmile-ai--mcp-agent__cap_12","uri":"capability://planning.reasoning.router.workflow.with.intent.based.agent.selection","name":"router workflow with intent-based agent selection","description":"Implements a Router workflow pattern that classifies incoming tasks by intent and routes them to specialized agents. Uses an LLM to classify the task intent, then selects the appropriate agent from a configured set based on the classification. Enables building systems where different agents handle different types of tasks (e.g., research agent, analysis agent, writing agent) without requiring explicit routing logic.","intents":["Route tasks to specialized agents based on task type/intent","Build multi-agent systems where each agent has a specific domain","Implement fallback routing when primary agent cannot handle task","Dynamically select agents based on task content without hardcoding routing logic"],"best_for":["Teams building multi-agent systems with specialized agents","Developers implementing task routing without explicit rules","Systems handling diverse task types that require different agents"],"limitations":["Intent classification is LLM-based — may misclassify edge cases","No built-in confidence scoring for classifications — all classifications are treated equally","Router adds latency for intent classification — not suitable for latency-critical systems","No fallback routing if selected agent fails — requires custom error handling"],"requires":["Python 3.9+","Multiple agents configured with different capabilities","LLM provider for intent classification"],"input_types":["Task/prompt text","Agent configurations"],"output_types":["Selected agent","Task execution result"],"categories":["planning-reasoning","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-lastmile-ai--mcp-agent__cap_13","uri":"capability://planning.reasoning.evaluator.optimizer.workflow.for.iterative.agent.refinement","name":"evaluator-optimizer workflow for iterative agent refinement","description":"Implements an Evaluator-Optimizer workflow pattern where an evaluator agent assesses the quality of a worker agent's output against specified criteria, and an optimizer agent refines the output based on evaluation feedback. Enables building self-improving agent systems that iteratively refine outputs until quality criteria are met, with configurable iteration limits and evaluation metrics.","intents":["Iteratively improve agent outputs through evaluation and refinement","Implement quality gates where outputs must meet specified criteria","Build self-improving agents that learn from evaluation feedback","Ensure agent outputs meet domain-specific quality standards"],"best_for":["Teams building high-quality content generation systems","Developers implementing quality assurance for agent outputs","Systems where output quality is critical (writing, code generation)"],"limitations":["Evaluator-Optimizer adds significant latency — multiple LLM calls per iteration","No built-in convergence detection — may iterate until max iterations without improvement","Evaluation criteria are LLM-based — subjective and may be inconsistent","No cost optimization — each iteration incurs full LLM costs"],"requires":["Python 3.9+","Worker agent, evaluator agent, and optimizer agent configured","Evaluation criteria defined"],"input_types":["Initial task/prompt","Evaluation criteria"],"output_types":["Refined agent output","Evaluation scores per iteration","Iteration history"],"categories":["planning-reasoning","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-lastmile-ai--mcp-agent__cap_2","uri":"capability://planning.reasoning.composable.workflow.execution.with.six.pattern.templates","name":"composable workflow execution with six pattern templates","description":"Provides six pre-built workflow patterns (Orchestrator, Deep Orchestrator, Parallel, Router, Evaluator-Optimizer, Swarm) that define how agents interact with tools and each other. Each pattern is implemented as a composable execution engine that handles agent sequencing, tool invocation, result aggregation, and error handling. Workflows are defined declaratively in YAML/Python and executed by the WorkflowExecutionSystem which manages state, context passing, and tool result routing.","intents":["Build sequential agent workflows where one agent's output feeds into the next","Execute multiple agents in parallel and aggregate their results","Route tasks to different agents based on content/intent classification","Implement self-improving workflows with evaluation and optimization loops","Coordinate swarms of agents working on sub-tasks of a larger problem"],"best_for":["Teams building complex multi-agent systems with defined interaction patterns","Developers who want pre-validated workflow patterns instead of building from scratch","Organizations needing reproducible, auditable agent execution flows"],"limitations":["Workflow patterns are opinionated — custom patterns require extending base classes","No built-in workflow versioning or rollback — requires external state management","Parallel workflow has no timeout per agent — long-running agents block entire workflow","Router pattern requires explicit intent classification logic — no built-in intent detection"],"requires":["Python 3.9+","At least one Agent configured with MCP server access","YAML or Python workflow definition"],"input_types":["Workflow definition (YAML or Python dict)","Initial task/prompt","Agent configurations"],"output_types":["Workflow execution results (structured JSON)","Agent interaction traces","Tool invocation logs"],"categories":["planning-reasoning","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-lastmile-ai--mcp-agent__cap_3","uri":"capability://automation.workflow.declarative.configuration.system.with.environment.variable.binding","name":"declarative configuration system with environment variable binding","description":"Provides a YAML-based configuration system (MCPApp) that declaratively defines agents, MCP servers, LLM providers, and workflows. Supports environment variable substitution, secret management via .env files, and schema validation against a JSON schema. Configuration is loaded at application startup and validated before any agents execute, catching configuration errors early without runtime failures.","intents":["Define agents, tools, and workflows in YAML without writing Python code","Manage different configurations for dev/staging/production environments","Inject secrets (API keys) via environment variables without hardcoding","Validate configuration schema before application startup","Share agent/workflow definitions across teams via version control"],"best_for":["Teams with non-technical stakeholders who need to modify agent behavior","Organizations deploying agents across multiple environments","Developers building agent platforms where end-users define workflows"],"limitations":["YAML configuration limited to declarative definitions — complex conditional logic requires Python","No built-in configuration hot-reloading — requires application restart to apply changes","Schema validation is static — cannot validate tool availability or MCP server connectivity at config time","Environment variable substitution is simple string replacement — no type coercion or validation"],"requires":["Python 3.9+",".env file or environment variables set for secrets","YAML configuration file following mcp-agent schema"],"input_types":["YAML configuration file","Environment variables",".env file"],"output_types":["Validated configuration object (Python dict)","Configuration validation errors"],"categories":["automation-workflow","configuration-management"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-lastmile-ai--mcp-agent__cap_4","uri":"capability://data.processing.analysis.token.tracking.and.cost.management.across.llm.calls","name":"token tracking and cost management across llm calls","description":"Automatically tracks input/output tokens and calculates costs for every LLM invocation across all providers (OpenAI, Anthropic, Azure, Bedrock, Google). Uses provider-specific pricing models and tokenizer implementations to compute per-call costs, aggregates costs across workflow execution, and exposes token metrics via the event system. Integrates with observability pipeline to enable cost analysis and budget monitoring.","intents":["Monitor total cost of agent workflows across multiple LLM providers","Identify expensive agents or tasks for optimization","Set cost budgets and alerts for production deployments","Compare cost-effectiveness of different models for the same task","Audit LLM usage for billing and compliance purposes"],"best_for":["Teams deploying agents in production with cost constraints","Organizations using multiple LLM providers and needing cost visibility","Developers optimizing agent performance for cost-efficiency"],"limitations":["Token counting is approximate — uses provider tokenizers which may differ from actual billing","Pricing models are static — requires code update when providers change prices","No built-in cost budgeting or enforcement — requires external monitoring system","Cost tracking adds ~5-10ms overhead per LLM call for token counting"],"requires":["Python 3.9+","Valid API keys for LLM providers","Access to provider pricing data (embedded in mcp-agent)"],"input_types":["LLM API responses with token counts"],"output_types":["Token usage metrics (input_tokens, output_tokens, total_tokens)","Cost per call (USD or other currency)","Aggregated cost per workflow execution"],"categories":["data-processing-analysis","monitoring-observability"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-lastmile-ai--mcp-agent__cap_5","uri":"capability://automation.workflow.event.driven.observability.and.tracing.system","name":"event-driven observability and tracing system","description":"Implements a comprehensive event system that emits structured events for every significant operation (agent execution, tool invocation, LLM calls, workflow transitions). Events are captured by pluggable exporters (file-based, OpenTelemetry) and can be analyzed via event analysis tools. Tracing is isolated per workflow execution to prevent cross-contamination in concurrent scenarios, using context variables to maintain execution context across async boundaries.","intents":["Debug agent behavior by inspecting detailed execution traces","Monitor agent performance and identify bottlenecks","Audit agent decisions and tool invocations for compliance","Integrate with external observability platforms (Datadog, New Relic, etc.)","Analyze agent behavior patterns across multiple executions"],"best_for":["Teams running agents in production requiring detailed observability","Developers debugging complex multi-agent workflows","Organizations with compliance requirements for AI system auditing"],"limitations":["Event emission adds ~2-5ms latency per operation","File-based exporter requires disk I/O — not suitable for high-throughput scenarios","OpenTelemetry exporter requires external collector infrastructure","Event schema is fixed — custom event types require framework extension"],"requires":["Python 3.9+","Optional: OpenTelemetry collector for distributed tracing","Optional: External observability platform (Datadog, New Relic, etc.)"],"input_types":["Workflow execution context","Agent/tool invocation data"],"output_types":["Structured event logs (JSON)","Execution traces (OpenTelemetry format)","Performance metrics (latency, token counts)"],"categories":["automation-workflow","monitoring-observability"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-lastmile-ai--mcp-agent__cap_6","uri":"capability://safety.moderation.agent.scoped.tool.access.control.with.permission.model","name":"agent-scoped tool access control with permission model","description":"Implements a permission model where each Agent is explicitly granted access to specific MCP servers and tools. The Agent class maintains a list of allowed servers, and tool invocation is gated by checking if the requested tool belongs to an allowed server. This enables fine-grained access control in multi-agent systems where different agents have different tool permissions, preventing unauthorized tool access.","intents":["Restrict agent access to sensitive tools (e.g., file deletion, external API calls)","Implement role-based access control where different agent roles have different tool permissions","Prevent agents from accessing tools outside their scope of responsibility","Audit which agents can access which tools for compliance purposes"],"best_for":["Organizations deploying agents with different trust levels","Teams building multi-tenant agent systems with isolation requirements","Developers implementing least-privilege access for agent tools"],"limitations":["Permission model is static — defined at agent creation time, not dynamically","No fine-grained permissions per tool (e.g., read-only vs read-write) — only server-level access","No audit logging of permission checks — requires external logging system","Permission enforcement is in-process — no isolation if agent code is compromised"],"requires":["Python 3.9+","Agent configuration with explicit server access list"],"input_types":["Agent configuration (server access list)","Tool invocation request (tool name, server)"],"output_types":["Tool execution result or permission denied error"],"categories":["safety-moderation","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-lastmile-ai--mcp-agent__cap_7","uri":"capability://data.processing.analysis.structured.output.generation.with.schema.based.validation","name":"structured output generation with schema-based validation","description":"Enables agents to generate structured outputs (JSON, Pydantic models) by providing a schema to the LLM and validating the response against that schema. Uses provider-specific structured output features (OpenAI's JSON mode, Anthropic's tool_use) when available, with fallback to post-processing validation. Automatically retries with corrected prompts if validation fails, up to a configurable number of attempts.","intents":["Extract structured data from unstructured text using LLMs","Generate valid JSON responses that downstream systems can parse","Ensure LLM outputs conform to expected data schemas","Build agents that produce machine-readable outputs for further processing"],"best_for":["Developers building data extraction pipelines with LLMs","Teams needing reliable structured outputs from agents","Systems integrating LLM outputs with downstream APIs or databases"],"limitations":["Schema validation adds latency — requires additional LLM call if validation fails","Retry logic is simple — no exponential backoff or circuit breaker","Schema complexity is limited — deeply nested schemas may confuse LLMs","Not all providers support native structured output — fallback validation may be unreliable"],"requires":["Python 3.9+","JSON schema or Pydantic model definition","LLM provider with structured output support (OpenAI, Anthropic recommended)"],"input_types":["JSON schema or Pydantic model","Prompt text"],"output_types":["Validated JSON object","Pydantic model instance"],"categories":["data-processing-analysis","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-lastmile-ai--mcp-agent__cap_8","uri":"capability://planning.reasoning.human.in.the.loop.integration.with.approval.gates","name":"human-in-the-loop integration with approval gates","description":"Provides a mechanism for agents to pause execution and request human approval before executing sensitive operations (e.g., deleting files, making external API calls). Agents can emit approval requests with context (what action, why, what are the consequences), and workflows pause until a human provides approval or rejection. Integrates with the event system to notify external systems (Slack, email) of pending approvals.","intents":["Require human approval before agents execute sensitive operations","Implement audit trails for high-stakes agent decisions","Build workflows that combine autonomous agent execution with human oversight","Enable non-technical users to control agent behavior via approval gates"],"best_for":["Organizations deploying agents in regulated industries (finance, healthcare)","Teams building agent systems with high-stakes decision points","Developers implementing audit trails for compliance"],"limitations":["Approval gates are synchronous — workflows block until human responds","No built-in timeout for pending approvals — requires external monitoring","Approval interface is not provided — requires custom UI/integration","No audit logging of approval decisions — requires external logging system"],"requires":["Python 3.9+","Custom approval interface (Slack bot, web UI, etc.)","Human availability to respond to approval requests"],"input_types":["Approval request (action, context, consequences)"],"output_types":["Approval decision (approved/rejected)","Human feedback/comments"],"categories":["planning-reasoning","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-lastmile-ai--mcp-agent__cap_9","uri":"capability://automation.workflow.async.first.execution.with.concurrent.agent.and.tool.invocation","name":"async-first execution with concurrent agent and tool invocation","description":"Built on Python's asyncio, mcp-agent enables concurrent execution of multiple agents and tools within a single workflow. The Parallel workflow pattern executes multiple agents concurrently and aggregates results, while individual tool invocations are non-blocking. Uses async context managers for resource management and ensures proper cleanup of MCP connections even if agents fail.","intents":["Execute multiple agents in parallel to reduce total workflow latency","Invoke multiple tools concurrently without blocking on individual tool responses","Build scalable agent systems that handle multiple concurrent requests","Implement timeout-based execution limits for long-running agents"],"best_for":["Teams building high-throughput agent systems","Developers optimizing agent latency with parallel execution","Systems handling multiple concurrent agent requests"],"limitations":["Async execution adds complexity — requires understanding of asyncio and context variables","No built-in timeout enforcement — long-running agents can block entire workflow","Concurrent tool invocation may hit rate limits on MCP servers","Debugging async workflows is harder than synchronous execution"],"requires":["Python 3.9+","Understanding of asyncio and async/await syntax","MCP servers that support concurrent connections"],"input_types":["Workflow definition with parallel agents","Tool invocation requests"],"output_types":["Aggregated results from parallel agents","Tool execution results"],"categories":["automation-workflow","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":48,"verified":false,"data_access_risk":"high","permissions":["Python 3.9+","API keys for at least one provider (OpenAI, Anthropic, Azure, AWS, or Google)","mcp-agent package installed via pip","MCP servers compatible with stdio, sse, or websocket transports","For SSE/WebSocket: network connectivity to MCP server endpoints","mcp-agent package with server framework","Understanding of MCP protocol and tool schemas","Workflow definition with context passing","Understanding of workflow execution model","Multiple agents configured with different capabilities"],"failure_modes":["Provider-specific features (e.g., vision, structured output) require conditional logic in workflows","Token counting accuracy depends on provider's tokenizer; estimates may drift for edge cases","Rate limiting and quota management delegated to provider SDKs — no built-in circuit breaker","STDIO transport limited to local processes — no network isolation or multi-tenancy","SSE transport is unidirectional (server→client) — requires HTTP polling for client→server messages","WebSocket transport requires additional infrastructure (reverse proxy, TLS termination)","No built-in authentication/authorization for MCP server access — relies on network security","Tool schema generation is limited to Python type hints — complex types may not translate well","No built-in authentication for MCP servers — requires custom implementation","Resource streaming is not supported — large resources must fit in memory","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.6417922305559907,"quality":0.35,"ecosystem":0.7000000000000001,"match_graph":0.25,"freshness":0.6,"weights":{"adoption":0.25,"quality":0.25,"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.550Z","last_scraped_at":"2026-05-03T13:56:59.048Z","last_commit":"2026-01-25T16:35:16Z"},"community":{"stars":8305,"forks":834,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=lastmile-ai--mcp-agent","compare_url":"https://unfragile.ai/compare?artifact=lastmile-ai--mcp-agent"}},"signature":"hyjohfxuEaw8Z9GO7WJdYeEyeS9GZ/4jRGiBGM20wYV2zwvbTRTGSl0zIZud2SvLTznMkSUQc88WNr7Nm6sPBA==","signedAt":"2026-06-20T17:44:17.407Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/lastmile-ai--mcp-agent","artifact":"https://unfragile.ai/lastmile-ai--mcp-agent","verify":"https://unfragile.ai/api/v1/verify?slug=lastmile-ai--mcp-agent","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"}}