Video wird geladen...

Video konnte nicht geladen werden

Zur Startseite

You already gave the LLM the answer. So why is it writing it out from scratch? Introducing a new AI model architecture: Constrained Decoding Models (CDMs) LLMs were built to write. Most production workloads just need an answer: fast, consistent, and affordable. CDMs are purpose-built for 1 task each....

1,410,953 Aufrufe • vor 1 Tag •via X (Twitter)

67 Kommentare

Profilbild von Machina
Machinavor 1 Tag

im not even done testing yesterday's model that a new class just spawned wtf

Profilbild von Neal Patel
Neal Patelvor 1 Tag

shit moves fast these days - now you can bench them!

Profilbild von Paul Mit
Paul Mitvor 1 Tag

I think that the next AI phase may be about figuring out which things don't need that model at all means we don't need the smartest model ever for every single task more specifications for each task

Profilbild von Neal Patel
Neal Patelvor 1 Tag

100% the future is multi-model and it's not going to be general purpose models across the stack

Profilbild von elvis
elvisvor 1 Tag

Using a frontier model to classify or tag at scale always felt like overkill. Great to see a model family built for exactly these tasks. Also very excited to try out the multimodal decision model.

Profilbild von Neal Patel
Neal Patelvor 1 Tag

multi-label is supported on scaledown classify so you can tag 1 input (text + image) with 20+ tags in 1 pass not just select 1 from a list

Profilbild von Shay Boloor
Shay Boloorvor 1 Tag

Woah 40x cheaper on input than Gemini 4 Argon 👀

Profilbild von aditya
adityavor 1 Tag

"Output is free (yes, even for summarize)" brooo wow-

Profilbild von Neal Patel
Neal Patelvor 1 Tag

🧑‍🍳👩‍🍳👨‍🍳

Profilbild von Peng
Pengvor 1 Tag

when you say one model one job, is classify meant to replace the gpt routing call or sit in front of it?

Profilbild von Neal Patel
Neal Patelvor 1 Tag

yea classify can be used a router model. but it is not tuned for that task specifically. we have a router and tool calling model in the works. will be out soon!

Profilbild von Rohan Paul
Rohan Paulvor 1 Tag

this is truly great, huge practical low-cost solution. pulling a due date out of a 300-page PDF shouldn’t need a model that writes.

Profilbild von Neal Patel
Neal Patelvor 1 Tag

appreciate it!! why wait for generation when you already gave the answwer

Profilbild von Science girl
Science girlvor 1 Tag

Cool to avoid the unnecessary text and an answer straight away.

Profilbild von Neal Patel
Neal Patelvor 1 Tag

no need to waste time/money on reasoning tokens!

Profilbild von dudu
duduvor 1 Tag

wasnt expecting Jev to get mogged so fast

Profilbild von Neal Patel
Neal Patelvor 1 Tag

😶‍🌫️

Profilbild von Harshit Jain
Harshit Jainvor 1 Tag

Hiring a giant model to sort tickets was always overkill. Glad someone built the right tool for it.

Profilbild von Neal Patel
Neal Patelvor 1 Tag

hire an intern for intern tasks

Profilbild von Abdul Shakoor
Abdul Shakoorvor 1 Tag

I like the framing here. LLMs write, but apps often just need classify, extract, or summarize.

Profilbild von Neal Patel
Neal Patelvor 1 Tag

couldn't agree more! why have 1 model that's ok when you can have 3 that are really good

Profilbild von CDG
CDGvor 1 Tag

if an invoice has two totals or a missing field, does Extract flag it or take a guess?

Profilbild von Neal Patel
Neal Patelvor 1 Tag

you can select the number of entities you want extracted so can do more than 1 and for missing fields extract will not return anything - never guesses main thing is you can set the confidence threshold for the entities as an input that is used for extract

Profilbild von Eon.io
Eon.iovor 1 Tag

Half of protecting data is knowing what’s in it. This makes that a lot cheaper. Awesome launch!

Profilbild von Neal Patel
Neal Patelvor 1 Tag

100% extract is great for PII redaction and other security/compliance use cases!

Profilbild von neural nets.
neural nets.vor 1 Tag

lemme give this a read Very similar to how decision models work, as far as I can understand, but seems like an interesting approach

Profilbild von Neal Patel
Neal Patelvor 1 Tag

similar but we've expanded past just decisions to data extraction and summary selection

