Skip to content

AI Tooling Landscape — 2026 Overview

What it is

The AI Tooling Landscape is a comprehensive architectural map of the generative AI ecosystem. It categorizes the diverse range of technologies—from physical hardware and foundational models to agentic frameworks and end-user applications—into a structured 8-layer stack.

What problem it solves

The rapid expansion of AI has created a fragmented and overwhelming market of tools. This landscape provides a mental model and a "standard map" to help developers, architects, and hobbyists understand where a specific tool (like Ollama or LangGraph) fits, what its dependencies are, and what alternatives exist at the same layer.

Where it fits in the stack

This document serves as the Layer 0-7 Meta-Layer. It is the primary entry point for the entire docs/knowledge_base/ section, providing the context needed to navigate specialized deep-dives into models, frameworks, and infrastructure.

Typical use cases

  • Stack Design: Deciding which components to use when building a new AI-powered home automation service.
  • Onboarding: Helping new contributors understand the repository's taxonomy and how different tools interoperate.
  • Gap Analysis: Identifying missing layers in a personal homelab setup (e.g., realizing you have models but no orchestration layer).
  • Technology Scouting: Finding alternatives for a specific tool by looking at other entries in the same layer.

Strengths

  • Comprehensive: Covers the entire lifecycle from raw compute to finished application.
  • Interoperable: Focuses on the "glue" (protocols like MCP) that connects layers.
  • Homelab-Centric: Prioritizes tools that can be run locally or self-hosted.

Limitations

  • High Velocity: The AI field moves so fast that specific tool placements may become outdated within months.
  • Agnostic: It provides the map but doesn't mandate a single "golden path" for every user.
  • Abstract: Focuses on categories rather than exhaustive lists of every minor tool.

When to use it

  • Use it when you are starting a new AI project and need to understand the architectural requirements.
  • Use it to find where a new tool you've discovered fits in the broader ecosystem.
  • Use it to explain AI architecture to others using a standardized 8-layer model.

When not to use it

  • Do not use it as a real-time price list for API providers (see API Pricing & Free Tiers).
  • Do not use it for step-by-step installation instructions (see Playbooks).

Getting started

  1. Start by reviewing The Stack (layered view) below to identify which layer you are currently interested in.
  2. Click on the Relevant Pages links within each layer to explore specific tools.
  3. Consult the Key Patterns section to understand how these layers are typically connected in production.
  4. For a hands-on start, see the How to use this repo section at the bottom.

The Stack (layered view)

┌───────────────────────────────────────────────────────────────────────────┐
│ Layer 7: Applications (ChatGPT, Perplexity, Open WebUI)                   │
├───────────────────────────────────────────────────────────────────────────┤
│ Layer 6: Agents & Orchestration (CrewAI, AutoGen, LangGraph, n8n)         │
├───────────────────────────────────────────────────────────────────────────┤
│ Layer 5: Frameworks (LangChain, LlamaIndex, Haystack, DSPy)               │
├───────────────────────────────────────────────────────────────────────────┤
│ Layer 4: Protocols & Standards (MCP, Tool Calling, A2A)                   │
├───────────────────────────────────────────────────────────────────────────┤
│ Layer 3: Inference & Serving (vLLM, TGI, Ollama, SGLang)                  │
├───────────────────────────────────────────────────────────────────────────┤
│ Layer 2: Models (GPT-4, Claude, Llama, Mistral, Gemini, Qwen)             │
├───────────────────────────────────────────────────────────────────────────┤
│ Layer 1: Providers (OpenAI, Anthropic, Google, Meta, Mistral, OpenRouter) │
├───────────────────────────────────────────────────────────────────────────┤
│ Layer 0: Infrastructure (GPUs, quantization, vector DBs)                  │
└───────────────────────────────────────────────────────────────────────────┘

Layer 7: Applications

User-facing interfaces and platforms where humans interact with AI. These provide the final product experience, abstracting the underlying layers for end-users. This layer includes both general-purpose chat interfaces and specialized AI-enhanced development environments. - Relevant Pages: ChatGPT, Perplexity, Open WebUI, Claude Code, Cursor, Aider, Zed, Obsidian, Logseq, TeamOut, Valyu, ansigpt, Continue Dev, Codeium, GitHub Copilot, VS Code, Tabnine, Mentat, GPT Engineer, Melty, Superconductor, Terminus 2, Junie CLI. - Key Trends: Moving from simple chat to agentic IDEs and multimodal research assistants.

