I am speed.
Fast.com Style but for LLMs
Last verified:
What is I am speed.?
I am speed. is a fast.com-style benchmarking tool for LLM APIs that measures two critical performance metrics directly in your browser: Time to First Token (TTFT) and tokens-per-second throughput. The tool provides live streaming output with real-time metrics as tokens stream from the LLM, giving developers and performance engineers concrete numbers instead of guessing whether an LLM feels fast or slow.
I am speed. pricing
Pricing model: Freemium
I Am Speed is completely free and open-source. The tool is browser-based with no backend, no subscription fees, and no paid tiers. It uses your own OpenAI or Anthropic API key which you configure in the settings panel, so you pay only the standard per-token costs from those providers directly. The source code is MIT licensed and available on GitHub at github.com/QAInsights/iamspeed.dev. You can also run it locally for free by cloning the repository, installing dependencies with npm install, and starting the development server with npm run dev.
I am speed. pros
- Measures Time to First Token (TTFT) precisely
- Tracks tokens-per-second throughput continuously
- Live streaming output with real-time metrics
- No backend required - runs entirely in browser
- No data collection or transmission
- API key stored locally with AES-GCM encryption
- API key never leaves your machine
- Minimal fast.com-inspired UI design
- Supports OpenAI providers (GPT-4o, GPT-4.1)
- Supports Anthropic providers (Claude Sonnet, Claude Haiku)
- Extensible ProviderAdapter architecture for new providers
- Quick benchmark results in about 10 seconds
- Open-source with MIT license
- Available on GitHub for contributions
- Responsive design works on different screen sizes
- Simple one-click Run button interface
- Settings panel for easy API key configuration
- Provider-agnostic benchmark engine
- Clean separation of concerns in architecture
- Under 1 minute to run locally
I am speed. cons
- Only supports OpenAI and Anthropic currently
- No historical results tracking yet
- No model comparison mode available
- No support for Gemini provider yet
- No Groq provider support
- No Mistral provider support
- No local Ollama model support yet
- Cannot share result links with team
- No prompt customization for different workloads
- Single benchmark runs only - no batch testing
- No percentage percentiles like professional tools
- Browser-based only - no mobile app
- Requires manual API key entry each time
- No backend means no cloud synchronization
- Limited to standard prompt length
Frequently asked questions about I am speed.
What metrics does I Am Speed measure?
I Am Speed measures two key performance metrics: Time to First Token (TTFT), which is the time between sending your request and receiving the very first token back from the model, reflecting how quickly the LLM starts generating; and tokens-per-second throughput, which is the rate at which the model streams tokens to you after the first one arrives, representing the output speed. Together these give the full picture of LLM API performance.
Why is TTFT important for LLM applications?
TTFT is what users actually feel as the awkward pause before anything appears on screen. For interactive applications, keeping TTFT low is critical. A high TTFT means user frustration. Reasoning models with extended thinking or deep think modes can inflate TTFT by 5x to 30x because of additional compute happening before the first visible token arrives.
How is tokens-per-second different from TTFT?
Tokens-per-second measures the output speed after the first token arrives - how fast text appears fluidly on screen. High tokens per second means text appears fast and fluid, while low throughput feels choppy and slow even if TTFT was acceptable. TTFT is about latency (when does it start), while throughput is about sustained delivery rate (how fast does it continue).
Where is my API key stored?
Your API key is stored locally in your browser using AES-GCM encryption. It never leaves your machine - there is no backend, no data transmission, and no server storage. The encryption ensures your key is secure in your browser's local storage.
Which LLM providers are supported?
Currently I Am Speed supports OpenAI providers (including GPT-4o, GPT-4.1, and compatible models) and Anthropic providers (including Claude Sonnet, Claude Haiku, and more). The extensible ProviderAdapter architecture makes it straightforward to add new providers like Gemini, Groq, Mistral, or local Ollama models.
How do I run I Am Speed locally?
Running locally takes under a minute: 1) Clone the repository with git clone https://github.com/QAInsights/iamspeed.dev.git and cd into it, 2) Install dependencies with npm install, 3) Start the development server with npm run dev, 4) Head to http://localhost:4321 in your browser, 5) Click the gear icon (Settings) and enter your OpenAI or Anthropic API key, 6) Hit Run to see tokens stream with live tokens/sec counter.
How do I add a new provider like Gemini or Groq?
The architecture makes adding providers clean: 1) Create a new adapter file in src/lib/providers/ that implements the ProviderAdapter interface, 2) Register it in src/lib/providers/index.ts, 3) Add the provider metadata (name, models, etc.) to src/lib/config.ts. No changes to the benchmark engine or UI logic are needed - the adapter pattern keeps concerns separated cleanly.
Is I Am Speed free to use?
Yes, I Am Speed is completely free and open-source with MIT license. There are no subscription fees, paid tiers, or subscription requirements. You only pay the standard per-token costs from OpenAI or Anthropic directly to those providers for your API usage. The tool itself has no backend and no monetization.
How long does a benchmark take?
You will have your tokens-per-second number in about 10 seconds. The tool is designed for quick, lightweight benchmarking - open it on a Tuesday afternoon and immediately get concrete numbers without the heavy lifting of tools that compare hundreds of models.
What's next for I Am Speed development?
Planned additions include: more providers (Gemini, Groq, Mistral, and local Ollama support), historical results to run multiple benchmarks and compare over time, model comparison mode to run the same prompt across two models side by side, shareable result links to generate URLs for your team, and prompt customization to choose input prompt length for simulating different workloads. Pull requests for contributions are welcome on GitHub.