# ContextIQ

> AI Context Engineering Suite by Trango Compute Inc. — free tools for AI engineers to visualize memory architectures, compare LLM token costs, inspect identity provider configurations, look up DNS/SPF/DMARC/CAA records, debug RAG chunking pipelines, and detect MCP, A2A, and ARD agent protocol support on any URL.

ContextIQ is a web application suite at https://contextiq.trango-compute.com. All tools are free to use without sign-up. A Pro plan ($5/month) unlocks diagram exports (PDF, PNG, SVG, JSON, Markdown) and shared public links.

## Tools

### AI Agent Protocol Inspector

URL: https://contextiq.trango-compute.com/agent-readiness-detector

Enter any URL and detect which AI agent protocols it supports: MCP (Model Context Protocol), A2A (Agent2Agent), and ARD (Agentic Resource Discovery). Runs a live JSON-RPC 2.0 initialize handshake against MCP servers (Streamable HTTP, SSE-framed responses, OAuth-protected server detection via RFC 9728), fetches and parses A2A agent cards from /.well-known/agent-card.json (including legacy agent.json), and discovers ARD ai-catalog.json catalogs via well-known URI, robots.txt Agentmap directives, and HTML link tags. Also available at /mcp-inspector, /a2a-inspector, and /ard-inspector.

Specs covered: MCP (Anthropic), SEP-2127 server cards, A2A (Google / Linux Foundation), agent-card.json, ARD (Google, Microsoft, Hugging Face, GoDaddy), ai-catalog.json, Agentmap, JSON-RPC 2.0, OAuth 2.0, RFC 9728, RFC 8615.

Features: per-protocol Confirmed / Indicated / Not-detected verdicts with evidence, MCP tools/list enumeration, A2A skills and securitySchemes breakdown, ARD catalog entry listing with URN identifiers and trust manifests, raw JSON views, full report download (Pro).

### Memory Architecture Visualizer

URL: https://contextiq.trango-compute.com/memory-visualizer

Design AI agent memory as a directed acyclic graph (DAG). Map the four memory layers — working memory (active context window), episodic memory (past interactions retrieved by vector search), semantic memory (RAG knowledge base / Pinecone / Weaviate), and procedural memory (tool registry, system prompt, few-shot examples) — with token budget allocations and data flow annotations.

Supports: LangGraph, CrewAI, AutoGen, OpenAI Agents SDK, Google ADK, LlamaIndex, Haystack, Semantic Kernel.

Features: auto-layout DAG rendering, turn-by-turn token budget simulation, export to SVG / PNG / JSON / Markdown (Pro).

### Token Inspector

URL: https://contextiq.trango-compute.com/token-inspector

Paste any text — system prompts, documents, few-shot examples, conversation history — and instantly compare token counts and estimated API costs across 20+ language models in a single view.

Models covered: GPT-5.6 Sol/Terra/Luna, GPT-4o, GPT-4o mini (OpenAI), Claude Sonnet 5, Claude Haiku 4.5 (Anthropic), Gemini 3.1 Pro, Gemini 2.5 Flash (Google), DeepSeek-V4 Pro/Flash (DeepSeek), Llama 4 Maverick/Scout (Meta), Mistral Large, Qwen3-235B, and more. Custom model support available.

OpenAI models use tiktoken (o200k_base) for exact counts client-side. Other models use character-ratio approximations clearly labeled with ~.

Features: exact token counts for OpenAI models, real cost projections at scale (set output tokens + daily volume), custom model/pricing support.

### RAG Chunk Inspector

URL: https://contextiq.trango-compute.com/rag-chunk-inspector

Paste any document and visually debug how it splits into chunks for a RAG pipeline. Supports four strategies: token-based (GPT-4o tiktoken / o200k_base), character-based, sentence-boundary, and paragraph-boundary chunking. Real-time visualization shows every chunk boundary colour-coded in the source document, with overlap regions highlighted in amber.

Vector stores supported: Pinecone, Weaviate, Qdrant, pgvector. Frameworks: LangChain, LlamaIndex. Embedding models: text-embedding-ada-002, text-embedding-3-small.

Features: live chunk boundary visualization, token distribution histogram with shape guide, LLM context preview (system prompt + retrieved chunk + user message), side-by-side strategy comparison, chunk size and overlap sliders, URL-encoded shareable state, export chunks as JSON (Pro).

### Agent Workflow Visualizer

URL: https://contextiq.trango-compute.com/agent-workflow-visualizer

Scan any public GitHub repository to generate an interactive graph of how AI agents, tools, and workflows connect. Fetches Python source files, detects the framework from imports and class usage, then parses the agent structure into a node-edge graph rendered with React Flow.

Frameworks: LangGraph (StateGraph, add_node, add_conditional_edges), CrewAI (Crew, Agent, Task), Google ADK (LlmAgent, SequentialAgent, ParallelAgent, LoopAgent), AutoGen (AssistantAgent, GroupChatManager, RoundRobinGroupChat), OpenAI Agents SDK and Swarm (Agent, Runner.run, function_tool, handoffs).

Features: GitHub repo scan (up to 15 Python files), AST-based parser for all 5 frameworks, node inspector (LLM model, tools, system prompt excerpt, source file), layered and compact layout modes, JSON export (free), PNG and SVG export (Pro).

### HyDE Visualizer

URL: https://contextiq.trango-compute.com/hyde-visualizer

