Code Generation

Cursor

FreemiumDirectory score 4.8

AI editor with Composer and Cloud agents

• Agent and Composer
• Cloud agents

GitHub Copilot

FreemiumDirectory score 4.6

Coding assistant with a free plan and agent mode

Devin Desktop

FreemiumDirectory score 4.5

combining a full IDE and agents in Devin Desktop

Replit Agent

FreemiumDirectory score 4.4

building applications from ideas in an online development workspace

Claude Code

PaidDirectory score 4.8

Terminal agent drawn from Claude paid plans, shared usage pool

• Terminal agent
• Cross-file refactors

Aider

FreeDirectory score 4.6

Open-source terminal pair programming, you supply the model

• Git auto commits
• Multi-model

Continue

FreeDirectory score 4.4

reviewing Continue's acquisition notice and available source code

Tabnine

FreemiumDirectory score 4.2

assisting development with organization-specific code context

Amazon Q Developer

FreemiumDirectory score 4.1

evaluating Amazon Q Developer against its IDE-plugin sunset notice

Cody

EnterpriseDirectory score 4.2

understanding and fixing code with codebase-search context

Phind

FreemiumDirectory score 4.3

checking the current status of Phind's developer Q&A service

Bolt

FreemiumDirectory score 4.5

In-browser full-stack generator metered by token limits

• Prompt to app
• Runs in browser

v0

FreemiumDirectory score 4.6

Credit-metered interface generator that lives in your Vercel account

• Text to UI
• React + Tailwind

Lovable

FreemiumDirectory score 4.5

building and iterating apps and websites from plain language

Devin

PaidDirectory score 4.2

delegating engineering tasks to a PR-producing software agent

Trae

FreemiumDirectory score 4.3

connecting ideation, design, coding and testing in TRAE IDE

Augment Code

PaidDirectory score 4.4

organizing agent workflows from specification to verification

Qodo

FreemiumDirectory score 4.3

reviewing changes against codebase rules and requirements

JetBrains AI

PaidDirectory score 4.2

chatting, completing code and delegating coding tasks within JetBrains IDEs

Supermaven

FreemiumDirectory score 4.4

getting context-aware completions while editing code

Greptile

PaidDirectory score 4.4

getting graph-informed first-pass pull-request reviews

Blackbox AI

FreemiumDirectory score 4

checking Blackbox's current encrypted-inference positioning

OpenAI Codex

PaidDirectory score 4.5

Coding agent that runs in its own cloud workspace

• Codex cloud tasks
• CLI terminal agent

Google Jules

FreemiumDirectory score 4.3

submitting self-contained engineering tasks to an async coding agent

AWS Kiro

FreemiumDirectory score 4.2

turning requirements into executable specs for agentic engineering

Sourcegraph Amp

PaidDirectory score 4.4

letting coding agents continue tasks in independent environments

CodeRabbit

FreemiumDirectory score 4.5

adding review and governance around agent-produced code

Cline

FreeDirectory score 4.5

using one open agent in the editor and terminal

OpenHands

FreeDirectory score 4.3

organizing repetitive software-delivery steps as agent workflows

Qoder

FreemiumDirectory score 4.3

switching between completion, chat and delegated development

Ollama

FreemiumDirectory score 4.6

Local runs plus cloud usage credits

• Local runs
• Unlimited local runs

LM Studio

FreeDirectory score 4.4

using downloaded models and a computer agent locally

OpenRouter

PaidDirectory score 4.5

accessing different model services through one interface

Hugging Face

FreemiumDirectory score 4.6

Open-weights and dataset hub, billed per TB and per hour

• Model and dataset hosting
• Spaces demos

Google Antigravity

FreeDirectory score 4.4

0 USD/month individual tier, parallel local agents

• Agent command center
• Terminal CLI

Grok Build

FreemiumDirectory score 4.2

using Grok Build from the terminal for development

Zed

Pricing unknown

Code editor with inline and agent assistance

Roomote

Pricing unknown

Coding agent delivering pull requests and previews

Kilo Code

Pricing unknown

Coding agents across editors and the CLI

Tabby

Pricing unknown

Self-hostable code completion and chat assistant

Self-hosted terminal planning and diff review

Local agent with extensible tool connections

OpenCode

Pricing unknown

Coding agent with terminal, desktop and editor interfaces

Google's terminal development agent

Codacy

Pricing unknown

Code quality rules combined with AI review

Bito

Pricing unknown

Code context and model routing for coding agents

Qase

Pricing unknown

AI test cases with unified execution results

Factory Droid

Pricing unknown

Development-task agent across multiple interfaces

Warp

Pricing unknown

Terminal with visible agent runs and code review

Searchable work memory for coding context

CodeGPT

Pricing unknown

IDE coding assistance with editable plans

Sourcery

Pricing unknown

Pull-request summaries and suggested fixes

Source security analysis with AI fix suggestions

Semgrep