Profilbild von Whale Insider
Whale Insidervor 1 Tag

Speed + cost numbers like this don’t come around often.

Profilbild von Neal Patel
Neal Patelvor 1 Tag

not everyday but we're happy to help people scale down their AI cost and latency!

Profilbild von Rémi 🌳
Rémi 🌳vor 1 Tag

Awesome, how should we call this? structured outputs?

Profilbild von Neal Patel
Neal Patelvor 1 Tag

the models are called constrained decoding models! for outputs i'd say extract = structured outputs but summarize is summaries and classify is decisions / labels

Profilbild von Vyom
Vyomvor 1 Tag

The funniest part is we’ve spent years optimizing prompts to make LLMs output valid JSON instead of questioning why we needed a generative model for that task in the first place 😭

Profilbild von Neal Patel
Neal Patelvor 1 Tag

lolll we did that too - we were just working with the tools we had happy to report no longer need to do that anymore!

Profilbild von Peter Mick
Peter Mickvor 1 Tag

31x size of Jev!! I can already think of a few solo SaaS startup ideas to build with it

Profilbild von Neal Patel
Neal Patelvor 1 Tag

love to hear that! can't see what you build also don't forget about images

Profilbild von Wall St Engine
Wall St Enginevor 1 Tag

really cool, invoice processing, support routing from screenshots and checking whether an agent is stuck in a loop

Profilbild von Neal Patel
Neal Patelvor 1 Tag

just the tip of the iceberg of use cases!

Profilbild von Aaliya
Aaliyavor 1 Tag

Faster results at a lower cost would help many teams.

Profilbild von Neal Patel
Neal Patelvor 1 Tag

which teams do you think would benefit the most?

Profilbild von Aaliya
Aaliyavor 1 Tag

I think for AI startups building agents that need fast classification, structured data extraction n summarization at scale.

Profilbild von Muhammad Ayan
Muhammad Ayanvor 1 Tag

Picking one task per model is the part I like most!! When a model only classifies, it stops wandering off into essays. So clean :)

Profilbild von Neal Patel
Neal Patelvor 1 Tag

appreciate it! 1 model per 1 task is the future

Profilbild von Plants Rock
Plants Rockvor 1 Tag

@Mr_Derivatives LLM’s are like wives and girlfriends 😉

Profilbild von Neal Patel
Neal Patelvor 1 Tag

@Mr_Derivatives i would love this to be elaborate on. im sure it's a good joke just missing the punchline

Profilbild von Sakata
Sakatavor 1 Tag

does Extract still return the exact source text and its position when the input is a scanned PDF image?

Profilbild von Khushi
Khushivor 1 Tag

how does it handle ambiguous classifications?

Profilbild von Neal Patel
Neal Patelvor 1 Tag

you can add those details in the class labels! we have an agent that helps with prompt tuning to cover those edge cases:

Profilbild von Pranav Mailarpawar
Pranav Mailarpawarvor 1 Tag

Ngl not every ai workflow needs a massive LLM burning tokens just to classify or extract a few things

Profilbild von Neal Patel
Neal Patelvor 1 Tag

you might be onto something!

Profilbild von Dhaval Makwana
Dhaval Makwanavor 1 Tag

the 200x speed claim definitely gets attention.

Profilbild von Neal Patel
Neal Patelvor 1 Tag

love to hear it! test it out and lmk how it goes

Profilbild von ShadowAguy
ShadowAguyvor 1 Tag

you already gave the llm the answer and then paid it to type that same answer back slower.

Profilbild von Neal Patel
Neal Patelvor 1 Tag

seems counterintuitive no? i agree - hence scaledown

Profilbild von said
saidvor 1 Tag

needed something like this

Profilbild von Neal Patel
Neal Patelvor 1 Tag

amazing! get your 50M tokens for free here

Profilbild von Markets & Mayhem
Markets & Mayhemvor 1 Tag

a new architecture for a faster answer. very interesting.

Profilbild von Neal Patel
Neal Patelvor 1 Tag

have to build from the ground up to get these 200x and 467x faster results

Profilbild von Markets & Mayhem
Markets & Mayhemvor 1 Tag

absolutely. there's a lot of room to innovate based on use cases. specialized models and architectures are going to be a big part of that.

Profilbild von Alex Ai | Tools & Updates
Alex Ai | Tools & Updatesvor 1 Tag

CDM concept finally fixes production latency

Profilbild von Neal Patel
Neal Patelvor 1 Tag