Visualize Hypothetical Document Embeddings (HyDE) for RAG pipelines. Paste a query and corpus chunks, generate a hypothetical answer via Claude Haiku 4.5 or GPT-4o mini (using your API key), and compare cosine similarity scores per chunk between direct query embedding and HyDE embedding. Embeddings computed locally using all-MiniLM-L6-v2 or BGE-Small-en-v1.5 via Transformers.js — no data transmitted.

Models supported: all-MiniLM-L6-v2, BGE-Small-en-v1.5, Claude Haiku 4.5 (Anthropic), GPT-4o mini (OpenAI). Frameworks: LangChain (HyDEQueryTransform), LlamaIndex (native HyDE transform), Raw Python (sentence-transformers). Vector stores: Pinecone, Weaviate, Qdrant, pgvector.

Features: in-browser WASM embeddings via Transformers.js, per-chunk rank delta, bridge term analysis (shared vocabulary between hypothetical answer and corpus), generation cost breakdown (per-query + monthly projections), top-k retrieval slider, embedding model switcher, export pipeline code for Raw Python / LangChain / LlamaIndex (Pro).

### Agent Trace Inspector

URL: https://contextiq.trango-compute.com/agent-trace-inspector

Paste any OTLP JSON trace from LangSmith, Langfuse, or the OpenTelemetry Collector and instantly visualize the agent graph. Reads OpenTelemetry GenAI semantic conventions (gen_ai.agent.name, gen_ai.tool.name, gen_ai.usage.input_tokens, gen_ai.usage.output_tokens, gen_ai.system) — no SDK or instrumentation changes required. LLM call spans without an agent name are folded onto their nearest ancestor agent node, so per-agent token totals reflect every inference the agent triggered.

Frameworks: LangGraph, CrewAI, AutoGen, OpenAI Agents SDK. Exporters: LangSmith, Langfuse, Jaeger, Zipkin, Grafana Tempo, OpenTelemetry Collector. Models: GPT-4o, GPT-4o-mini, Claude 3.5 Sonnet, Gemini 1.5 Pro, and any model reported via gen_ai.request.model.

Features: agent-tool graph from OTLP JSON (free), token attribution per agent node (free), framework auto-detection from gen_ai.system (free), span timeline waterfall (Pro).

### OIDC Inspector

URL: https://contextiq.trango-compute.com/oidc-inspector

Enter any domain and scan for OpenID Connect and OAuth 2.0 provider configurations. Scans the primary domain plus 11 common auth subdomains (auth., login., sso., id., identity., accounts., oauth., oidc., as., access., connect.) in parallel.

Fetches and parses /.well-known/openid-configuration and /.well-known/oauth-authorization-server. Displays authorization endpoint, token endpoint, userinfo endpoint, JWKS URI, supported scopes, grant types, response modes, and PKCE support.

Detects: Google Identity, Microsoft Azure AD, Auth0, Okta, AWS Cognito, Keycloak, PingIdentity, OneLogin, Salesforce Identity, GitLab, Apple ID.

Features: parallel subdomain scan, full discovery document parsing, JWKS key inspection (RSA/EC/OKP), PKCE security check, Authorization Code Flow sequence diagram, raw JSON download (Pro).

### DNS Inspector

URL: https://contextiq.trango-compute.com/dns-inspector

Enter any domain and see its full DNS record set — A, AAAA, CNAME, MX, NS, TXT, SOA, and CAA — queried in parallel via DNS-over-HTTPS, plus the _dmarc TXT record. Parses SPF mechanisms and qualifier strength, decodes DMARC policy into a plain verdict, and decodes CAA records (including the raw RFC 3597 wire-format hex most tools leave unreadable) to flag domains with no certificate authority restriction at all.

Detects: Cloudflare, AWS Route 53, GoDaddy, Namecheap, Google Cloud DNS, DNSimple, DigitalOcean, Azure DNS, Akamai, NS1 (DNS hosts); Google Workspace, Microsoft 365, Zoho Mail, Proton Mail, Proofpoint, Mimecast (mail providers).

Features: full record lookup in one scan, SPF strict/softfail/neutral/wide-open verdict, DMARC Protected/Monitoring/Unprotected verdict, CAA authority restriction check, DNS host and mail provider identification, connected third-party SaaS service detection from TXT domain-verification records (Google Search Console, Microsoft, Salesforce, Stripe, and more), cross-links to OIDC Inspector and Agent Protocol Inspector for the same domain, raw JSON download (Pro).

### x402 Inspector

URL: https://contextiq.trango-compute.com/x402-inspector

Paste a paid endpoint URL and validate its x402 payment challenge — the HTTP 402 Payment Required response that Coinbase's x402 protocol uses for machine-to-machine stablecoin payments. Probes with a GET→POST method fallback (since x402 commonly gates POST-only resources), then checks the response body against the x402 spec: required fields, USDC amount encoding in atomic units, and address format per network. Does not check facilitator reachability (not exposed in the 402 body) or complete live payment settlement.

Networks recognized: Base, Base Sepolia, Polygon, Arbitrum, World Chain, Avalanche, Solana, Stellar. Supports both x402 v1 (top-level maxAmountRequired, bare network names) and x402 v2 (amount field, extra-nested resource/description, CAIP-2 network identifiers) response shapes.

Features: 402 challenge detection with automatic method fallback, payment-requirements field validation (scheme, network, maxAmountRequired, resource, payTo, asset, maxTimeoutSeconds, extra), network and address-format checks per chain family, x402 spec-version detection, plain-language misconfiguration warnings, paid v1 API endpoint gated by API key or a live x402 payment.

### ERC-8004 Inspector (Beta)