Pricing unknown

Rule-based analysis with AI-assisted triage

Serve multimodal models on your infrastructure

• Load model backends on demand
• Compatible model APIs and user quotas

Deploy language-model inference and serving

• Continuous batching and prefix caching
• Distributed inference and quantized model loading

Serve language and multimodal model inference

• Deploy language and vision-language endpoints
• Integrated image and video diffusion engine

Run language models across hardware with C/C++

• Quantized models and hybrid CPU/GPU inference
• CLI chat, server and built-in web interface

Generate text and fine-tune on Apple silicon

• Command-line and Python model calls
• Quantization and distributed inference or tuning

Deploy and manage different AI model services

• Language, speech and multimodal serving
• Request batching and distributed workers

Package model inference code as services

• Define inference APIs in Python
• Manage dependencies and build serving containers

Serve open language models through compatible APIs

• Model server launch and built-in chat
• Docker, Kubernetes and BentoCloud deployment

Unify model APIs and request governance

• Python SDK or standalone proxy gateway
• Virtual keys, spend tracking and load balancing

Configure one routing gateway for model providers

• Automatic retries and fallbacks
• Conditional routing and load balancing

Model gateway and LLM observability platform

• Inspect agent traces and conversation sessions
• Track cost, latency and prompt versions

Collaborative LLM engineering and observability

• Trace model calls, retrieval and agent actions
• Manage prompt versions, datasets and evaluations

Observe and evaluate production AI agents

• Agent simulations and call tracing
• Virtual-key budgets and usage governance

Observability for debugging and evaluating AI apps

• Trace execution with OpenTelemetry
• Compare prompt and retrieval experiments on datasets

Trace, evaluate and improve LLM applications

• Inspect multi-step agent and tool-call trees
• Manage evaluation experiments and prompt optimization

Compare model outputs and assess AI app risks

• Evaluate prompt and model combinations
• Produce red-team reports and integrate CI

Evaluate model applications with metrics and examples

• End-to-end app and agent trajectory evaluation
• Assess tool use, retrieval and answer quality

Organize evaluation workflows for RAG and agents

• Score outputs with model judges and traditional metrics
• Generate evaluation examples from application scenarios

Dynamic multi-turn evaluation for AI agents

• Create and apply agent evaluation checks
• Scan model risks and evaluate RAG applications

Evaluate and monitor ML and LLM systems

• Generate data-quality and model evaluation reports
• Add pass conditions and visualize monitoring trends

Add validation to language-model inputs and outputs

• Compose input and output validators
• Constrain models to produce structured data

Add programmable behavior rules to AI conversations

• Define dialogue paths and output behavior
• Configure rules between models and external tools

Identify generative-AI risks in authorized assessments

• Organize generative-AI risk assessment workflows
• Reuse assessment processes through framework components

Check language-model failure modes from the CLI

• Probe leakage, injection and misinformation risks
• Connect local models or hosted model endpoints

Toolkit for compressing, deploying and serving LLMs

• Weight and KV-cache quantization
• Distribute model requests across machines

Automate browser workflows with visual models

• Configure web actions with natural language
• Visual workflows and Playwright-compatible APIs

Tools for AI agents to operate browsers

• Browse pages and perform task-directed actions
• Local agent library and hosted browser connections

Connect AI reasoning to programmable browsers

• Locate and perform actions with act and observe
• Extract structured data from pages

Build agents that carry out web tasks

• Plan next actions through a world model
• Execute actions through browser drivers

Turn web pages into AI-ready source material

• Crawl sites into Markdown or structured data
• Browser actions and page screenshots

Web crawling tools for AI applications

• Generate cleaned Markdown content
• Structured JSON extraction and browser sessions

Parse varied documents for AI applications

• Recognize layouts, tables and formulas
• Export Markdown, HTML and structured JSON

Convert complex documents into structured content

• Extract tables, formulas, code and images
• Produce Markdown, JSON or HTML

Parse and read documents incrementally for agents

• Convert documents into readable content and Markdown
• Use page and block locators for follow-up reads

Prepare unstructured documents for AI retrieval

• Partition documents into content elements
• Connect data sources and preprocessing pipelines

Define extraction pipelines with natural language

• Combine language models with graph extraction logic
• Process web and local document sources

Build collaborative multi-agent applications

• Orchestrate agent conversations and tool calls
• Connect model providers and human participation

SDK for agents and multi-agent workflows

• Define agent tools, state and execution flows
• Connect MCP tools and A2A agent interfaces

Orchestrate work with role-based agents and flows

• Define crew roles and collaborative tasks
• Control state and events with Flows

Platform to build, deploy and run task agents

• Build agents with language or a visual editor
• Run on demand, on schedules or from triggers

Run extensible task agents in your environment

• Use container workspaces for files and commands
• Extend tasks through skills, plugins and tools

Self-hosted AI assistant for people and teams