why go slow when you can go fast🏎️

Profilbild von Anomaly
Anomalyvor 1 Tag

Time to run it up 🔥🔥🔥

Profilbild von Neal Patel
Neal Patelvor 1 Tag

🏃🏃‍♂️🏃‍♀️

Profilbild von painn
painnvor 1 Tag

i’m tired of paying for expensive llm that doesn’t exactly this trying this with the free tokens now

Profilbild von Jatin Garg
Jatin Gargvor 1 Tag

the rewrite step wastes tokens and latency when the model could just return the cached answer. biggest win would be skipping regeneration entirely for exact matches in context.

Profilbild von Neal Patel
Neal Patelvor 1 Tag

that's the base premise of CDMs

Profilbild von codemarch
codemarchvor 1 Tag

CDMs could make production AI workflows faster, cheaper, and more reliable.

Profilbild von Neal Patel
Neal Patelvor 1 Tag

100% that's the mission

Ähnliche Videos

Jev is cool. So is it's OSS companion, Laya. The Latest Cool Thing In AI™ tends to get a lot of hype, sometimes without everyone even understanding it. So... what is this thing? Jev is an AI model that consumes input and produces output VERY differently than chat, claude, grok. The input is two things: 1) Text state to assess. Email, html, code, whatever. 2) A set of questions which will be asked about the attached state. The canonical example from TypeSafe's docs is to identify the urgency of a support ticket. We pass the model the customer text + a single noul question "is this urgent?". Jev returns a full set of JSON. This JSON is not generated with token-by-token autoregression. Jev is not trained to produce sequences of text tokens, rather to answer questions, and guarantees well-formed responses. In the example below, we see it produces a 0.99 probability (on a 0-1.0 scale) that the answer is "yes." Jev supports exactly three types of questions (seconds example in video): a) Noul: 0–1 probability that the answer to a yes/no question is "yes." b) Choice: Ask question with pre-defined set of answers. Jev chooses the best and assigns probabilities to each. c) Score: Ask question with pre-defined scale of answers. Jev produces a position on the scale. Jev computes answers for all questions in parallel, making responses super fast even for many questions in a single request. This might seem like a narrow set of capabilities, but in the right contexts leads to incredible potential. It also makes for a useful API / primitive for programming, since the outputs are... *ahem*... type-safe and predictable in structure. Jev is not going to replace LLMs for writing your code, auto-generating your docs, or being at the core of an agent harness. But Jev IS incredibly cool, and will be used to build a lot of amazing tech. Hope this helps.

Ben Dicken

40,810 Aufrufe • vor 24 Tagen

Redis built a cache that cuts LLM costs by 90%! Production LLM apps do not receive completely new questions every time. A customer-support assistant might receive all three of these: - "Can I get a refund after buying the monthly plan?" - "Is the monthly subscription refundable?" - "Can I cancel the plan and get my money back?" The wording is different, but the underlying question and its answer remain the same. Yet LLM apps process every version as a new request. They assemble the prompt, send it to the model, and generate an answer that may have already been generated. Prefix caching reduces part of these repeated calls. When requests begin with the same system prompt or context, the model can reuse the KV states already computed for that shared prefix. But the request still hits the LLM. The new tokens must be processed, and the complete answer must still be decoded. So even with a prefix-cache hit, there's another generation call involved. To solve this, instead of only caching computation inside the model, the application can cache the generated response outside it. When another question arrives, the system embeds it and compares it with previously answered questions. If it finds a sufficiently close match, it returns the stored response without invoking the LLM again. A cache hit removes the input tokens, output tokens, and decoding time associated with another LLM call. In practice, it is important to decide which questions can safely share an answer since a production setup needs well-tuned similarity thresholds, expiration policies, data isolation, and monitoring for incorrect matches. If you want to use this in practice, Redis already implements it as a managed service called Redis LangCache. Under the hood, it generates embeddings, searches previous responses, and returns a matching answer before another model call occurs. Redis also handles access scopes, custom filtering, TTL and eviction controls, and cache monitoring through Redis Cloud. I built an interface to compare it against direct LLM inference. The video below shows this in action, and I worked with Redis on this post to put this together. For the paraphrased question in my run, direct inference took 2.232 seconds and consumed 514 input tokens plus 250 output tokens. Redis returned the earlier response in 0.37 seconds with zero LLM input or output tokens. That was roughly 6x faster in this run. Redis reports API cost savings of up to 90% and cache-hit responses up to 15x faster. The actual result depends on how much safe repetition exists in the workload. You can try Redis LangCache here: If you want to dive deeper, I have already written a detailed breakdown of KV, prefix, prompt, and semantic caching in the article quoted below. This demo builds on the final technique and shows it running in practice. Read it below.

