I love Ultrafast (it's unusable)

Summary of technological concepts, features, and analysis

“Ultrafast” / “Ultraast” mode is real-time and extremely responsive

• The video demonstrates building and modifying an app live, with changes appearing immediately in the browser/dev server.
• It highlights rapid UI/code iteration (“trippy” but effective).
• It supports “in the loop” workflows where the user keeps steering while the model is still working.

Powerful for live prototyping and interactive coding UX

• High-impact use cases mentioned:
  • Live prototyping
  • Working-in-the-loop iterative refinement
  • Creating user experiences that feel immediate
  • “Computer use” experiences that feel faster than a human operating the computer
• The speaker suggests split-screen workflows (model output + app) improve “flow state” by making cause/effect visible quickly.

But cost/rate-limit impact is severe

• Core argument: Ultrafast is fast enough to make iteration effortless, but burns tokens and money extremely quickly.
• Pricing comparisons cited:
  • Astra base: $50 per million output tokens
  • Ultraast: $300 per million out
  • Long-context: up to $450 per million tokens out
• Cash cost examples are described as unusually high versus normal models (including “cash read” and “cash write” token costs).
• The speaker repeatedly warns most people should avoid using it via API due to expense.

Operational guidance: runtime optimization shifts

• A practical point: if normal inference takes ~10 minutes but ultrafast takes ~30 seconds, then tool/build time becomes relatively more dominant.
• Recommendations:
  • Use a different system prompt (or steering instructions) to reduce slow tool calls that take seconds.
  • Prioritize operations that won’t introduce noticeable latency compared to ultrafast inference.

Product/stack integration used for the live demo

• Live demo stack:
  • Astra + Lakeb
  • Lakeb provides auto updates when code changes
• The evolving app includes:
  • Light/dark mode
  • Chat controls (e.g., “signed in only”)
  • Image attachment behavior
  • UI cleanup (remove subtitles/titles, tighten top navigation spacing)

Astra model behavior vs other models

• Claim: Astra steers better during rapid instruction changes while running (handling multiple directives quickly/possibly in parallel).
• Compared to slower models mentioned (e.g., Opus/Sonnet/Fable), ultrafast is described as:
  • Faster to first working draft
  • More conducive to iterative UI refinement

Cost justification conclusion

• The “value” question depends on whether you’d otherwise rebuild or lose context.
• The speaker estimates ultrafast enabled progress they otherwise might not have finished.
• However, they conclude it’s not generally economically justified for most tasks versus cheaper alternatives like “61 Soul”.

Quantitative performance (throughput and token burn)

• Reported measured throughput:
  • Regular: ~30 TPS
  • Fast: ~60ish TPS
  • Ultrafast: 320–340 TPS
• Usage behavior described:
  • Small ultrafast actions may only reduce limits ~1% per under-a-minute change, but later cumulative/continued usage drops limits much faster.
• Dollar-equivalent example:
  • Doing similar work with 61 Soul is estimated as much cheaper than Astra Ultraast
  • Example given: $46 vs $110 (with additional multipliers in other comparisons)

Notable tutorial-like build/iteration workflow described

• Prompting patterns while ultrafast is running:
  • “Spam” follow-ups with quick UX fixes
  • Treat the model like a continuously updating collaborator
  • Use rapid, small directives (e.g., “Change my mind on sort…”, “Get rid of useless space…”, “Make panel top left…”)
• Tooling automation mentioned:
  • In T3 code, threads auto-hide while running to improve focus (unless the workflow requires interaction “in the loop”).

Use-case framing: when ultrafast is “worth it”

• Best justification described:
  • High-priority incident response (super urgent issues)
  • Use only if you can afford the burn / don’t care about losing quota
• Advice:
  • Don’t upgrade to a $500 tier just for this unless resets or special conditions apply.

Upcoming model/plan commentary

• Claim: “6.1 Soul Ultraast is coming soon”
  • Public confirmation cited as “Tibo” teased it
• Speculation: it could improve value—potentially bringing ultrafast pricing closer to 61 Soul rather than Astra Ultraast’s extreme costs.

Sponsor / related tooling

• Sponsor in the video: Graptile
  • Promotes T-Rex, a tool for code review agents that run tests on a real computer environment (not only static analysis).
• Example outcome:
  • A regression in a YouTube-related PR was caught by running it for real
  • Artifacts and a dashboard showed failures.

---

Key takeaways (review/guide-style)

• Ultrafast is best for interactive “in-the-loop” UI/coding where latency is the bottleneck, enabling rapid iterative changes.
• Tool-call/build time matters more than usual relative to ultrafast inference; steer to minimize slow tools.
• Cost/rate-limit risk is the main drawback—most users should avoid it via API.
• High-urgency incident response is the most defensible use case.
• A cheaper ultrafast alternative (“61 Soul ultraast” / “6.1 Soul ultraast”) is expected, which could change the value proposition.

---

Main speakers / sources

Primary speaker

• Single narrator (unnamed in subtitles)
• Described as having accounts like “Codeex,” building demos like “Slopolytics,” and referencing “Tibo” and “Bot Cooper.”

Sponsor source

• Graptile (product: T-Rex)
• Credited as “Reptiles put together,” with link: soyv.link/grapile

Referenced individuals/companies

• OpenAI (employees mentioned; includes an “unlimited inference” claim)
• Tibo (teased “6.1” ultrafast)
• Bot Cooper (named as someone adopting these ideas)
• Anthropic models: Opus, Fable, Sonnet
• Astra and Lakeb (main technical stack mentioned)