• Connect chat channels and chosen model providers
• Use tools and plugins for ongoing tasks

Computer agents using screens and input actions

• Plan interface actions from screen content
• Execute mouse and keyboard actions

Visual agents for desktop interfaces

• Understand screenshots and plan task actions
• Connect local or remote computer environments

Collaborative agents with browser and file tools

• Coordinate browser tasks with an orchestrator model
• Combine sandbox execution with human approval

Build AI agents using code or tool calls

• Run agent code in configurable sandboxes
• Connect model providers, MCP and Hub tools

Python framework for RAG and agent applications

• Compose retrieval, routing and generation pipelines
• Connect agents to tools and state management

Connect external data to AI applications

• Build document indexes and RAG pipelines
• Orchestrate agents that call data tools

Build stateful agents with durable execution

• Define branches and loops as graphs
• Persist execution state and human review

TypeScript framework for AI agents and workflows

• Configure models, tools and agent memory
• Compose multi-step tasks with workflows

Develop and operate AI agents with memory

• Connect agent knowledge, tools and permissions
• Serve agents through AgentOS and its interface

Build AI applications and agents with typed Python

• Validate structured outputs and tool parameters
• Connect model providers and compose capabilities

Persistent memory for AI assistants and agents

• Manage user, session and agent memory
• Store and retrieve relevant memories through APIs

Build temporal context graphs for agents

• Track changing facts and source provenance
• Update graphs incrementally and query history

Organize sources into searchable agent memory

• Process documents, code and conversations
• Connect context through graphs and retrieval

Context and long-term memory for AI applications

• Extract facts and user context from sources
• Update memories and retrieve relevant context

Create interactive web apps for ML models

• Define model inputs, outputs and UI in Python
• Compose UI components and share demos

Visually compare prompts and model outputs

• Organize prompt experiments as node workflows
• Evaluate and visualize multi-model responses

Develop, trace and evaluate model application flows

• Connect prompts, models and Python steps
• Debug traces and compare evaluation results

Orchestrate data, AI and infrastructure workflows

• Define flows with declarative configuration and UI
• Use schedules, events and AI-assisted flow authoring

Automatically build and compare ML models

• Train tabular and time-series models
• Perform model selection and ensembling

Train and deploy models with declarative configuration

• Define data features and tasks in YAML
• Fine-tune language models and process multimodal data

Automated ML within resource budgets

• Automatically select models and tune hyperparameters
• Configure search spaces, time and compute limits

Manage model development, evaluation and run records

• Trace models and agents and evaluate outputs
• Manage prompts, model versions and serving endpoints

Track and compare machine-learning experiments

• Log training configurations, metrics and charts
• Version data and model artifacts

Manage ML experiments and execution pipelines

• Track experiments, models and data artifacts
• Orchestrate remote training and automated pipelines

Version data and models for machine learning

• Track large data artifacts through Git metadata
• Define incrementally executable model pipelines

Orchestrate traceable machine-learning pipelines

• Combine training, evaluation and deployment steps
• Manage run records and versioned artifacts

Store and retrieve vectors for AI applications

• Manage vectors and associated payloads
• Apply filters within similarity searches

AI retrieval database for objects and vectors

• Combine semantic, keyword and reranked retrieval
• Vectorize imports or ingest existing embeddings

Vector database for text, images and other data

• Organize vectors and perform similarity search
• Choose standalone or distributed deployment

Searchable document embeddings for model applications

• Store documents and vectors in collections
• Query by text and apply metadata filters

Data platform for multimodal AI workloads

• Search with keywords, vectors and SQL
• Manage data for analysis and model development

Application engine combining search and model computation

• Combine vector, text and structured-data search
• Run model inference and ranking during queries

Package AI inference components as network services

• Serve calls over HTTP, gRPC and WebSocket
• Compose service graphs and deploy containers

Deploy models from different ML frameworks

• Manage model backends and inference requests
• Support batching and ensemble pipelines

Configure post-training for language and multimodal models

• Define data, training and evaluation in YAML
• Run full fine-tuning, LoRA and preference training

Configure model fine-tuning and inference together

• Configure training through CLI or web UI
• Run multimodal fine-tuning and monitor training metrics

Library for post-training foundation models

• Provide SFT, DPO and GRPO trainers
• Scale to multiple GPUs and nodes with Accelerate

Observe model applications with OpenTelemetry

• Instrument model and vector-database call traces
• Export to OTLP-compatible observability backends

Trace, evaluate and improve AI agents

• Record agent and tool calls with OpenTelemetry
• Manage evaluations, prompts and cost monitoring

Observe execution of language-model applications

• Collect model, framework and vector-database traces
• Inspect call latency, usage and costs

Trace and compare AI application quality

• Record execution steps with OpenTelemetry
• Evaluate traces or datasets

Coding agent with selectable models and harnesses

• Switch models and compatible providers from the terminal
• Run sandboxed commands and connect editors through ACP