Getting Started

almyty turns any API into AI-ready tools and lets you build multi-LLM agent pipelines with a visual builder. Serve everything via MCP, A2A, UTCP, Agent Skills, or an OpenAI-compatible API.

The Pipeline

The core workflow follows four steps: API → Tools → Gateway → Agent.

1. Connect an API — point almyty at an OpenAPI, GraphQL, SOAP, Protobuf, or SDK schema
2. Generate tools — each operation becomes an executable tool with typed parameters
3. Create a gateway — expose your tools via MCP, A2A, UTCP, or Agent Skills
4. Build an agent — compose tools and LLM calls into a visual pipeline

Create an Account

Go to your almyty instance and click Sign up. Fill in your name, email, organization name, and a password. You’ll land on the dashboard immediately after registration.

Dashboard

The dashboard shows an onboarding checklist that walks you through each step of the pipeline. Click any step to jump directly to the relevant page.

Use ⌘K (or Ctrl+K) anywhere to open the command palette for quick navigation.

Connect Your First API

Navigate to APIs in the sidebar. Click Connect API to open the import dialog.

Provide a name, select the schema type, and paste your schema URL or content. Check Generate Tools to automatically create tools from each operation.

almyty supports:

• OpenAPI 3.x (JSON or YAML)
• GraphQL (introspection or SDL)
• SOAP (WSDL documents)
• Protobuf (.proto definitions)
• SDK (npm packages with discoverable exports)

Via the API:

curl -X POST /apis \
  -H "Content-Type: application/json" \
  -d '{
    "name": "My REST API",
    "type": "openapi",
    "baseUrl": "https://api.example.com/v1"
  }'

Generate Tools

Navigate to Tools to manage your tools. After importing an API schema with Generate Tools enabled, each operation automatically becomes a tool with typed parameters and validation.

You can also create custom tools manually:

Five execution methods are available: HTTP, JavaScript (sandboxed), GraphQL, LLM (prompt-based), and SDK.

Via the API:

curl -X POST /organizations/{orgId}/tools \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my_tool",
    "description": "Does something useful",
    "type": "function",
    "executionMethod": "http",
    "parameters": { "type": "object", "properties": {} }
  }'

Create a Gateway

Gateways expose your tools to AI agents via standardized protocols. Navigate to Gateways and click Create Gateway.

Choose a protocol:

After creating a gateway, open it to assign tools from the Tool Scoping tab and configure authentication.

Via the API:

curl -X POST /gateways \
  -H "Content-Type: application/json" \
  -d '{
    "name": "My MCP Gateway",
    "type": "mcp",
    "endpoint": "/my-gateway"
  }'

Build an Agent

Navigate to Agents and click Create Agent. The visual pipeline builder lets you compose agent workflows by dragging nodes onto a canvas.

Ten node types are available: input, output, llm_call, tool_call, condition, transform, loop, parallel, merge, and sub_agent. Connect them to define the execution flow.

For autonomous agents, switch to Autonomous mode to configure instructions, tool access, memory, and multi-agent collaboration without a pipeline graph.

Via the API:

curl -X POST /agents \
  -H "Content-Type: application/json" \
  -d '{
    "name": "My Agent",
    "description": "Answers questions using my API tools",
    "pipeline": { "nodes": [...], "edges": [...] }
  }'

Configure LLM Providers

Navigate to Models in the sidebar. Click Add Provider to connect an LLM.

almyty supports 14 providers: OpenAI, Anthropic, Google Gemini, Azure OpenAI, AWS Bedrock, Google Vertex, Mistral, Cohere, Groq, Together, Perplexity, DeepSeek, Ollama, and custom endpoints.

Manage Credentials

The Credentials page stores encrypted API keys, bearer tokens, and OAuth2 credentials. These are used by your APIs and tools for authenticated requests.

The Access Keys tab is where you generate API keys for CLI tools and programmatic access. Click Generate Key, pick a scope, and copy the key — it’s shown only once. Use it with Authorization: Bearer ak_live_... or let the CLI handle it via npx @almyty/auth login.

Analytics and Audit

The Analytics page shows real-time usage across all protocols. Seven tabs cover: Overview, Request Log, Tools, Gateways, LLM usage, Agents, and Audit Trail.

The audit trail records every sensitive action (create, update, delete, execute) with user, timestamp, resource, and IP.

Memory

Agents can store and recall facts, preferences, and context. Create memories manually or let agents auto-save key facts from conversations.

Keyboard Shortcuts

Press ? anywhere to see available shortcuts.

Connect to almyty via MCP

almyty is a remote MCP server. Any MCP-compatible client (Claude Code, Cursor, Windsurf, Copilot, Gemini CLI) can connect directly — no CLI install needed.

Connect the platform (manage almyty from your AI tools)

Add the almyty MCP endpoint to your client:

Claude Code:

claude mcp add almyty --url https://api.almyty.com/mcp

Cursor / Windsurf (.cursor/mcp.json):

{
  "mcpServers": {
    "almyty": {
      "url": "https://api.almyty.com/mcp"
    }
  }
}

This gives your AI assistant tools to manage almyty: create APIs, import schemas, generate tools, build agents, set up gateways.

Connect a specific gateway (use your API tools from your AI tools)

Each gateway has its own MCP endpoint. Find it on the gateway’s Integrations tab, or construct it as:

https://api.almyty.com/{org}/{gateway-slug}

Claude Code:

claude mcp add petstore --url https://api.almyty.com/acme/petstore

Discovery

MCP clients that support server discovery can find almyty at:

https://api.almyty.com/mcp/.well-known/mcp

Using the CLI proxy (optional, lower token overhead)

For skill-first mode (2 tools instead of N, ~300 tokens/turn instead of ~4,000):

npx @almyty/auth login
npx @almyty/mcp-server acme/petstore

Next Steps

• Tools — deep dive into each tool type
• Gateways — protocol-specific configuration
• Agents — pipeline builder, scheduling, webhooks
• API Reference — full HTTP API documentation
• CLI — command-line tools for automation