TypeSafe AI Debuts Non-Chat Model Jev to Slash LLM Inference Costs

Fireship

By stripping conversational text generation in favor of strictly typed schema outputs, Jev eliminates hallucinations and cuts operational costs by 400 times for classification tasks.

AI-assisted summary of An ex-OpenAI researcher just deleted language from the LLM... — original source. Check the original for full context.

Source published: 2026-09-21

Key ideas

Ex-OpenAI researcher Diogo Almeida and startup TypeSafe AI launched Jev with $40 million in funding, introducing a non-conversational AI model that strips out natural language generation entirely. (1:20)
Positioned as a rapid 'System 1' classifier, Jev claims 200x faster inference and 400x lower operational costs than standard reasoning LLMs, with mathematically enforced schemas and free output tokens. (0:00)
To counter typical LLM overconfidence and sycophancy, Jev uses Reinforcement Learning for Calibrated Decisions (RLCD) to attach a numerical confidence percentage to its answers. (1:20)
The open-source community rapidly replicated Jev's functionality with OpenJev, extracting option probabilities in a single forward pass from a frozen Qwen-4B model on consumer GPUs and in-browser WebGPU. (3:40)

Detailed notes

## Background Published by the Fireship channel on YouTube on September 21, 2026, this video covers ex-OpenAI researcher Diogo Almeida emerging from two years in stealth to launch Jev through his startup TypeSafe AI. According to the description, Jev is a 'System 1' AI model that strips out natural language generation and coding abilities entirely, claiming to deliver 200x faster speeds, 400x lower costs, and zero hallucinations.

## TL;DR The video examines Jev, a newly unveiled AI model designed to eliminate the verbose, costly token generation of standard frontier LLMs by functioning strictly as a high-speed classifier. Operating on a 'System 1' gut-instinct framework, Jev enforces type safety by restricting responses to a choice, a score, or null, accompanied by calibrated confidence metrics rather than conversational text. While TypeSafe AI raised $40 million behind closed doors without publishing its architecture, the machine learning community quickly criticized its resemblance to established zero-shot classification methods. In response, open-source developers rapidly created OpenJev, successfully replicating the model's functionality on consumer hardware using a frozen Qwen-4B model and a single forward pass.

## Atmosphere & style The video carries Fireship's signature rapid-fire, irreverent tech satire, poking fun at the relentless AI hype cycle and the absurdity of bloated models burning thousands of tokens to answer a simple boolean question. The delivery is punchy and sardonic, contrasting the inflated promises of frontier chat models with pragmatic developer frustrations. It feels brisk, cynical, and entertaining, blending sharp technical explainers with internet humor and community-driven skepticism.

## Bulletin - [01:20](https://www.youtube.com/watch?v=TbkUKCm3CHQ&t=80s) Ex-OpenAI researcher Diogo Almeida and startup TypeSafe AI launched Jev with $40 million in funding, introducing a non-conversational AI model that strips out natural language generation entirely. - [00:00](https://www.youtube.com/watch?v=TbkUKCm3CHQ&t=0s) Positioned as a rapid 'System 1' classifier, Jev claims 200x faster inference and 400x lower operational costs than standard reasoning LLMs, with mathematically enforced schemas and free output tokens. - [01:20](https://www.youtube.com/watch?v=TbkUKCm3CHQ&t=80s) To counter typical LLM overconfidence and sycophancy, Jev uses Reinforcement Learning for Calibrated Decisions (RLCD) to attach a numerical confidence percentage to its answers. - [03:40](https://www.youtube.com/watch?v=TbkUKCm3CHQ&t=220s) The open-source community rapidly replicated Jev's functionality with OpenJev, extracting option probabilities in a single forward pass from a frozen Qwen-4B model on consumer GPUs and in-browser WebGPU.