URL: https://contextiq.trango-compute.com/erc8004-inspector

Enter an ERC-8004 ("Trustless Agents") agent ID and look up its on-chain identity and reputation — live reads from the Identity Registry (ERC-721-based owner, agent wallet, tokenURI/metadata) and Reputation Registry (client feedback count, aggregate score), with no indexing and no signup. Agent ID only in this beta: the Identity Registry isn't ERC-721-Enumerable and free RPC providers reject the unbounded event-log queries an address-to-agent-ID lookup would need. ValidationRegistry isn't covered — no verified contract address is published for it.

Networks recognized: Ethereum, Base, Base Sepolia, Arbitrum, Polygon, Avalanche, BNB Chain.

Features: Identity Registry lookup (owner, agent wallet, tokenURI + fetched JSON metadata when http(s)), Reputation Registry lookup (client count, aggregate feedback score), plain-language "trust signals found" framing (not a trust verdict), paid v1 API endpoint gated by API key or a live x402 payment.

## Blog

URL: https://contextiq.trango-compute.com/blog
RSS: https://contextiq.trango-compute.com/rss.xml

Technical articles on LLM token costs, AI agent memory architectures, OpenID Connect, and context engineering. Posts cover practical cost breakdowns, model comparisons, and architecture guides for AI engineers.

Topics covered: GPT-4o, Claude 3.5 Sonnet, Gemini 1.5 Pro, DeepSeek V3, LangGraph, CrewAI, AutoGen, token pricing, prompt caching, model routing, OIDC, OAuth 2.0, MCP, A2A, ARD, agent discovery, x402, ERC-8004.

### What Is x402? How HTTP 402 Payment Required Powers AI Agent Micropayments on Base

URL: https://contextiq.trango-compute.com/blog/what-is-x402-http-402-payment-required-ai-agents

Explains how Coinbase and Cloudflare's x402 protocol turns HTTP's dormant 402 status code into instant USDC micropayments for APIs and AI agents. Covers the request/402/retry flow, the PaymentRequirements JSON fields (scheme, network, maxAmountRequired, payTo, asset, extra), the role of facilitators (Coinbase's CDP facilitator, the Stellar Development Foundation's facilitator), the x402 Foundation's Linux Foundation governance and member list, and the most common integration mistakes (missing payTo, atomic-unit amount confusion, method mismatches).

Entities covered: x402, HTTP 402 Payment Required, Coinbase, Cloudflare, USDC, Base, Base Sepolia, Solana, Stellar, x402 Foundation, EIP-3009, Linux Foundation.

### What Is ERC-8004? Ethereum's Standard for Trustless AI Agent Identity and Reputation

URL: https://contextiq.trango-compute.com/blog/what-is-erc-8004-ethereum-trustless-ai-agent-identity

Explains the ERC-8004 "Trustless Agents" Ethereum standard: the ERC-721-based Identity Registry, the Reputation Registry, and the Validation Registry, and how they differ from off-chain A2A agent cards and MCP server cards. Covers why on-chain identity is portable in a way self-hosted agent cards aren't, how ERC-8004 pairs with payment protocols like x402 as a pre-payment trust check, and the standard's current draft-EIP status across Ethereum mainnet and testnets.

Entities covered: ERC-8004, Ethereum, ERC-721, Identity Registry, Reputation Registry, Validation Registry, A2A, MCP, x402, ERC-4337, EIP-7702, Base Sepolia, Linea Sepolia, Hedera Testnet.

### x402 v1 vs v2: What Changed in the Payment Requirements Schema

URL: https://contextiq.trango-compute.com/blog/x402-v1-vs-v2-payment-requirements-schema-changes

Field-by-field diff between x402Version 1 and 2 payment-challenge responses, with real examples from both a live ContextIQ endpoint (v1) and a live PayAI echo test server (v2). Covers the move from bare network strings to CAIP-2 identifiers (eip155:8453, solana:5eykt4Us...), the maxAmountRequired-to-amount rename, and resource/description/mimeType moving into extra — plus what sellers and client/validator authors each need to change.

Entities covered: x402, x402 v2, CAIP-2, eip155, maxAmountRequired, amount, extra, Base, Base Sepolia, Solana, PayAI.

### How to Look Up an AI Agent's On-Chain Identity and Reputation (ERC-8004 Walkthrough)

URL: https://contextiq.trango-compute.com/blog/how-to-look-up-erc-8004-agent-identity-reputation