Layer 6: Agents & Orchestration

Systems that coordinate multiple steps, tools, and agents to achieve complex goals. This layer handles reasoning, planning, and task execution using underlying models and frameworks. - Relevant Pages: Mistral Agents, CrewAI, AutoGen, LangGraph, n8n, Agency Swarm, Agentic Automation Canvas, Agno, Bee Agent Framework, Composio, Phidata, OpenHands, Droid, Plandex, OpenSwarm, OpenClaw, Jules, Browser Use, Zapier, Make, Skyvern, Atlassian Jira MCP, ServiceNow MCP, CliHub. Systems that coordinate multiple steps, tools, and agents to achieve complex goals. This layer handles reasoning, planning, and task execution using underlying models and frameworks. It is where autonomous decision-making and environment interaction are managed. - Key Trends: Shift from linear chains to complex, stateful multi-agent graphs.

Layer 5: Frameworks

Development libraries used to build AI applications, handling prompt management, tool integration, and RAG logic. They provide the abstraction layer between models and applications. These frameworks simplify the process of constructing complex AI workflows and integrating various data sources. - Relevant Pages: LangChain, LlamaIndex, Haystack, DSPy, Semantic Kernel, Smolagents, Mycelium, Dify, Flowise, RAGFlow. - Key Trends: Increased focus on programmatic prompt optimization and modular RAG.

Layer 4: Protocols & Standards

The "glue" that allows models to interact with tools and other agents consistently. These standards ensure interoperability across the ecosystem. By establishing common interfaces, they prevent vendor lock-in and enable tool reuse across different frameworks. - Relevant Pages: Model Context Protocol (MCP), Agent Client Protocol (ACP), Tool Calling & MCP Patterns, Mistral AI (Native MCP), MCP Registry. - Key Trends: Rapid adoption of MCP as the standard for model-to-tool communication.

Layer 3: Inference & Serving

Engines that run model weights and provide APIs for applications to consume. This layer is responsible for the actual execution of model inference. It optimizes performance, handles concurrency, and provides the necessary scaling for production deployments. - Relevant Pages: vLLM, Text Generation Inference (TGI), Ollama, SGLang, Aphrodite Engine, ExLlamaV2, llama.cpp, MLX, LiteLLM. - Key Trends: Layer 3 is consolidating around vLLM and SGLang for high-performance serving.

Layer 2: Models

The core reasoning engines (LLMs, VLMs) that process information and generate text or actions. These are the fundamental units of intelligence in the stack. This layer includes both general-purpose foundation models and specialized models for coding, reasoning, or multimodality. - Relevant Pages: OpenAI Models, Anthropic Claude, Meta Llama, Mistral, Google Gemini, DeepSeek, Model Classes. - Key Trends: Rise of specialized reasoning models using test-time compute (e.g., GPT-5.5, Claude 4.7, Llama 4 Maverick).

Layer 1: Providers

Companies and platforms that host models and provide them as-a-service via API. They handle the scale and infrastructure required for model access. These providers offer varying levels of cost, speed, and privacy, allowing users to choose the best fit for their needs. - Relevant Pages: OpenRouter, Groq, Fireworks AI, Together AI, Replicate, Mistral AI, Cohere. - Key Trends: Providers are competing on speed (tokens/sec) and lower costs.

Layer 0: Infrastructure

The underlying hardware, storage, and low-level optimizations like quantization and vector databases that power the entire stack. This foundation ensures that higher-level services run efficiently and securely. It also includes the critical data supply chain components for ingestion and preparation. - Relevant Pages: Home Lab Architecture, TrueNAS SCALE, Tailscale, OpenPipe (Fine-tuning), Crawl4AI, Firecrawl, OCRmyPDF, PageIndex, CalDAV, ZSE. - Key Trends: Move towards hybrid infrastructure combining local GPU power with cloud scaling.

Key Patterns

How to use this repo

  • Model Classes — Understanding the different "tiers" of models within the landscape.
  • Agent Protocols — Deep dive into MCP and ACP.
  • Home Lab Architecture — How the physical layer (Layer 0) is implemented in this repo.
  • OpenRouter — A key Layer 1 provider that bridges many models.
  • n8n — A primary Layer 6 orchestration tool used in this stack.
  • Ollama — The recommended Layer 3 serving solution for local use.
  • MCP Registry — A catalog of tools available via the Layer 4 standard.

Sources / references

Contribution Metadata

  • Last reviewed: 2026-06-07
  • Confidence: high