Avi Chawla

166,230 Aufrufe • vor 1 Monat

New short course: LLMs as Operating Systems: Agent Memory, created with Letta, and taught by its founders Charles Packer and Sarah Wooders. An LLM's input context window has limited space. Using a longer input context also costs more and results in slower processing. So, managing what's stored in this context window is important. In the innovative paper MemGPT: Towards LLMs as Operating Systems, its authors (which include the instructors) proposed using an LLM agent to manage this context window. Their system uses a large persistent memory that stores everything that could be included in the input context, and an agent decides what is actually included. Take the example of building a chatbot that needs to remember what's been said earlier in a conversation (perhaps over many days of interaction with a user). As the conversation's length grows, the memory management agent will move information from the input context to a persistent searchable database; summarize information to keep relevant facts in the input context; and restore relevant conversation elements from further back in time. This allows a chatbot to keep what's currently most relevant in its input context memory to generate the next response. When I read the original MemGPT paper, I thought it was an innovative technique for handling memory for LLMs. The open-source Letta framework, which we'll use in this course, makes MemGPT easy to implement. It adds memory to your LLM agents and gives them transparent long-term memory. In detail, you’ll learn: - How to build an agent that can edit its own limited input context memory, using tools and multi-step reasoning - What is a memory hierarchy (an idea from computer operating systems, which use a cache to speed up memory access), and how these ideas apply to managing the LLM input context (where the input context window is a "cache" storing the most relevant information; and an agent decides what to move in and out of this to/from a larger persistent storage system) - How to implement multi-agent collaboration by letting different agents share blocks of memory This course will give you a sophisticated understanding of memory management for LLMs, which is important for chatbots having long conversations, and for complex agentic workflows. Please sign up here!

Andrew Ng

201,127 Aufrufe • vor 1 Jahr

A tricky LLM interview question: You're serving a reasoning model on vLLM, and it keeps running out of GPU memory on long traces. So you add KV cache compression and evict 90% of the cached tokens. VRAM usage stays as is and GPU still runs out of memory. Why? (answer below) Evicting 90% of the KV cache can free almost none of the memory it was using. This sounds counterintuitive, but it follows directly from how production servers store the cache today. The KV cache grows with every token a model generates. Each token appends its key and value vectors across every layer, and nothing is freed while generation continues. This is the dominant memory cost for reasoning models. If a 32K-token CoT caches ~32K tokens of KV vectors, a Qwen3-32B with 4-bit weights will run out-of-memory around 24K tokens on a 24GB GPU. One obvious solution is to keep the important tokens and drop the rest, since attention is sparse enough to allow it. But this does not solve the memory problem yet. The reason is paged attention, which is the memory manager behind vLLM and most production servers. Under the hood, it splits GPU memory into fixed physical blocks, each one holds the KV for about 16 tokens. This block returns to the allocator only when every slot inside it is empty. Since the eviction logic selects tokens by importance, and such tokens are scattered across blocks... ...so despite eviction, almost every block is left with at least some survivor tokens. For instance, if the logic evicts 14k of 16k tokens across 1,000 blocks, most likely every block will still have a token. This means the allocator frees almost nothing. Placing the new tokens into those freed slots is not ideal because it breaks the cache's layout. Say token 16,001 arrives, and it's placed in the slot the 40th token used to hold. The cache now reads position 38, then 16,001, then 41, so the cache is no longer in token order. Attention can still compute the right answer from that, but only if every slot now carries a separate note recording which position it actually holds. This introduces another bookkeeping cost that an in-order layout inherently avoids. So the cache is logically 90% smaller and still physically the same size. Many compression results miss this because they measure on pre-allocated contiguous tensors rather than a paged server. There's another problem. Eviction methods pick which tokens to keep by looking at the attention scores themselves (as expected). But fast attention kernels used in production, like FlashAttention, never save those scores. They compute attention in small pieces and throw the full score grid away as they go, which is also why they're fast. So the exact signal eviction methods need isn't available in memory. The workaround is to fall back to eager attention and build the full matrix, which gives up the speed FlashAttention was there to provide. NVIDIA published a method called TriAttention to solve both these problems. It never needs attention scores. Instead, it scores tokens from the geometry of the model's key and query vectors before RoPE is applied, where those vectors sit in stable clusters. For the memory problem, it runs a compaction pass every 128 decoded tokens. The surviving tokens slide forward to close the holes eviction creates, so whole blocks empty out and return to the allocator while the cache stays in token order. On long reasoning traces, the approach matches full-attention accuracy while decoding 2.5x faster and using 10.7x less KV memory. KV cache compression is a big infrastructure problem. The number that decides whether it works is the count of freed blocks, not the count of evicted tokens. You can find the NVIDIA write-up here: I wrote a first-principles breakdown of how the KV cache works. It walks through why the model stores keys and values at all, why the cache grows with every token, and a comparison of LLM generation speed with and without KV caching. Read it below.