## Key takeaways - [00:00](https://www.youtube.com/watch?v=TbkUKCm3CHQ&t=0s) Traditional large language models suffer from verbosity, often generating thousands of reasoning tokens and incurring high costs for simple boolean questions. - [00:00](https://www.youtube.com/watch?v=TbkUKCm3CHQ&t=0s) Jev eliminates conversational language generation, acting strictly as a high-speed classifier with free output tokens and zero risk of schema hallucinations. - [00:00](https://www.youtube.com/watch?v=TbkUKCm3CHQ&t=0s) TypeSafe AI claims Jev delivers up to 200x faster execution and 400x lower costs compared to frontier reasoning models. - [01:20](https://www.youtube.com/watch?v=TbkUKCm3CHQ&t=80s) TypeSafe AI was founded by Diogo Almeida, an early instruction-tuning researcher at OpenAI, and launched following a $40 million funding round. - [01:20](https://www.youtube.com/watch?v=TbkUKCm3CHQ&t=80s) Framed around Daniel Kahneman's 'System 1' concept, Jev is designed for rapid gut-instinct decisions rather than slow, deliberate 'System 2' reasoning. - [01:20](https://www.youtube.com/watch?v=TbkUKCm3CHQ&t=80s) Outputs are strictly constrained to a type-safe schema limited to three formats: a choice, a score, or null (representing a boolean). - [01:20](https://www.youtube.com/watch?v=TbkUKCm3CHQ&t=80s) Because type safety does not ensure infallible correctness, Jev integrates Reinforcement Learning for Calibrated Decisions (RLCD) to provide calibrated probability scores. - [01:20](https://www.youtube.com/watch?v=TbkUKCm3CHQ&t=80s) The model is optimized for high-frequency, low-latency programmatic workloads, such as real-time content moderation, video game NPC logic, and interactive calculators. - [03:40](https://www.youtube.com/watch?v=TbkUKCm3CHQ&t=220s) TypeSafe AI faced community criticism for keeping Jev's architecture proprietary while leveraging concepts resembling decade-old zero-shot classification research. - [03:40](https://www.youtube.com/watch?v=TbkUKCm3CHQ&t=220s) Open-source clone OpenJev proved that Jev's behavior can be replicated without proprietary pretraining by pulling logits directly from a frozen Qwen-4B model. - [03:40](https://www.youtube.com/watch?v=TbkUKCm3CHQ&t=220s) Extracting classification probabilities in a single forward pass bypasses the autoregressive loop, running efficiently on consumer hardware like an RTX 3090 or inside browsers using WebGPU. - [04:22](https://www.youtube.com/watch?v=TbkUKCm3CHQ&t=262s) Video infrastructure service Mux offers API-driven video encoding, streaming, automated transcripts, and AI-powered workflow automation via Mux Robots.

## Detailed walkthrough ### [00:00](https://www.youtube.com/watch?v=TbkUKCm3CHQ&t=0s) Deleting Language from the Large Language Model

Every week in artificial intelligence brings another proclamation that everything has changed forever, but this time the shift is genuinely unusual. An ex-OpenAI researcher responsible for the early instruction-tuning breakthroughs that directly led to ChatGPT has emerged from two years in stealth to launch a frontier model. In stark contrast to prevailing models, this new creation cannot converse, cannot write code, cannot draft college essays, and "will never tell you you're absolutely right." Its name is Jev.

The driving philosophy behind Jev is addressing what many developers see as the fatal design flaw of contemporary large language models: they refuse to keep their answers concise. Asking a flagship model a basic boolean question—such as requesting a simple `true` or `false`—frequently results in the system ruminating over 4,000 tokens, finding an unprompted third option, and racking up an 11-cent bill on the user's credit card. Jev circumvents this by deleting generative natural language entirely from the equation. Stripped down to its core, it acts as a high-speed classifier boasting 200x faster inference, 400x cheaper operational costs, zero hallucination risk, and entirely free output tokens.

```mermaid flowchart TD accTitle: Comparison of Traditional LLMs vs Jev System 1 accDescr: Flowchart contrasting the token-heavy generative path of System 2 LLMs with Jev's direct typed output.

subgraph Traditional["System 2: Traditional LLMs"] A["Query & Context"] --> B["Autoregressive Generation"] B --> C["Thousands of Reasoning Tokens"] C --> D["Unstructured Text Output"] end

subgraph JevArchitecture["System 1: TypeSafe AI Jev"] E["Typed Question & Context"] --> F["Single Forward-Pass Classifier"] F --> G{"Fixed Schema Output"} G --> H["Choice"] G --> I["Score"] G --> J["Null (Boolean)"] G --> K["Calibrated Confidence"] end ```