Hands-on walkthrough reading the ERC-8004 Identity and Reputation registries for real, currently-registered agents on Ethereum and Base Sepolia — ownerOf/getAgentWallet/tokenURI calls, decoding a data: URI tokenURI (no network fetch needed, unlike http(s) or ipfs://) using a real named agent ("Corgent - Cortensor Agent") as the worked example, and reading getClients/getSummary for aggregate reputation. Ends with what the data doesn't tell you (self-reported reputation, no ValidationRegistry coverage yet).

Entities covered: ERC-8004, Identity Registry, Reputation Registry, tokenURI, data URI, Ethereum, Base Sepolia, eth_call, Corgent, Cortensor.

### What Is Agent Commerce? How x402 and ERC-8004 Let AI Agents Trust and Pay Each Other

URL: https://contextiq.trango-compute.com/blog/what-is-agent-commerce-x402-erc-8004

Synthesis piece explaining "agent commerce" as the combination of x402 (payment rail — USDC micropayments via HTTP 402) and ERC-8004 (trust rail — on-chain Identity and Reputation registries), why neither alone is sufficient for autonomous agent-to-agent transactions, a concrete discover-check-decide-pay-settle flow, real registered agents that already declare x402 support inside their ERC-8004 metadata, and the current rough edges (self-reported reputation, no address-to-agent-ID resolution, independently-evolving schemas, no usable ValidationRegistry yet).

Entities covered: agent commerce, x402, ERC-8004, USDC, Identity Registry, Reputation Registry, x402 Foundation, Coinbase, Corgent, A2A, MCP.

### MCP 2026-07-28 Explained: The Stateless Core, server/discover, and Who's Already Compliant

URL: https://contextiq.trango-compute.com/blog/mcp-2026-07-28-spec-stateless-server-discover

Covers the 2026-07-28 Model Context Protocol revision: the removal of the initialize handshake and Mcp-Session-Id header in favor of a stateless core built around the new mandatory server/discover RPC, the Multi Round-Trip Requests pattern replacing server-initiated sampling/elicitation/roots calls, the Roots/Sampling/Logging/Dynamic Client Registration deprecations (earliest removal 2027-07-28), and new JSON-RPC error codes. Includes live compliance testing showing which real MCP servers already implement it.

Entities covered: MCP, Model Context Protocol, server/discover, Mcp-Session-Id, initialize handshake, Streamable HTTP, JSON-RPC 2.0, Multi Round-Trip Requests, Client ID Metadata Documents, Dynamic Client Registration, RFC 9207, Hugging Face, Cloudflare, DeepWiki, GitHub Copilot.

### How to Make Your Website Discoverable to AI Agents: llms.txt, agent-card.json, ai-catalog.json, and MCP Server Cards

URL: https://contextiq.trango-compute.com/blog/make-website-discoverable-ai-agents-llms-txt-agent-cards

A practical four-step checklist for agent discoverability: llms.txt for LLM crawlers, an A2A agent card at /.well-known/agent-card.json, an MCP server with a SEP-2127 server card, and an ARD ai-catalog.json with a robots.txt Agentmap directive. Covers common silent failures like SPA catch-all routes and why outside-in verification matters.

Entities covered: llms.txt, agent-card.json, ai-catalog.json, Agentmap, robots.txt, MCP, A2A, ARD, SEP-2127, RFC 9728, Claude, Cursor, answer engines.

### MCP Server Discovery: How .well-known/mcp/server-card (SEP-2127) Works

URL: https://contextiq.trango-compute.com/blog/mcp-server-discovery-well-known-server-card-sep-2127

Explains the SEP-2127 MCP server card: the /.well-known/mcp/server-card discovery document, its experimental extensions-track status, what fields it contains, and how MCP servers are discovered without one — the /mcp path convention, the initialize handshake as fingerprint, and 401 + RFC 9728 OAuth metadata as a discovery signal.

Entities covered: MCP, Model Context Protocol, SEP-2127, server card, Streamable HTTP, JSON-RPC 2.0, RFC 8615, RFC 9728, OAuth 2.0, WWW-Authenticate, tools/list, SSE.

### MCP vs A2A vs ARD: How AI Agents Call Tools, Talk to Each Other, and Get Discovered

URL: https://contextiq.trango-compute.com/blog/mcp-vs-a2a-vs-ard-agent-protocols

Compares the three layers of the AI agent protocol stack: MCP (Anthropic's Model Context Protocol) for agent-to-tool invocation over JSON-RPC 2.0, A2A (Google / Linux Foundation Agent2Agent) for agent-to-agent collaboration via Agent Cards, and ARD (Agentic Resource Discovery, from Google, Microsoft, Hugging Face, and GoDaddy) for cross-organization discovery. Includes the well-known discovery documents each spec defines and how they compose in one flow.

Entities covered: MCP, Model Context Protocol, A2A, Agent2Agent, ARD, Agentic Resource Discovery, Anthropic, Google, Microsoft, Hugging Face, Linux Foundation, JSON-RPC 2.0, agent-card.json, ai-catalog.json, SEP-2127, Streamable HTTP.

### What Is the Agentic Resource Discovery (ARD) Specification? ai-catalog.json, Agentmap, and Agent Search Explained

URL: https://contextiq.trango-compute.com/blog/agentic-resource-discovery-ard-specification-ai-catalog

Explains the July 2026 ARD specification: publishing an ai-catalog.json manifest at a well-known URI, the robots.txt Agentmap directive, HTML link tags, DNS service bindings, URN identifiers anchored to domains, registry semantic search with relevance scores, trust manifests with SPIFFE and SOC 2 attestations, and registry federation.

Entities covered: ARD, Agentic Resource Discovery, ai-catalog.json, Agentmap, robots.txt, RFC 8615, URN, SPIFFE, SOC 2, Google, Microsoft, Hugging Face, GoDaddy, MCP, A2A, agent registries.

### A2A Agent Cards Explained: How to Publish and Validate .well-known/agent-card.json

URL: https://contextiq.trango-compute.com/blog/a2a-agent-card-well-known-agent-card-json

Field-by-field guide to the A2A protocol's Agent Card at /.well-known/agent-card.json: protocolVersion, skills, capabilities, defaultInputModes, securitySchemes in OpenAPI 3 format, the legacy agent.json path, authenticated extended cards, cache headers, and a pre-launch validation checklist.

Entities covered: A2A, Agent2Agent, Agent Card, agent-card.json, agent.json, RFC 8615, OpenID Connect, OAuth 2.0, OpenAPI 3, JSON-RPC, SSE, Linux Foundation, Google.

### What is Context Engineering? The Discipline Behind Every Production LLM Application

URL: https://contextiq.trango-compute.com/blog/what-is-context-engineering

Defines context engineering as the practice of designing everything that occupies a GPT-4o, Claude Sonnet 4.6, or Gemini 2.5 Pro context window at inference time — system prompts, RAG retrieved chunks, conversation history, tool results, and memory outputs competing for a fixed token budget. Covers the three core skills: token budget design, retrieval precision, and memory architecture.

Entities covered: GPT-4o, Claude Sonnet 4.6, Gemini 2.5 Pro, LangGraph, CrewAI, Pinecone, Weaviate, pgvector, tiktoken, text-embedding-ada-002, text-embedding-3-small.

### How Context Engineering Makes You a Better AI Engineer

URL: https://contextiq.trango-compute.com/blog/context-engineering-better-ai-engineer

Explains the practical skills context engineering builds: token budget design with turn-by-turn fill prediction, cost intuition for GPT-4o and Claude 3.5 Sonnet at production volume, retrieval precision as a context budget problem, reading OpenTelemetry agent traces, and designing memory architectures across working/episodic/semantic/procedural stores.

Entities covered: GPT-4o, Claude Sonnet 4.6, Claude 3.5 Sonnet, Gemini 2.5 Pro, DeepSeek V3, LangGraph, CrewAI, AutoGen, OpenAI Agents SDK, Pinecone, tiktoken, text-embedding-ada-002, text-embedding-3-small, LangSmith, Langfuse, gen_ai.usage.input_tokens.

### A Concrete Example of Context Engineering — and How a Suite of Tools Makes It Tractable

URL: https://contextiq.trango-compute.com/blog/context-engineering-example-suite

Step-by-step context engineering walkthrough for a LangGraph customer support agent on GPT-4o with Pinecone RAG and tiktoken token measurement. Shows the before/after context budget table, retrieval precision tuning, history truncation with summarization, and verification using Memory Visualizer, Token Inspector, RAG Chunk Inspector, and Agent Trace Inspector. Quantifies a 34% token reduction saving $1,406/month at 15,000 calls/day.

Entities covered: LangGraph, GPT-4o, Pinecone, text-embedding-ada-002, tiktoken, o200k_base, LangSmith, gen_ai.usage.input_tokens, Memory Architecture Visualizer, Token Inspector, RAG Chunk Inspector, Agent Trace Inspector.

### HyDE: Why Your RAG Embeddings Miss and How Hypothetical Document Embeddings Fix It

URL: https://contextiq.trango-compute.com/blog/hyde-hypothetical-document-embeddings-rag-retrieval

Explains the query-document embedding gap in RAG pipelines and how Hypothetical Document Embeddings (HyDE) closes it by generating a hypothetical answer document before embedding. Covers the query-document gap, when HyDE helps most, LangChain and LlamaIndex implementation, generation cost for Claude Haiku 4.5 and GPT-4o mini, and embedding model comparison.

Entities covered: HyDE (Hypothetical Document Embeddings), all-MiniLM-L6-v2, BGE-Small-en-v1.5, Claude Haiku 4.5, GPT-4o mini, LangChain HyDEQueryTransform, LlamaIndex HyDEQueryTransform, sentence-transformers, Pinecone, Weaviate.

### LangGraph vs CrewAI vs AutoGen vs Google ADK: How Each Framework Structures Multi-Agent Workflows

URL: https://contextiq.trango-compute.com/blog/langgraph-crewai-autogen-google-adk-agent-architecture

Structural comparison of how LangGraph StateGraph, CrewAI Crew, AutoGen GroupChatManager, and Google ADK SequentialAgent wire agents together — with real code patterns and graph shape analysis. Explains routing ownership, node types, and which framework fits which problem shape.

Entities covered: LangGraph StateGraph, add_conditional_edges, CrewAI Crew, Process.sequential, AutoGen GroupChatManager, RoundRobinGroupChat, Google ADK LlmAgent, SequentialAgent, ParallelAgent, OpenAI Agents SDK, Swarm handoffs.

### Token vs Sentence vs Paragraph Chunking in RAG: Which Strategy Fits Your Documents

URL: https://contextiq.trango-compute.com/blog/rag-chunking-strategies-token-sentence-paragraph

Comparison of token-based (tiktoken), sentence-boundary, paragraph-boundary, and character-based chunking strategies for RAG pipelines. Covers where each strategy produces bad chunks, how overlap affects retrieval quality, and how to read a token distribution histogram to diagnose fragmentation or oversized chunks. Includes a comparison table across LangChain, LlamaIndex, Pinecone, and Weaviate use cases.

Entities covered: tiktoken, o200k_base, cl100k_base, text-embedding-ada-002, LangChain CharacterTextSplitter, LlamaIndex SentenceSplitter, Pinecone, Weaviate.

### Why RAG Retrieval Fails: Chunk Size, Overlap, and the text-embedding-ada-002 Token Limit

URL: https://contextiq.trango-compute.com/blog/chunk-size-overlap-rag-retrieval-quality

Diagnostic guide for poor RAG retrieval caused by wrong chunk size and overlap settings. Covers text-embedding-ada-002's 8,191-token truncation limit, what happens when chunks are too small (fragmentation) or too large (diluted relevance), and how boundary-spanning facts are lost without overlap. Includes embedding cost comparison across chunk sizes and a practical tuning workflow.

Entities covered: text-embedding-ada-002, text-embedding-3-small, tiktoken, Pinecone, Weaviate, Qdrant, LangChain, GPT-4o.

### AI Agent Memory Architecture: How LangGraph, CrewAI, AutoGen, and OpenAI Agents SDK Manage Context

URL: https://contextiq.trango-compute.com/blog/ai-agent-memory-architecture-langgraph-crewai-autogen

Breakdown of the four AI agent memory layers — working memory (context window), episodic memory (vector retrieval of past interactions), semantic memory (RAG / knowledge base), and procedural memory (tool registry, system prompt, few-shot examples) — with implementation notes for LangGraph, CrewAI, AutoGen, and the OpenAI Agents SDK. Covers token budget allocation, chunking strategy, dynamic tool selection, and retrieval timing.

Frameworks covered: LangGraph, CrewAI, AutoGen, OpenAI Agents SDK, Google ADK, LlamaIndex. Backends: Pinecone, Weaviate, Qdrant, pgvector.

### How to Read OTLP Traces from LangGraph, CrewAI, and OpenAI Agents SDK

URL: https://contextiq.trango-compute.com/blog/how-to-read-otlp-traces-langgraph-crewai-openai-agents

Guide to the OpenTelemetry GenAI semantic conventions and how to use span parentage to reconstruct the agent graph from a LangGraph ReAct loop, CrewAI pipeline, or OpenAI Agents SDK handoff. Covers per-agent token attribution, tool call latency vs LLM latency, and how to export traces from LangSmith and Langfuse.

Entities covered: LangGraph, CrewAI, OpenAI Agents SDK, gen_ai.agent.name, gen_ai.tool.name, gen_ai.usage.input_tokens, gen_ai.usage.output_tokens, gen_ai.system, LangSmith, Langfuse, OpenTelemetry Collector, GPT-4o, claude-3-5-sonnet-20241022.

### LangSmith vs Langfuse vs LangGraph Studio: Which Gives You the Best Agent Graph View?

URL: https://contextiq.trango-compute.com/blog/langsmith-vs-langfuse-vs-langgraph-studio-agent-graph-view

Compares how LangSmith (tree/waterfall, no node-edge graph), LangGraph Studio (local desktop, LangGraph-only), and Langfuse (beta LangGraph graph view since Feb 2025) visualize agent runs — and contrasts them with ContextIQ's zero-instrumentation static graph approach.

Entities covered: LangSmith, Langfuse, LangGraph Studio, LangGraph, CrewAI, AutoGen, OpenAI Agents SDK, Google ADK, ContextIQ Agent Workflow Visualizer.

### Predict When Your Context Window Will Fill — Before It Happens

URL: https://contextiq.trango-compute.com/blog/predict-context-window-fill-turn

Explains how to estimate the turn at which a GPT-4o, Claude Sonnet 4.6, or Gemini 2.5 Pro agent exhausts its context window using stable-layer baselines and per-turn conversation history growth. Covers the Predict Fill feature in ContextIQ's Memory Architecture Visualizer.

Entities covered: GPT-4o, Claude Sonnet 4.6, Gemini 2.5 Pro, Pinecone, Weaviate, PostgreSQL, Redis, LangGraph, external_injection, retrieved_context, long_term_memory, conversation_history.

### How to Debug a Failing LangGraph Agent with OTLP Traces

URL: https://contextiq.trango-compute.com/blog/debug-failing-langgraph-agent-otlp-trace

Practical walkthrough of three common LangGraph agent failure patterns — infinite loops, silent tool call errors, and token blowout — using OTLP span data. Shows which span attributes to inspect for each failure: callCount on repeated gen_ai.agent.name spans for loops, status.code === 2 and status.message for tool errors, and high gen_ai.usage.input_tokens on deep LLM call spans for token blowout.

Entities covered: LangGraph, LangSmith, CrewAI, OpenAI Agents SDK, gen_ai.agent.name, gen_ai.tool.name, gen_ai.usage.input_tokens, gen_ai.usage.output_tokens, OpenTelemetry, OTLP, gpt-4o, claude-3-5-sonnet-20241022.

### LangSmith Vendor Attributes vs OpenTelemetry gen_ai Conventions: Why Your Trace Looks Empty

URL: https://contextiq.trango-compute.com/blog/langsmith-vendor-attributes-vs-opentelemetry-gen-ai-conventions

Explains why LangGraph and LangSmith traces render blank in OTLP tooling: LangSmith uses langsmith.span.kind and langgraph.graph.id instead of gen_ai.agent.name and gen_ai.tool.name. Covers the full attribute mapping table, why langgraph.graph.id is a constant graph identifier (not a per-node name), how to use span.name with langsmith.span.kind = "chain" to recover agent node names, and how to handle custom vendor namespaces.

Entities covered: LangSmith, LangGraph, langsmith.span.kind, langgraph.graph.id, gen_ai.agent.name, gen_ai.tool.name, gen_ai.system, OpenTelemetry GenAI semantic conventions, Langfuse, OpenTelemetry Collector.

### Ontologies vs. Knowledge Graphs: What AI Engineers Actually Need to Know

URL: https://contextiq.trango-compute.com/blog/ontologies-vs-knowledge-graphs

Explains the practical difference between OWL ontologies (formal domain schemas using RDF and SPARQL) and Neo4j knowledge graphs (entity-relationship stores with Cypher), and when each is appropriate for AI systems. Covers graph-based RAG with LangGraph and LlamaIndex's PropertyGraphIndex as a hybrid retrieval alternative to pure vector search.

Entities covered: OWL, RDF, SPARQL, schema.org, Wikidata, DBpedia, Neo4j, Amazon Neptune, Apache AGE, LlamaIndex PropertyGraphIndex, LangGraph, Cypher, pgvector.

### GPT-4o vs Claude 3.5 Sonnet vs Gemini 1.5 Pro: Token Cost Comparison at 10k req/day

URL: https://contextiq.trango-compute.com/blog/gpt-4o-vs-claude-vs-gemini-token-cost

Practical cost breakdown comparing GPT-4o ($2.50/$10.00 per 1M tokens), Claude 3.5 Sonnet ($3.00/$15.00), and Gemini 1.5 Pro ($1.25/$5.00) at production scale. Includes monthly cost projections at 10,000 requests/day, tokenizer accuracy notes (tiktoken, Anthropic BPE, SentencePiece), and cost reduction strategies (prompt caching, structured outputs, model routing, batch API).

### Prompt Caching in GPT-4o, Claude Sonnet 4.6, and Gemini 2.5 Pro: How It Works and What You Save

URL: https://contextiq.trango-compute.com/blog/prompt-caching-gpt4o-claude-gemini

Explains how GPT-4o automatic prompt caching (50% discount, 1,024-token minimum prefix), Claude Sonnet 4.6 cache_control blocks (25% cost on hits, 5-minute TTL), and Gemini 2.5 Pro context caching (pinned prefix, 1-hour minimum) reduce repeated-prefix costs for system prompts, RAG few-shot blocks, and long documents.

Entities covered: GPT-4o, Claude Sonnet 4.6, Claude Haiku 4.5, Gemini 2.5 Pro, Gemini 2.5 Flash, cache_control, prompt caching, LangGraph, tiktoken.

### What is PKCE and Why Every OAuth 2.0 App Needs It

URL: https://contextiq.trango-compute.com/blog/pkce-oauth2-authorization-code-flow

Explains RFC 7636 Proof Key for Code Exchange: code_verifier, SHA-256 code_challenge, and why PKCE prevents authorization code interception attacks. Covers which providers (Auth0, Okta, AWS Cognito, Keycloak, Azure AD) require PKCE under OAuth 2.1 and how to verify support via the code_challenge_methods_supported field in the OIDC discovery document.

Entities covered: PKCE, RFC 7636, OAuth 2.1 RFC 9700, Auth0, Okta, AWS Cognito, Keycloak, Azure AD, code_verifier, code_challenge, S256, openid-configuration.

### Model Context Protocol (MCP): How Claude, Cursor, and AI Agents Connect to External Tools

URL: https://contextiq.trango-compute.com/blog/model-context-protocol-mcp-ai-agents

Explains Anthropic's Model Context Protocol (MCP) — JSON-RPC 2.0 over stdio or SSE — covering the three primitive types (tools, resources, prompts), the tools/list discovery call, and tools/call invocation. Covers MCP hosts Claude Desktop, Cursor, Cline, Zed, Windsurf, and framework integrations with LangGraph and OpenAI Agents SDK.

Entities covered: MCP, Model Context Protocol, Claude Desktop, Cursor, Cline, Zed, Windsurf, LangGraph, OpenAI Agents SDK, CrewAI, AutoGen, Google ADK, JSON-RPC 2.0, gen_ai.tool.name, OpenTelemetry.

### text-embedding-3-small vs text-embedding-ada-002 vs BGE-large-en-v1.5: Which Embedding Model for RAG?

URL: https://contextiq.trango-compute.com/blog/embedding-model-comparison-rag-text-embedding-3-bge

Practical comparison of OpenAI text-embedding-3-small ($0.02/1M tokens), text-embedding-ada-002 ($0.10/1M tokens), text-embedding-3-large, BGE-large-en-v1.5, and BGE-M3 for RAG pipelines — covering MTEB BEIR scores, token limits, dimension counts, and how the 512-token BGE limit interacts with chunk size in LangChain and LlamaIndex.

Entities covered: text-embedding-3-small, text-embedding-ada-002, text-embedding-3-large, BGE-large-en-v1.5, BGE-M3, MTEB, BEIR, Pinecone, Weaviate, pgvector, LangChain, LlamaIndex, sentence-transformers.

### Auth0 vs Okta vs AWS Cognito: OIDC Discovery Endpoint Differences Every Developer Should Know

URL: https://contextiq.trango-compute.com/blog/auth0-okta-aws-cognito-oidc-discovery-differences

Maps the discovery document URL patterns for Auth0, Okta (org-level vs custom authorization server), AWS Cognito (region + User Pool ID path), Keycloak (realm-scoped), and Azure AD Entra ID (tenant-specific vs /common/ endpoint). Explains how JWKS URI paths, supported scopes, and code_challenge_methods_supported differ across providers.

Entities covered: Auth0, Okta, AWS Cognito, Keycloak, Azure AD, Entra ID, PingIdentity, openid-configuration, JWKS, code_challenge_methods_supported, RS256, OAuth 2.0, PKCE.

### Why the Same Prompt Has Different Token Counts on GPT-4o, Claude, and Gemini

URL: https://contextiq.trango-compute.com/blog/why-token-counts-differ-gpt-4o-claude-gemini-tokenizers

Explains why token counts for identical text differ across model families: byte-pair encoding, vocabulary size, and training-corpus effects in o200k_base (GPT-4o), cl100k_base (GPT-4), Anthropic's proprietary tokenizer (Claude 3.5 Sonnet), SentencePiece (Gemini 1.5 Pro), and the open Llama 3.1 / DeepSeek V3 tokenizers. Covers why code, non-English text, and JSON widen the gap and how tokenizer differences invalidate naive per-million-token price comparisons.

Entities covered: tiktoken, o200k_base, cl100k_base, SentencePiece, byte-pair encoding, GPT-4o, Claude 3.5 Sonnet, Gemini 1.5 Pro, Llama 3.1, DeepSeek V3, token pricing, context windows.

### SPF vs DKIM vs DMARC: How Email Authentication Actually Works

URL: https://contextiq.trango-compute.com/blog/spf-dkim-dmarc-email-authentication-explained

Explains how SPF, DKIM, and DMARC work together to stop email spoofing: SPF authorizes sending servers and ends in a qualifier (-all/~all/?all/+all) deciding what happens to everyone else, DKIM cryptographically signs outgoing mail, and DMARC is the record that actually enforces a quarantine or reject policy when both fail.

Entities covered: SPF, RFC 7208, DKIM, RFC 6376, DMARC, RFC 7489, code_challenge_methods_supported, email spoofing, phishing, DNS TXT records.

### CAA Records Explained: Stopping Unauthorized Certificate Authorities From Issuing Certs for Your Domain

URL: https://contextiq.trango-compute.com/blog/caa-records-certificate-authority-authorization-explained

Explains RFC 8659 CAA records: the issue, issuewild, and iodef tags, why the CA/Browser Forum has required CAs to check CAA before issuing since 2017, and why having no CAA record means any of roughly 100 public certificate authorities can lawfully issue a certificate for a domain.

Entities covered: CAA, RFC 8659, Let's Encrypt, DigiCert, Sectigo, GlobalSign, RFC 3597, Certificate Transparency, TLS mis-issuance.

### How to Find Out Which DNS Host and Mail Provider Any Domain Uses

URL: https://contextiq.trango-compute.com/blog/check-dns-host-mail-provider-cloudflare-route53-godaddy

Explains how NS record hostname patterns reveal a domain's DNS host (Cloudflare, AWS Route 53, GoDaddy, Namecheap) and MX record hostname patterns reveal its mail provider (Google Workspace, Microsoft 365, Zoho Mail), and why this is routine reconnaissance for security audits, M&A vendor-risk review, and migration verification.

Entities covered: NS records, MX records, Cloudflare, AWS Route 53, GoDaddy, Namecheap, Google Workspace, Microsoft 365, DNS hosting.

## Keywords & Related Topics

ContextIQ's tools and blog span four practitioner disciplines. Related search terms and topics an AI engineer, security engineer, or platform team might use to find this suite:

**Context engineering:** context engineering, context window management, token budget design, prompt engineering, system prompt design, few-shot example design, in-context learning, RAG optimization, retrieval augmented generation, context compaction, context compression, memory architecture, working memory, episodic memory, semantic memory, procedural memory, long-term memory, short-term memory, conversation history truncation, context window overflow, context rot, lost-in-the-middle problem, needle-in-a-haystack evaluation, structured context assembly, dynamic context injection, context caching, prompt caching, retrieval precision tuning, chunking strategy design, embedding model selection.

**AI engineering:** AI engineering, LLM engineering, LLMOps, MLOps for LLMs, production LLM applications, agentic AI, AI agents, multi-agent systems, agent orchestration, tool calling, function calling, structured outputs, agent frameworks, LangGraph, CrewAI, AutoGen, OpenAI Agents SDK, Google ADK, LlamaIndex, Haystack, Semantic Kernel, agent evaluation, LLM observability, agent tracing, OpenTelemetry GenAI semantic conventions, prompt versioning, model routing, fallback routing, LLM cost optimization, token cost analysis, inference cost modeling, batch API usage.

**Preflight and readiness tooling:** agent readiness check, deployment readiness check, pre-deployment validation, agent discoverability, service discovery, well-known URI convention, .well-known endpoint audit, health check endpoint, configuration validation, schema validation, spec linting, protocol conformance testing, API readiness check, launch checklist, go-live checklist, smoke testing, integration testing, contract testing, discoverability audit, llms.txt validator, robots.txt validator, sitemap validation, manifest validation, agent card validation, MCP server card validation, ai-catalog.json validation, agent card lint, pre-launch checklist, cross-protocol readiness scan.

**Security tooling:** SSRF protection, server-side request forgery prevention, CSRF protection, cross-site request forgery prevention, per-IP rate limiting, DDoS mitigation, penetration testing, security scanning, vulnerability scanning, identity provider audit, OAuth 2.0 security review, OAuth 2.1, PKCE (Proof Key for Code Exchange), JWKS inspection, JSON Web Key Set validation, JWT validation, OpenID Connect discovery audit, IAM audit, identity and access management, zero trust architecture, SPIFFE, SOC 2 attestation, security posture assessment, attack surface mapping, secrets detection, credential leakage detection, API security testing, auth misconfiguration detection, private IP / internal network blocking, DNS-over-HTTPS resolution guard, open proxy prevention, SPF record check, DKIM signature validation, DMARC policy audit, email spoofing prevention, CAA record lookup, certificate authority authorization, TLS certificate mis-issuance prevention, DNS reconnaissance, DNS host fingerprinting, mail provider identification.

## Pricing

- Free: all tools, unlimited use, no sign-up required
- Pro ($5/month USD): export diagrams, share via public link, early access to new tools

## Company

Trango Compute Inc.
LinkedIn: https://www.linkedin.com/company/trango-compute
Contact: hello@trango-compute.com

## Optional

- Sitemap: https://contextiq.trango-compute.com/sitemap.xml
- Robots: https://contextiq.trango-compute.com/robots.txt