Avi Chawla

273,525 Aufrufe • vor 3 Monaten

Continuous batching in LLMs, clearly explained: (a popular LLM interview question; bookmark this) In traditional ML inference, a batch is a matrix. Every input is padded to the same length, one forward pass runs, and every row finishes at the same moment. LLM decoding does not work that way. One forward pass produces one token per sequence, so a request needs as many passes as it has output tokens, and nobody knows that count until the model emits a stop token. Under static batching, membership is fixed when the batch starts. A request that finishes in 30 tokens holds its slot until the slowest request in the same batch finishes at 400. The GPU keeps paying the full weight read for a batch that is mostly empty. Loading model weights out of HBM costs the same whether four slots are producing tokens or one. Continuous batching moves the decision boundary. Instead of scheduling once per batch, the scheduler runs a single forward pass, gets control back, and decides again. A finished request leaves at the next iteration boundary, and a queued request takes its slot right there. No slot stays reserved for work that is already done. Anyscale benchmarked both OPT-13B on a single A100. With uniform generation lengths, the two policies came out about level (as expected), and as output length variance rose, static batching fell to around 81 tokens per second while vLLM reached 23x the throughput of naive Hugging Face serving. Variance drives the entire gap. Production traffic mixes 30-token replies with 400-token ones, which is exactly the condition static batching handles worst. None of this alters the model. vLLM, SGLang, TGI, and TensorRT-LLM all run it by default, and NVIDIA ships the same mechanism under the name in-flight batching. The animation below runs both policies on the same 16 requests and the same 4 slots, stepping in lockstep. The only difference is when a new request is allowed in. To dive deeper into continuous batching specifically, I wrote a full breakdown of the scheduler underneath it. It covers what happens between two forward passes, how tokens get handed out against a fixed budget, why the scheduler needs no separate path for prefill and decode, and what preemption costs you when the KV cache fills up mid-generation. Read it below.

Avi Chawla

16,140 Aufrufe • vor 2 Monaten

Researchers found a way to make LLMs 8.5x faster! (without compromising accuracy) Speculative decoding is quite an effective way to address the single-token bottleneck in traditional LLM inference. A small "draft" model first generates the next several tokens, then the large model verifies all of them at once in a single forward pass. If a token at any position is wrong, you keep everything before it and restart from there. This never does worse than normal decoding. But current drafters in Speculative decoding still guess one token at a time. That makes the drafting step itself a bottleneck, capping real-world speedups at 2-3x. DFlash is a new technique that swaps the autoregressive drafter with a lightweight block diffusion model that guesses all tokens in one parallel shot. Drafting cost stays flat no matter how many tokens you speculate. On top of that, the drafter is conditioned on hidden features pulled from multiple layers of the target model and injected into every draft layer, so it makes significantly better guesses than a drafter working from scratch. In the side-by-side demo below, vanilla decoding runs at 48.5 tokens/sec. DFlash hits 415 tokens/sec on the same model, with zero quality loss. It's already integrated with vLLM, SGLang, and Transformers, with draft models on HuggingFace for several models like Qwen3, Qwen3.5, Llama 3.1, Kimi-K2.5, gpt-oss, and many more. I have shared the GitHub repo in the replies! KV caching is another must-know technique to boost LLM inference. I recently wrote an article about it. Read it below. 👉 Over to you: What use case are you working on that can benefit from this new technique?

Avi Chawla

158,352 Aufrufe • vor 5 Monaten