- **Core Performance Claims:** Up to 200x faster execution and roughly 400x to 440x lower cost than heavyweight frontier reasoning models. - **Output Economics:** By eliminating conversational token generation, output tokens are effectively free and schema errors are mathematically impossible. - **Target Workloads:** Aimed directly at replacing bloated models for high-frequency, instinctual, binary or multiple-choice programmatic decisions.

---

[01:20](https://www.youtube.com/watch?v=TbkUKCm3CHQ&t=80s) How Jev Works: System 1 Thinking and Type Safety

Jev was built by former OpenAI researcher Diogo Almeida and his startup, TypeSafe AI, which launched backed by a fresh $40 million funding round. The name of the company offers the clearest blueprint of how the system functions: while it still ingests an arbitrary question alongside unstructured contextual data, it behaves like a type-safe programming language like TypeScript. Rather than opening an open-ended dialogue, requests are framed as strongly typed questions bound strictly to one of three return schemas: a choice, a score, or null (which functions as a definitive yes or no). Schema compliance is absolute, rendering malformed syntax and hallucinations structurally impossible.

TypeSafe AI frames Jev as a "System 1" model, drawing on Daniel Kahneman's framework in *Thinking, Fast and Slow*. While legacy "System 2" reasoning models—satirized here as systems like GPT-6 or Claude Fable that consume 40,000 tokens simply deciding how to name a variable—are slow and deliberate, System 1 operates on rapid gut instinct. This capability provides immediate utility for real-time applications. For instance, in an app moderation workflow on an app like "Horse Tinder", where non-horse accounts like donkeys violate the terms of service, Jev can instantly flag and auto-ban offending profiles by returning a null response to whether the image depicts a horse. Beyond moderation, developers are using Jev's ultra-low latency for real-time video game NPC decision-making and building real-time interactive AI calculators.

Crucially, type safety does not mean infallible accuracy or deterministic responses; querying identical context multiple times can yield differing results. To prevent the unearned overconfidence typical of chat models—which are fine-tuned via RLHF to sound appealing to humans, often leaving them "wrong with the confidence of Kanye"—Jev employs Reinforcement Learning for Calibrated Decisions (RLCD). This outputs an explicit calibrated confidence metric alongside each decision:

---

[03:40](https://www.youtube.com/watch?v=TbkUKCm3CHQ&t=220s) Architecture Secrets, Controversy, and Open-Source Clones

The proprietary mechanics of Jev remain shrouded in secrecy. TypeSafe AI's leadership is keeping the actual architecture "close to the chest," merely teasing that an academic paper might arrive sometime in the future. This lack of transparency has sparked pushback across the machine learning community. Skeptics point out that the underlying paradigm bears a striking resemblance to zero-shot classifiers pioneered over a decade ago by researchers like Jian Yang, none of whom received credit in TypeSafe AI's release materials. Other researchers have noted that pre-existing papers published within the past year detailed functionally identical classification methodologies.

The open-source community responded almost immediately with reverse-engineered alternatives. A project dubbed OpenJev demonstrated that the entire interface and behavior could be replicated without any proprietary pretraining. By extracting option probabilities directly from a frozen Qwen-4B model during a single forward pass, the clone operates with remarkable efficiency:

- **Minimal Compute Overhead:** The entire extraction pipeline can be run locally on a consumer-grade Nvidia GeForce RTX 3090 without specialized enterprise clusters. - **Single Forward Pass:** Evaluates classification choices without the multi-token autoregressive decoding loop that inflates traditional LLM runtime. - **Browser Accessibility:** Community implementations have already packaged the technique into WebGPU demos executable locally inside modern web browsers.

---

[04:22](https://www.youtube.com/watch?v=TbkUKCm3CHQ&t=262s) Sponsor: Mux and Video Automation

The broadcast transitions to highlighting video infrastructure provider Mux, framed as the antidote to wrestling directly with complex tools and "getting jump-scared by FFmpeg." Mux offers developers an API-first approach to uploading, hosting, and streaming video without the overhead of manually managing low-level encoding pipelines or bespoke delivery infrastructure.

Beyond streaming, Mux provides automated data enrichment. Uploading video assets immediately generates synchronized transcripts, visual storyboards, thumbnails, dynamic clips, and deep structured metadata analyzing video content. These capabilities integrate into "Mux Robots," an automated AI-driven workflow layer designed to execute translation, multilingual dubbing, and content moderation at scale. Through declarative Directives, developers configure automation pipelines once to run on all subsequent uploads, paying strictly for the processing jobs executed. Supported by clients such as Perplexity and Patreon, Mux provides a free entry tier offering 10 videos and 100,000 delivery minutes per month without requiring a credit card, alongside a $50 introductory credit.

## Notable quotes > [00:00](https://www.youtube.com/watch?v=TbkUKCm3CHQ&t=0s) will never tell you you're absolutely right. — Fireship

> [01:20](https://www.youtube.com/watch?v=TbkUKCm3CHQ&t=80s) wrong with the confidence of Kanye — Fireship

> [03:40](https://www.youtube.com/watch?v=TbkUKCm3CHQ&t=220s) close to the chest — Fireship

> [04:22](https://www.youtube.com/watch?v=TbkUKCm3CHQ&t=262s) getting jump-scared by FFmpeg — Fireship

## Mentioned Diogo Almeida, Jev, TypeSafe AI, OpenAI, ChatGPT, Daniel Kahneman, Thinking, Fast and Slow, TypeScript, RLCD, Jian Yang, OpenJev, Qwen-4B, Nvidia GeForce RTX 3090, WebGPU, Mux, FFmpeg, Mux Robots, Perplexity, Patreon

## Video description Mux is the video API that translates audio and answers questions about your video. Get $50 in free credits: https://mux.com/fireship

Ex-OpenAI researcher Diogo Almeida spent two years in stealth building Jev, a "System 1" AI model that can't talk or write code but claims to be 200x faster, 400x cheaper, and hallucination-free. Let's dive in.

Want more Fireship?

🗞️ Newsletter: https://bytes.dev 🧠 Courses: https://fireship.dev

[Source](https://www.youtube.com/watch?v=TbkUKCm3CHQ)

中文简报

TypeSafe AI推出非对话模型Jev，大幅削减大语言模型推理成本 Jev摒弃了对话式文本生成，转而采用严格类型的模式输出，在分类任务中消除了幻觉并将运营成本降低了400倍。该视频分析了新推出的AI模型Jev。该模型旨在通过纯粹作为高速分类器运行，消除标准前沿大语言模型冗长且昂贵的Token生成。在“系统1”直觉框架下运行的Jev通过强制执行类型安全，将响应限制为选项、分数或空值（null），并附带校准后的置信度指标，而非对话文本。尽管TypeSafe AI在未公开其架构的情况下闭门筹集了4000万美元，但机器学习社区迅速指出其与既有零样本分类方法的相似性并提出了批评。对此，开源开发者迅速打造了OpenJev，使用冻结的Qwen-4B模型和单次前向传播，在消费级硬件上成功复现了该模型的功能。前OpenAI研究员Diogo Almeida与初创公司TypeSafe AI在获得4000万美元融资后推出了Jev，引入了一种完全剥离自然语言生成的非对话式AI模型。 (1:20) Jev被定位为快速的“系统1”分类器，声称推理速度比标准推理大语言模型快200倍，运营成本低400倍，具有数学上强制执行的模式且输出Token免费。 (0:00) 为应对传统大语言模型的过度自信和阿谀奉承现象，Jev使用校准决策强化学习（RLCD）为其答案附带数值置信度百分比。 (1:20) 开源社区通过OpenJev迅速复现了Jev的功能，在消费级GPU和浏览器内WebGPU上，仅通过冻结的Qwen-4B模型单次前向传播便提取出选项概率。 (3:40)

Reading summary

Former OpenAI researcher Diogo Almeida and his startup TypeSafe AI have introduced Jev, a non-conversational AI model that strips out natural language generation to deliver fast, low-cost classification without output token costs or syntax hallucinations. Eliminating Generative Text for Targeted Workloads (0:00) Contemporary large language models frequently exhibit an architectural inefficiency when handling simple boolean or classification tasks: asking a basic question can prompt an autoregressive model to produce thousands of unnecessary reasoning tokens, driving up latency and infrastructure costs. Jev departs from this paradigm by entirely removing generative conversational outputs. Instead, it operates strictly as a rapid classifier designed to evaluate unstructured input and return fixed programmatic responses. Type Safety, Low Latency, and Confidence Calibration (1:20) Backed by a $40 million funding round, TypeSafe AI structures Jev around Daniel Kahneman's concept of 'System 1' fast-instinct thinking. Unlike generative 'System 2' models that produce freeform text, Jev constrains its outputs strictly to three structured data types: a choice, a score, or null (serving as a binary true/false). This architectural limitation makes schema violations structurally impossible, targeting real-time use cases such as content moderation, video game non-player character decisions, and interactive calculators. While traditional models fine-tuned with reinforcement learning from human feedback (RLHF) often generate assertive but incorrect answers, Jev does not guarantee deterministic or infallible outcomes. To manage accuracy without conversational rhetoric, the platform uses Reinforcement Learning for Calibrated Decisions (RLCD), which pairs every structured return with an explicit, calibrated numerical confidence percentage. Transparency Concerns and Open-Source Replication (3:40) TypeSafe AI has kept Jev's proprietary architecture undisclosed, promising only a future academic paper. This lack of disclosure has drawn skepticism from the machine learning community, where critics observe that the technique closely mirrors zero-shot classification methodologies developed over a decade ago by researchers such as Jian Yang, as well as several papers published within the past year that received no formal acknowledgment in the launch. In response, the open-source community developed OpenJev, a reverse-engineered implementation demonstrating that Jev's core functionality does not require proprietary pretraining. By extracting option probabilities from a frozen Qwen-4B model in a single forward pass, OpenJev bypasses autoregressive decoding loops entirely. The workflow can run locally on consumer-grade hardware such as an Nvidia GeForce RTX 3090 or inside web browsers using WebGPU. While Jev offers substantial operational efficiencies for discrete classification tasks, TypeSafe AI faces lingering questions regarding its technical novelty after open-source developers quickly replicated its single-pass classification mechanism using existing open-weight models.

Source quotes

[0:00] Fireship: will never tell you you're absolutely right. [1:20] Fireship: wrong with the confidence of Kanye [3:40] Fireship: close to the chest [4:22] Fireship: getting jump-scared by FFmpeg

Original transcript

[0:00] Last week, everything about AI changed [0:02] forever. I realize everything about AI [0:04] changes forever almost every week, but [0:06] this time AI changed forever more than [0:07] usual because one of the OpenAI [0:09] researchers behind the [0:10] instruction-following work that [0:12] eventually became ChatGPT just released [0:14] the next big frontier model after 2 [0:16] years in stealth development. A model [0:18] that can't talk, a model that can't [0:20] write code, a model that can't write [0:21] your college essays, and a model that [0:23] will never tell you you're absolutely [0:25] right. Its name is Jev. [0:27] >> My name is Jev. [0:29] >> And this is a huge deal because large [0:31] language models have one fatal flaw. [0:33] They won't shut the hell up. You give [0:34] Fable or Astra a simple instruction like [0:36] return true or false, and it'll discover [0:38] a third option after thinking for 4,000 [0:40] tokens and then charge your credit card [0:42] 11 cents. Jev fixed this problem with a [0:44] radical solution. It deleted language [0:46] from the large language model, and the [0:48] result is a new type of classifier [0:50] that's 200 times faster, 400 times [0:52] cheaper, with free output tokens and [0:54] zero hallucinations. Sounds too good to [0:56] be true. So, in today's video, we'll [0:58] take a look at Jev's code, its [1:00] trust-me-bro benchmarks, and the dude [1:01] who says he built an open-source Jev [1:03] over a year ago. It is September 21st, [1:05] 2026, and you're watching The Code [1:07] Report. The big AI duopoly is literally [1:09] shaking right now because Jev is a [1:11] cheaper, faster way to solve basically [1:13] any AI problem that requires a quick [1:16] gut-instinct decision. [1:19] >> It's freight. [1:20] >> But, the first thing you need to know is [1:22] that Jev was created by an ex-OpenAI [1:24] researcher, Diogo Almeida, and his [1:26] company TypeSafe AI, which just raised [1:29] $40 million. But, the company name is [1:31] the first clue to what Jev really is. [1:33] Like a regular large language model, you [1:35] send it a question and some context, [1:37] like a bunch of unstructured text. [1:39] However, it differs because it behaves [1:42] more like a type-safe programming [1:43] language like TypeScript. The question [1:45] you send to the model is a strongly [1:47] typed question that must return a [1:49] specific shape, one of three shapes [1:51] actually, a choice, a score, and a null, [1:54] which is basically just a yes or no. Its [1:56] schema matching is guaranteed and a type [1:58] error would be mathematically impossible [2:00] to produce. They call Jev a system one [2:02] model, which is a name that comes from [2:04] Daniel Kahneman's Thinking Fast and [2:06] Slow. A system one model is fast and [2:08] goes from gut instinct, while a system [2:10] two model is slow and deliberate, like [2:12] these old antique reasoning models like [2:14] GPT-6 and Claude Fable that burn 40,000 [2:17] tokens to name a variable. But the [2:19] difference is huge for app developers [2:20] like myself who want to integrate fast [2:22] cheap AI into their applications. Like [2:24] on Horse Tinder, we recently had an [2:26] issue of some donkeys trying to use the [2:28] app, which is strictly forbidden in the [2:29] terms of service. Thanks to Jev, we [2:32] implemented an AI moderation step that [2:34] will insta-ban any account that is not a [2:36] horse, which is accomplished by [2:37] returning a null response to is this a [2:40] horse? Not only is it extremely fast, if [2:42] we are to believe these TMBBs, but more [2:44] importantly, it's off the charts cheap, [2:46] like 440 times cheaper than one of the [2:48] big brand models. In fact, it's so fast [2:51] and cheap that you can even use it for [2:52] real-time applications. Like developers [2:55] are already using it to implement NPC [2:56] behavior in video games. And this guy [2:58] even used it to build the world's first [3:00] real-time AI calculator. But just [3:02] because the output is type safe, that [3:04] doesn't mean it's always correct. And [3:06] it's not even deterministic. Like you [3:07] could send it the exact same question in [3:09] the exact same context and get different [3:12] results, just like any regular large [3:14] language model. But to get an idea of [3:15] the response quality, it returns [3:17] something called the calibrated [3:18] confidence number. The chat models are [3:20] trained to please human readers, and [3:22] humans love confidence, which is how we [3:23] got models that are wrong with the [3:25] confidence of Kanye. Jev gained its [3:27] confidence through a technique called [3:28] RLCD, or reinforcement learning for [3:31] calibrated decisions. This means every [3:33] response provides a confidence value, [3:35] like say 60%, which means 60% of the [3:38] time it's right every time. But the big [3:40] question is how does Jev actually work? [3:42] Well, nobody knows for sure because the [3:44] CEO says the architecture is staying [3:46] close to the chest with a paper possibly [3:48] coming in the future, maybe. But Jev [3:50] also has some doubters. Some people say [3:52] it's no different than zero-shot [3:53] classifiers of the past, but the company [3:55] gives no credit to the original pioneers [3:57] of this technique like Jin Yang who were [3:59] building zero-shot classifiers over a [4:01] decade ago. In addition, this guy claims [4:03] his paper he released a year ago is the [4:05] exact same thing as Jeb. And another [4:07] developer already built OpenJeb which [4:09] reproduces the entire interface by [4:11] reading option probabilities off a [4:13] frozen Qwen-4B model in a single forward [4:15] pass. It requires no new training and [4:18] can run on a 3090. And there's even a [4:19] web GPU demo you can run in your browser [4:21] right now. It's an awesome time to be a [4:23] developer, which is why you need to [4:24] check out Mux, the sponsor of today's [4:26] video. Their highly customizable API is [4:29] by far the easiest way to add video [4:31] features to your application without [4:32] getting jump-scared by FFmpeg. We've [4:35] used it for years to handle all the [4:36] hosting and streaming for our courses, [4:38] but it does a lot more than just [4:40] infrastructure. When you upload a video [4:41] to Mux, you automatically get [4:43] transcripts, storyboards, thumbnails, [4:45] and clips along with structured data [4:47] about what's actually in the video. That [4:49] powers Mux robots, which is their AI [4:52] hosted workflows that can translate your [4:54] audio into other languages, moderate [4:56] content, and lots more without you [4:58] needing to host a model or maintain a [4:59] pipeline. You can automate all this with [5:01] directives where you define a workflow [5:03] once and it runs on every new upload. [5:06] And you only pay for the jobs that [5:07] actually run. Perplexity, Patreon, and [5:09] many other prestigious companies all [5:11] trust Mux and their free plan includes [5:13] 10 videos and 100,000 delivery minutes [5:16] per month with no credit card required. [5:18] And you can get an extra $50 credit at [5:20] the link below. This has been The Code [5:21] Report. Thanks for watching and I will [5:23] see you in the next one.