NVIDIA JUST DROPPED A FREE AI MODEL THAT READS PDFS, WATCHES VIDEOS, LISTENS TO AUDIO, AND UNDERSTANDS YOUR SCREEN SIMULTANEOUSLY. Not one at a time. ALL AT ONCE. In a single pass. It is called Nemotron 3 Nano Omni and it runs 9 times faster than every other multimodal model currently available. Think about what that actually means for how you work. Right now you are switching between tools constantly. One tool for transcribing your call recordings. A different tool for analyzing your client PDFs. Another tool for processing your training videos. A separate workflow for understanding what is happening on your screen. Four tools. Four contexts. Four different outputs you have to manually synthesize into one decision. Nemotron 3 Nano Omni does all of it in one model. One pass. One output. The use cases that just got dramatically simpler: Meeting recordings where you need the transcript, the visual context, and the document references all analyzed together. Training videos where the audio, the slides, and the on-screen demonstrations all feed into one coherent summary. Client PDFs where you need the document content cross-referenced against your screen data and your call notes simultaneously. Sales call transcripts analyzed alongside the proposals and the CRM data in one unified pass. This is not a marginal improvement on existing multimodal models. It is a 9x speed increase on a capability that was already changing how people work. Free. From NVIDIA. Available right now. Bookmark this before everyone catches on. Follow CyrilXBT for every AI capability shift the moment it drops.

CyrilXBT

37,847 Aufrufe • vor 5 Monaten

JEV + OPUS 5.5 IS INSANE FOR BUILDING A COMPANY BRAIN I pulled the whole architecture out of the TypeSafe and Anthropic docs and packed it into a 14-page PDF the 10 steps: 1. meet the pair > Opus 5.5 thinks, Jev decides, your code holds the branch 2. stop asking a text generator for a yes or no > Jev returns a typed answer with a calibrated probability in 0.44s for $0.00035 3. ask everything at once > Choice, Score and Noul run in parallel, so the fourth question costs almost nothing 4. branch on the number > 0.999 goes straight into the if statement. ~99% of turns end right here 5. stop routing blind > Opus 5.5 to Sonnet and back costs 5.84 against 3.32 for staying on 5.5 6. keep one context warm > cache reads at $0.20 per Mtok are 20x cheaper than a fresh load 7. escalate the hard part > the toughest 1% goes to Opus 5.5 with 1M context and 66.4% on Terminal-Bench 4.0 8. score every chunk on every query > keep whole, summarize or drop. the context gets rebuilt each turn 9. gate the actual command > every bash call gets classified before it runs, inside your own code 10. judge 100% of runs > $3.50 a day for 10,000 traces, and it matched the human label on all 500 decisions the result: a while loop that paid a frontier model for every tiny call turns into a brain that spends a fraction of a cent to notice and pays properly only when it has to think the person who brings this into their team walks into the budget meeting with the AI bill cut and the output up the PDF maps the company brain. the loop side of it - how Jev takes a Claude bill from $765 to $3 a month - is in the article below ↓

Mr. Buzzoni

103,282 Aufrufe • vor 16 Tagen

Today, we are launching Depost AI 2. 🎉 I am a bit emotional writing this. The last eight months were intense. But today I am proud of what we built. Because Depost AI 2 is built to become the best and safest AI content team for LinkedIn. We listened to thousands of people who used the first version, and we rebuilt Depost AI from scratch on the official LinkedIn API. The result: - A chat instead of a form, so you brief it like a colleague - Analytics that show what performs for you and why - Four agents that write in your voice and design the graphics to match - A calendar that fills from approved drafts - Approvals, roles, and a separate workspace for every brand - MCP, so the whole team works inside Claude, ChatGPT, or Cursor It is built for B2B founders who need to be visible without losing an hour a day. For marketing teams who need one system, one review flow, and one voice per brand. And for agencies who run LinkedIn for clients and need every brand kept apart. But the bigger vision is this: Depost AI is becoming a content team that understands your brand before it writes a word. It learns from everything you publish. It knows what performs for you and why. It plans, writes, designs, and schedules from that. And nothing goes live until you approve it. Because writing a post is not the hard part. Knowing what to say, saying it well every week, and doing it safely on an account you cannot afford to lose is. Depost AI 2 is the tool we built to solve that. And honestly, the best part right now is watching people brief it for the first time and get a week of drafts back in their own voice. You can start a 7-day free trial today at And if you message me, I will happily walk you through it myself. ❤️

Atta 🐬

20,330 Aufrufe • vor 1 Monat