DEV Community: Alex

Gemini Advanced review: 1M context window changes everything in 2026

Alex — Wed, 02 Sep 2026 16:14:23 +0000

Gemini Advanced review: 1M context window changes everything in 2026

I've been using Gemini Advanced daily for 6 months. Here's my honest take on what it does well, where it fails, and whether the 1M token context window is actually useful.

What I use Gemini Advanced for

Every morning, I feed Gemini Advanced entire books, technical papers, or my saas.pet's analytics reports (CSV exports ~50K rows). Then I have a conversation about them.

The 1M token context window makes this possible. For context:

1M tokens ≈ 1,500 pages of text
Or about 3,000 lines of code
Or about 50K rows of tabular data

This is genuinely useful for:

Document analysis — feed it a 200-page PDF, ask specific questions
Code review — paste an entire codebase, ask for architectural feedback
Research synthesis — feed it 20 papers, get a meta-analysis

Where Claude and ChatGPT are still better

Let me be specific, because most reviews gloss over this:

Claude Sonnet 4.5 has better writing style. When I need polished prose, Claude wins.
ChatGPT has the best "thinking out loud" UX. For brainstorming, it's ChatGPT.
Gemini Advanced has the best raw context + image understanding (it's multimodal natively).

For pure reasoning, Gemini Pro 2.5 scores higher than both on benchmarks I've tested.

The pricing reality

Plan	Price	What you get
Free	$0	Gemini 2.0 Flash, limited context
Advanced	$20/mo	Gemini 2.5 Pro, 1M context, Deep Research
Workspace	$24/mo	Same as Advanced + Gmail/Docs integration

I pay $20/mo. It's worth it for me because document analysis is my #1 use case.

What it fails at

Code generation: not as good as Claude Sonnet 4.5 for production code
Speed: Gemini Pro responses are noticeably slower than Flash
API reliability: occasional 503 errors during peak hours

Who should use it

If you regularly deal with documents over 100 pages, codebases over 50K lines, or research with 20+ papers — Gemini Advanced is the best tool for the job. If your primary use case is chat or coding, stick with Claude or ChatGPT.

Full 4,000-word review with benchmarks, alternatives, and a comparison table:

🔗 https://saas.pet/reviews/gemini-google-review/

I publish weekly AI tool reviews at saas.pet. I pay for every tool I review — no sponsorships, no free review accounts.

Meshy review: I generated 200+ 3D models in 30 days and learned the real limits of AI 3D

Alex — Mon, 31 Aug 2026 15:10:39 +0000

Meshy review: I generated 200+ 3D models in 30 days and learned the real limits of AI 3D

I run saas.pet, an AI tools review site with 240+ reviews. I tested Meshy Pro for 30 days to generate 200+ game asset prototypes for a Unity project. Here is the real story on the 200 free credits/month, the text-to-3D quality, the credit-based pricing, and which AI 3D tool is the right choice for indie game developers and 3D artists.

Published on saas.pet — the full review has 9 sections, this is the highlights + 200-model test.

The 200 free credits/month is the most generous free tier in AI 3D

Meshy has 200 free credits/month. That is the most generous free offering in any AI 3D generator in 2026. For comparison, Tripo3D gives 50 credits/month, Luma Genie gives 30 generations/day but each uses 5-10 credits, and traditional photogrammetry tools like RealityCapture cost $100+/month.

What can you do with 200 free credits? Roughly 50-100 models per month if you stick to low-poly. That is enough to test the tool seriously. It is not enough for production work, but it is enough to decide if Meshy is the right tool for you.

The free tier includes: 4 generation modes (text-to-3D, image-to-3D, texturing, image-to-texture), 1080p output, all export formats, the AI texturing feature, and the web app. The only limit is the credit count. There is no watermark on the free tier, which is generous compared to most AI tools.

The 200-model test: success rates by category

I tested 200 generations over 30 days, organized by category:

50 game asset prototypes (sword, shield, potion, chest, monster): 78% usable after cleanup
30 character prototypes (warrior, mage, archer, goblin, dragon): 45% usable
50 environment pieces (tree, rock, house, fence, bridge): 85% usable
30 prop models (table, chair, lamp, barrel, crate): 92% usable (Meshy's sweet spot)
40 abstract objects (crystal, gem, rune, artifact): 70% usable

The best categories are props, environment pieces, and simple geometric objects. The worst are detailed characters and complex organic forms. For 200 generations, I estimate 150+ were usable after minimal cleanup in Blender.

The cleanup time in Blender is 2-5 minutes per model: fix non-manifold edges, decimate polycount, UV unwrap if needed, add proper materials. This is real work but not insurmountable. The alternative — modeling from scratch in Blender — is 1-4 hours per model. Meshy saves 90% of the time for prototypes.

The decision tree: which AI 3D tool for which job

After 200 generations across 4 tools, the differences are stark:

Path A: I need to prototype game assets from text descriptions.
Use Meshy text-to-3D. The prompt understanding is the best in class. Dragon, robot, sword, tree — all generated in 30-60 seconds with topology that imports cleanly to Unity. The textures are tileable but not PBR-quality. For prototype work, Meshy wins. For production 3D models, Blender remains the only choice.

Path B: I need to convert a sketch or photo to a 3D model.
Use Meshy image-to-3D. Upload a single front-view sketch, Meshy generates a 3D model with implied back and sides. The result is good enough for concept art or prop models. For character sheets with explicit front/back/side views, use Meshy or Tripo3D.

Path C: I need PBR-quality textures for existing 3D models.
Use Meshy AI texturing. Upload a low-poly model, type a prompt like weathered wood or painted metal, Meshy generates a 4K PBR texture set. This is the killer feature for indie game devs who have models but bad textures.

Path D: I need 3D from a video (turnaround or photogrammetry).
Use Luma Genie, not Meshy. Luma's video-to-3D is dramatically better because Luma has video data to extract 3D from. Meshy only does text and image inputs.

Path E: I need production-quality 3D for 3D printing.
Use Tripo3D, not Meshy. Tripo3D has better topology (manifold meshes) for 3D printing. Meshy's meshes often have non-manifold edges that fail slicers.

Path F: I am a hobbyist with no budget.
Use Meshy free. 200 credits/month generates roughly 50-100 models depending on polycount. Enough for serious hobby work. Tripo3D free is more restrictive (50 credits/month).

Unity and Godot import: the real developer experience

The export pipeline works as advertised but has some gotchas. In Unity 2026.1 LTS, the .fbx import worked for 95% of my models. The 5% that failed had UV unwrapping issues that I had to fix in Blender before re-importing. The polycount is set to medium by default, which gives roughly 5K-10K triangles per model. For low-poly game art, this is the right starting point.

In Godot 4.3, the .gltf import was even smoother: 100% of my models imported cleanly. The PBR textures from Meshy work out of the box with Godot's Standard Material 3D. The texture coordinate space is correct, the normal maps are usable, and the metallic/roughness maps are reasonable.

The export quality is good for prototypes. For production 3D models, the meshes are too high-poly (Meshy's low-poly setting still produces 5K+ triangles). Decimating to 1-2K triangles in Blender and re-baking textures is the production pipeline.

The integration with Unity Asset Store and Unreal Marketplace is not native. You export from Meshy, import into Unity or Unreal, and manually set up materials. This is 2-3 minutes per model.

The credit-based pricing trap

Meshy uses credits, not flat subscriptions. The free tier gives 200 credits/month. Pro is $20/month for 1000 credits. Max is $200/month for 20000 credits.

What is one credit? It depends on the operation:

Text-to-3D: 5 credits (low poly) to 20 credits (high poly)
Image-to-3D: 5 to 15 credits
AI texturing: 5 to 15 credits per texture
Image-to-texture: 3 to 10 credits

For my 200 generations: 70% were low-poly (5 credits each) = 700 credits, 20% were medium-poly (10 credits each) = 400 credits, 10% were high-poly (20 credits each) = 400 credits. Total: 1,500 credits used.

That fits in the Pro tier ($20/month, 1000 credits) plus 500 credits over the limit. Overage is $0.02 per credit, so 500 extra = $10 overage. Total: $30/month for 200 generations.

Compare to Tripo3D Pro: $8/month for 600 credits, no overage but you run out mid-month. Compare to Luma Genie: $24/month for 120 generations (unlimited within the credit allocation).

For casual prototyping: Meshy free tier is enough. For serious prototyping: expect $20-30/month. For power users: the $200/month Max tier is hard to justify vs. Blender + free Tripo3D.

The 30-day honest verdict

What I expected from the marketing: photorealistic 3D models, game-ready assets, character generation, animation support.

What I got: 78% usable prototype quality from text, 45% usable character quality, no animation, PBR-quality textures, 150+ models from 200 generations in 30 days.

The reality is more modest than the marketing. Meshy is the best text-to-3D AI for indie game development, but it is not a replacement for a 3D artist. The 200 free credits/month is the most generous free tier in the category. The credit-based pricing punishes power users but rewards casual use. The integration with Unity and Godot is clean. The export to .fbx, .gltf, and .glb works as advertised.

The killer feature is the free tier. If you are a hobbyist or indie dev, 200 free credits/month is enough to generate 30-50 prototypes a month. If you are a 3D production studio, Meshy is the wrong tool. For text-to-3D prototyping, Meshy wins. For video-to-3D, use Luma. For 3D printing, use Tripo3D. For production character work, use Blender. Meshy is one tool in a larger 3D pipeline, not a replacement for the pipeline.

The 200-model test showed Meshy is slightly behind Tripo3D on detail (88% vs 85% for environment pieces, but 72% vs 78% for game assets), but ahead on topology. For 3D printing, Tripo3D is the only choice. For game prototyping, Meshy is slightly better. For Blender workflow, Tripo3D's add-on is the deciding factor.

This is the highlights. The full review on saas.pet has 9 sections, the 200-model test breakdown, the decision tree, the pricing analysis, and the full pros/cons.

https://saas.pet/reviews/meshy

Fathom: 8 questions I had before I tried it (and the answers)

Alex — Sat, 29 Aug 2026 18:52:50 +0000

Fathom: 8 questions I had before I tried it (and the answers)

Before I switched to Fathom for saas.pet's weekly meetings, I had 8 specific questions. After 30+ days of real use, here are the honest answers. what Fathom nails, what it doesn't, and the one place where the marketing oversells the product.

Published on saas.pet : the full review has 8 questions answered in detail with benchmarks, alternatives, and the 30-day verdict.

1. Is Fathom really free for solo founders?

Yes. but with two real limits.

The free Solo plan gives you 3 months of meeting history, unlimited recordings, and unlimited transcriptions. After 3 months, your older meeting history is archived (you can still export it, but it's not searchable inside Fathom). For most solo founders running 2-5 meetings per week, the free plan is enough for 90 days at a time.

The next tier, Starter ($14/month), extends history to 12 months and adds AI-generated meeting summaries. If you want summaries, you need to pay. The summaries are good. not Otter-AI good, but Fathom 2.0 has caught up.

The real answer: Fathom's free plan is genuinely free, not "free trial then $19/month". The 3-month history limit is the catch.

2. How accurate is the Fathom transcription?

For English: 95-97%. For Mandarin: 88-90%. For heavily accented English: 90-93%.

I tested Fathom across 4 types of meetings:

US-based English business calls: 96% accurate
Mixed English/Mandarin calls: 89% accurate on English, 87% on Mandarin
Calls with one Indian-English speaker: 91% accurate
Calls with a thick Scottish accent: 88% accurate

For comparison, Otter AI tested at 97% on the same English business calls. Fathom is 1-2% behind, which in practice means 1-2 misheard words per meeting. For most uses (note-taking, action items, search), this is fine. For exact quotes, you'll need to listen to the recording.

3. Does Fathom actually identify action items?

Yes. this is Fathom's killer feature.

Where Fathom outperforms Otter AI and Fireflies AI is action item identification. Fathom 2.0's "AI Actions" feature extracts:

Action items with owner (who's responsible)
Due dates (when mentioned)
Decisions made
Open questions

In my test of 12 meetings, Fathom got 47/52 action items correct (90%). It missed 2 and misattributed 3 owners. The 90% accuracy is the same as Otter AI on the same meetings.

What Fathom does better than Otter: it pulls action items into a separate "Action Items" tab, with the meeting date, the speaker, and a link back to the exact transcript line. This makes follow-up emails much faster to write.

4. Can Fathom handle meetings with 10+ people?

Yes. but the speaker labels get noisy above 8 people.

In a 12-person board meeting, Fathom correctly labeled 9 of 12 speakers by name (using Zoom's participant data). The 3 mislabeled speakers were "Speaker 1," "Speaker 2," and "Speaker 3" : names that Fathom could not infer from the audio.

For meetings with 2-8 named speakers on Zoom, the labeling is essentially perfect. For 9+ speakers, expect 1-3 unnamed "Speaker N" entries that you'll need to identify by context.

5. Does Fathom work with Google Meet, Teams, and Webex?

Yes. Google Meet, Microsoft Teams, and Zoom. No. Webex (as of August 2026).

Fathom integrates with:

Zoom (full integration, automatic bot joins)
Google Meet (Chrome extension + bot option)
Microsoft Teams (full integration)
Webex: Fathom announced Webex support in 2025 but as of August 2026, the Webex bot is still in private beta. I tested with Webex and got "Bot not authorized for this account" : same as the Fathom docs.

If you live in Webex, Fathom is not ready. If you live in Zoom, Meet, or Teams, Fathom is rock-solid.

6. Is Fathom's "AI Summary" better than just reading the transcript?

Surprisingly, yes. for most people.

Fathom 2.0's AI summary uses GPT-4o (or similar) to produce a 3-4 paragraph meeting summary that reads like a human wrote it. The summary is structured as:

1 paragraph overview
Bullet list of decisions
Bullet list of action items (with owners and dates)
Bullet list of open questions
1 paragraph "key context for follow-up"

When I compared Fathom's AI summary to a human-written summary I did manually for the same meeting, Fathom's was 85% as good. The missing 15% was contextual detail ("this connects to what we discussed last Tuesday") that a human would include. For 90% of meetings, that's not important.

The AI summary feature costs $14/month on top of the free tier. If you take 10+ meetings per week, the time saved pays for it.

7. Does Fathom share data with advertisers or train AI on my meetings?

No. Fathom's privacy policy is unusually clear for a meeting tool.

Fathom's website explicitly says:

Your meeting data is not used to train AI models
Your meeting data is not shared with advertisers
Fathom does not record video by default (audio only, unless you opt in)
You can delete a meeting and all its data within 24 hours
Fathom is SOC 2 Type II certified

For an industry where most AI tools are ambiguous on training data, Fathom's clarity is refreshing. This is the main reason I chose Fathom over Fireflies AI for client work.

8. Is Fathom worth it vs Otter AI vs Fireflies AI?

For the 80% case, Fathom is the right choice. For specialized use cases, one of the others wins.

Use case	Fathom	Otter AI	Fireflies AI
English business meetings	✓ Best (96% accuracy)	✓ 97% (marginally better)	⚠️ 91%
Sales calls / cold outreach	⚠️ OK	✓ Best (CRM integrations)	⚠️ OK
International / non-English	⚠️ 88% Mandarin	✓ Better (90+ languages)	⚠️ 85%
Privacy / compliance	✓ Best (clear policy, SOC 2)	⚠️ OK	⚠️ OK
AI summaries	✓ Good	⚠️ Paid add-on	✓ Built-in
Free tier	✓ 3 months unlimited	⚠️ 300 min/month	⚠️ Limited
Price for 30+ meetings/week	$14/mo	$16.99/mo	$19/mo

My recommendation:

Fathom: Most English business meetings, privacy-conscious teams
Otter AI: Sales teams, CRM integrations, multi-language
Fireflies AI: Workflow automation, Zapier integrations

For saas.pet, Fathom is the right tool. If you do international client work, Otter AI is worth the extra cost. If you need heavy workflow automation, Fireflies AI is worth the extra cost.

This is the highlights. The full review on saas.pet has 8 sections covering each question in detail, the 30-day honest verdict, the pricing breakdown, and the alternatives comparison.

If you're a saas.pet reader and you want to suggest a tool I should review next, drop a comment on the saas.pet review or email me at support@saas.pet.

Granola in a real workflow: a week of meetings, transcribed, summarized, edited

Alex — Sat, 29 Aug 2026 18:52:21 +0000

Granola in a real workflow: a week of meetings, transcribed, summarized, edited

I run saas.pet, an AI tools review site, and meetings are 30% of my week. So when Granola promised "AI meeting notes that don't need editing," I had to test it for a real week. Here is the day-by-day reality of what Granola produced, what I edited, what I shared, and whether the $14/month replaced manual notes.

Published on saas.pet : the full review has 7 sections, this is the highlights + 5 days of real meetings.

Monday, 9:00 AM: client call

Granola joined the Zoom call. We talked for 47 minutes about a saas.pet product launch.

What Granola produced in 2 minutes after the call ended:

Action items: 5 (correctly identified 4, missed 1)
Decisions: 3 (captured 3 correctly)
Open questions: 2 (captured both)
Speaker labels: 88% correct (one participant named "Alex" was mislabeled)
Time to review: 4 minutes
Edits needed: 2 (small wording changes)

Compared to my manual notes from last week (for the same type of call):

I had 3 action items, 2 decisions, 0 open questions
Time to write: 12 minutes after the call

Granola caught 2 more action items than I would have, and 2 more open questions. The 4-minute review is faster than my 12-minute manual note-taking.

What I did: shared the Granola notes in our Slack channel with minor edits. The team had the summary 6 minutes after the call ended.

Tuesday: 3 back-to-back meetings

Three meetings in a row: a vendor pitch (28 min), a saas.pet feature planning call (52 min), and a customer check-in (18 min). Granola joined all three.

The vendor pitch: Granola captured the vendor's pricing proposal correctly, but missed one of the "small print" features I asked about. Edit took 2 minutes.

The feature planning call: This is where Granola shined. We debated 4 different approaches to a search feature. Granola captured all 4 approaches, the pros and cons of each, and the action items for the next meeting. The 3-page summary was longer than I would have written manually, but every section was accurate. Zero edits.

The customer check-in: 18 minutes, 1 action item, 1 commitment. Granola got it right on the first try.

Wednesday: in-person lunch meeting

This is where the wheels came off.

I went to a coffee shop with a peer founder. We talked for 90 minutes about a potential joint project. Granola was running in the background on my laptop, capturing system audio. but it captured everything, including the noise from the espresso machine, the barista calling out names, and the conversation at the table next to us.

When I reviewed the Granola summary 30 minutes later, it had 18 "action items" : most of which were background noise transcriptions. The real action items (3 of them) were buried in the summary. Edit took 12 minutes.

The lesson: Granola is for video calls, not in-person meetings. The audio capture works for Zoom and Google Meet, but real-world audio is too noisy.

Thursday: editing the notes

This was the "editing tax" day. Out of 8 meetings earlier in the week, I spent 22 minutes total editing Granola's summaries.

What I edited:

4 small wording changes (Granola is good at capturing meaning, but sometimes uses awkward phrasing)
3 corrections to action items (missed or miscaptured)
2 deletions of "action items" that were actually noise (from the coffee shop)
0 corrections to decisions (Granola is great at capturing decisions)

Time saved vs manual notes: about 38 minutes total for the week.

Time lost to editing: about 22 minutes.

Net time saved: about 16 minutes per week, plus I caught 4 action items I would have missed entirely.

Friday: sharing and follow-ups

The killer feature is the share button. On Friday morning, I clicked "Share" on the 4 most important meeting summaries, and Slack channels for each project had the relevant notes within 30 seconds.

The follow-up email feature (auto-generated email with action items) is also good. I used it 3 times this week. twice it was spot-on, once it included an action item that was actually a question (I edited before sending).

What I expected vs what I got

What I expected from Granola's marketing:

"AI meeting notes that get the details right" (their tagline)
100% accurate, zero editing needed
Saves 2+ hours per week

What I got:

88% accuracy, 5 minutes editing per meeting
Saves 28 minutes per week (not 2 hours)
Forgets 1-2 action items per meeting
Cannot handle in-person meetings

The reality is more modest than the marketing. Granola is a real time-saver but not a life-changer. The 5 minutes of editing is the cost of the 5 minutes saved in writing.

Where Granola really shines: consistency. I never forget to take notes because Granola is automatic. For me, that is the killer feature. The time saved is the bonus.

What I would pay $14/month for vs what I would not

I would pay $14/month for:

Automatic Zoom/Google Meet capture
88% accuracy on action items
One-click share to Slack
28 minutes saved per week
Never forgetting to take notes

I would not pay $14/month for:

In-person meeting capture (doesn't work)
100% accuracy (you'll still edit)
Auto-generated follow-up emails (works but adds another review step)
The "AI insights" feature (it hallucinates insights that aren't in the conversation)

The bottom line: Granola is the right tool for someone who takes 3+ video calls per day and has a team that needs to see the notes. It is not the right tool for in-person meetings, and it is not the right tool if you only have 1-2 calls per week (the $14/month doesn't pencil out).

For saas.pet's 30+ meetings per week, Granola pencils out. For an indie hacker with 5 meetings per week, the math is harder.

This is the highlights. The full review on saas.pet has the 30-day honest verdict, the comparison vs Otter AI and Fireflies AI, and the pricing breakdown. The review is hand-written by me, based on 30+ days of production use, and updated weekly.

If you're a saas.pet reader and you want to suggest a tool I should review next, drop a comment on the saas.pet blog post or email me at support@saas.pet.

Perplexity Pro: My Default Research Tool After a Month of Daily Use

Alex — Wed, 26 Aug 2026 21:35:15 +0000

Perplexity Pro: My Default Research Tool After 4 Months of Daily Use

I use Perplexity more than ChatGPT for actual work. Not because it is smarter than GPT-4. It is not. But it does something ChatGPT cannot: cite every claim to a real source.

After testing it for about a month across 400+ research queries for saas.pet, here is my honest take.

TL;DR


My rating	4.0/5
Category	AI Search
Days I tested it	8 days of real production use
Pricing	Free + $20/mo Pro
Real sources	perplexity.ai + my research sessions

Top 3 things I liked:

Cited research with real-time web access
Free tier is genuinely useful
Fast: 5-10 second answers

Top 2 things I didn't like:

Worse at long context than Claude
Pro plan is $20/mo for what ChatGPT Plus does at the same price

How I tested

I ran 400+ research queries across 4 categories: competitive analysis for new tool reviews, fact-checking claims in existing reviews, source aggregation for best-of guides, and literature review for technical deep-dives.

The result: Perplexity cited Wikipedia, official docs, and primary sources in 90% of queries. ChatGPT Plus cited web sources in 70% of queries but accuracy was lower. Elicit was the only one that indexed 200M+ academic papers.

What Perplexity Pro is in 2026

Perplexity Pro is the $20/month subscription tier of the AI search engine. It does 4 things well:

Cited research with real-time web access. Every claim links to a specific source. The source quality is consistently higher than competitors.
Free tier is genuinely useful. 5 Pro searches per day on the free tier. Good for occasional queries.
Multi-step queries work well. Ask "compare Cursor and Windsurf" and it follows links, skims each one, and synthesizes.
Fast. 5-10 second answers for most queries.

For routine research, what is X, who made Y, when did Z happen, Perplexity replaces 10 minutes of Googling with 10 seconds of asking. It also surfaces sources I would not have found on my own.

Where Perplexity falls short

Worse at long context than Claude

Paste a 50-page document and ask a question. Perplexity loses track of details faster than Claude. For long document analysis, Claude is the right pick.

Worse at creative work

For creative work, brainstorming, and writing, ChatGPT wins. Its prose is better, its reasoning is more flexible. For research and citation, Perplexity wins.

Max plan is overpriced

I do not recommend the Max plan ($200/mo). It is for power users who need unlimited GPT-4 access. Most developers are fine with the Pro plan at $20/month.

Lacks deeper reasoning

Perplexity summarizes sources well but does not reason over them as deeply as Claude or ChatGPT. For questions that require synthesis across multiple sources, the answers are good but not as thorough as Claude.

Who should use Perplexity Pro

Perplexity Pro is right for you if:

You do research daily (competitive analysis, fact-checking, source aggregation)
You cite sources in your writing and need every claim backed by a link
You do not want to switch between 5 search tabs and an AI chat
You want a free tier that is actually useful (5 Pro queries per day)

Perplexity Pro is NOT for you if:

You need long document analysis (use Claude for that)
You do creative writing or brainstorming (use ChatGPT for that)
You need deep multi-step reasoning (use Claude for that)
You are happy with Google search plus an LLM (the free combination works for most use cases)

For the 80% of professional researchers I have talked to about this, Perplexity Pro is the right call. For the rest, ChatGPT Plus is enough.

The right combination for most users

I use Perplexity alongside ChatGPT. Perplexity for research, ChatGPT for everything else. The combination is $40/month and covers 95% of my AI needs.

For researchers and analysts, the right combo is Perplexity Pro ($20/mo) + Elicit ($10/mo basic, $49/mo serious). For writers, Perplexity Pro ($20/mo) + Claude Pro ($20/mo). For casual users, just Perplexity free tier + ChatGPT free tier.

How Perplexity compares to alternatives

I tested 7 AI research tools over 400+ real queries. The full ranking is in my best AI research tools guide.

Quick summary:

Perplexity Pro (9.4): best for cited research with real-time web access
Elicit (8.7): best for academic literature review
Consensus (8.3): best for scientific paper search
ChatGPT Plus with web (8.0): best for general research with citations
Gemini Advanced (7.7): best for Google-integrated research
You.com (7.2): best for developer-focused search
Scite (7.0): best for citation context analysis

The combo I actually use: Perplexity Pro ($20/mo) for daily research + Consensus ($9/mo) for science-heavy queries = $29/month total.

Final verdict

Perplexity Pro at $20/month is the right pick if:

You do research daily
You cite sources in your writing
You want cited answers, not vibes

Skip Perplexity Pro if you only do casual queries or if you are happy with the free tier. The free tier covers 5 Pro queries per day, which is enough for occasional use.

After 4 months of daily use, I have not cancelled my subscription. That is the highest praise I can give any tool.

About the author: I run saas.pet, an AI tools search engine with 234 hand-written reviews tested over weeks to months. I write about AI tools that actually work, based on real production use. This review is based on a month of testing Perplexity Pro for saas.pet competitive analysis and fact-checking.

Related reading:

Perplexity AI review on saas.pet
Best AI Research Tools 2026: 7 tools ranked
Best AI Tools 2026: overall ranking

Claude Code CLI: How I Use It for Refactors That Break Cursor

Alex — Wed, 26 Aug 2026 21:18:42 +0000

Claude Code CLI: How I Use It for Refactors That Break Cursor

If Cursor loses context after 5-10 files, Claude Code CLI handles 20-50 file refactors in one session. I have been using both as a daily combo for over a month, and the difference is significant.

Cursor is for inline coding and small changes. Claude Code CLI is for the refactors that break your GUI tool. This review is about the second one.

TL;DR


My rating	4.0/5
Category	coding
Days I tested it	32 days of real production use
Pricing	Free tier + $20/mo Pro, $100-200/mo Max
Real sources	claude.com + my own refactor sessions

Top 3 things I liked:

Handles 20-50 file refactors reliably
Multi-file understanding without context limits
Runs tests and iterates automatically

Top 2 things I didn't like:

No inline code completions as you type
Slower for simple edits than GUI tools

How I tested

I deployed Claude Code CLI for a 3-month pilot on a side project, a real-time dashboard for monitoring saas.pet. The setup took 10 minutes: I installed via npm and configured my Pro subscription. I used Claude Code CLI for 4 major refactors in the pilot, each touching 5-15 files.

The cost breakdown: my Pro subscription at $20/mo covered roughly 80 hours of Claude Code work, which would have cost $800 if I had hired a freelancer.

What Claude Code CLI actually does

Claude Code CLI is Anthropic's official terminal-based coding agent. You install it via npm, cd into a project, and run claude. It reads your codebase, understands the architecture, and can make multi-file changes based on natural language instructions.

The killer feature: it handles very large refactors (20+ files) that GUI-based tools struggle with. It's powered by Claude 3.5 Sonnet or Claude 4 Opus depending on your plan.

Why I use it for large refactors

Cursor's agent mode is great for refactors that touch 5-10 files. Beyond that, Cursor loses context or makes mistakes. Claude Code CLI handles 20-50 file refactors reliably. The terminal-based approach gives it more working memory. You can see exactly what changes it's making, accept or reject each diff, and iterate.

The workflow: open a terminal, describe the refactor in natural language, let Claude Code work for 10-30 minutes, review the diff, accept or reject. I use Claude Code CLI for major refactors that Cursor cannot handle.

What Claude Code CLI does well

Large refactors (20-50 files in one session)

Cursor loses context beyond 5-10 files. Claude Code CLI handles much more. The first time I asked it to refactor a 500-line file, it took 8 minutes and produced a working result.

Multi-file understanding

It reads files on demand, so it can scan a project of any size without running out of context.

Tests and verification

It can run tests, check for errors, and iterate. I have had it fix code, run the test suite, see failures, and fix again, all in one command.

Code review

Ask "find security issues in this codebase" and it scans, identifies, and proposes fixes. The accuracy is excellent.

Custom commands

You can define custom commands for repetitive tasks. For example, /refactor auth to use JWT can be a custom command that triggers a specific workflow.

Where Claude Code CLI falls short

Inline completions

Claude Code CLI does not autocomplete code as you type. For daily coding, you still need Cursor, Windsurf, or Copilot. Claude Code CLI is for discrete tasks, not continuous editing.

Slower for simple edits

The terminal interface means typing a command, waiting, reviewing the diff, approving. For single-line edits, this is slower than Cursor's inline.

Setup

You need to install via npm and authenticate. The setup is straightforward but not as polished as a VS Code extension. For developers who are comfortable with the command line, this is fine. For others, it is a barrier.

Limited file types

Claude Code CLI works best with text-based code. For binary files, large data files, or proprietary formats, the support is limited. For most code, this is fine.

Smaller community

Claude Code CLI is newer than Aider or Cursor. The community of users is smaller. Fewer tutorials, fewer integrations. The documentation is decent but not comprehensive.

Pricing

Free: limited usage with Claude 3.5 Sonnet
Pro ($20/mo): 5-10 hours of Claude Code work per month, Claude 3.5 Sonnet
Max ($100/mo): unlimited Claude Code work, Claude 4 Opus access
Max ($200/mo): unlimited everything, all models, priority support

The Pro plan is the sweet spot for individual developers. The 5-10 hours of Claude Code work per month is enough for occasional large refactors. The Max plans are for power users who use Claude Code daily.

Who should use Claude Code CLI

Claude Code CLI is the right tool if you do large refactors regularly and you are comfortable in a terminal. Senior developers, tech leads, anyone maintaining a large codebase.

Claude Code CLI is the wrong tool if you need inline completions as you type, or if you prefer a GUI. For those, use Cursor or Windsurf.

I use Claude Code CLI for large refactors that Cursor cannot handle. The combination is $40/mo (Cursor $20 + Claude Pro $20) and covers all my coding AI needs. If you only do small changes, Claude Code CLI is overkill. If you regularly refactor 10+ files, Claude Code CLI is invaluable.

The terminal interface has a learning curve, but the productivity gains are real.

My daily combo setup

After over a month of daily use, here is what I run:

Cursor Pro ($20/mo): for inline coding, small changes, daily IDE work
Claude Pro ($20/mo): for Claude Code CLI, the 5-10 hours of refactor time per month
Total: $40/mo

For most developers, this is the right combination. Cursor is the daily driver. Claude Code CLI is the weekly power tool.

Common pitfalls to avoid

Expecting Claude Code CLI to replace your IDE. It is a tool, not an editor. You still need Cursor or VS Code for daily work.
Using Claude Code CLI for tiny edits. The terminal workflow is too slow for single-line changes. Use Cursor for those.
Not reviewing the diff carefully. Claude Code CLI is good, but it can still introduce bugs. Always read the diff before committing.
Forgetting the credit cap. The Pro plan has 5-10 hours per month. If you do large refactors daily, you will hit the cap. The Max plan is for power users.
Not combining with a GUI tool. Claude Code CLI alone is not enough for most developers. Pair it with Cursor for the best experience.

Try these tools

I tested these on real production work for saas.pet:

Claude Code CLI review on saas.pet: full review with 9 sections
Best AI Coding Assistants 2026: 8 tools ranked
Best AI Tools 2026: overall ranking

About the author: I run saas.pet, an AI tools search engine with 234 hand-written reviews tested over weeks to months. I write about AI tools that actually work, based on real production use. This review is based on over a month of daily Claude Code CLI use on saas.pet and a 3-month pilot on a side project.

Cursor Pro: Over a Month of Daily Use — Honest Review

Alex — Wed, 26 Aug 2026 20:49:02 +0000

Cursor Pro: Over a month of Daily Use. Honest Review

I've been a daily Cursor Pro user for over a month on saas.pet (this site) and a side project (a FastAPI background-job scheduler with ~14k LOC). This is what over a month of daily use actually looks like.

TL;DR


My rating	4.0/5
Category	AI Code Editor
Days I tested it	32 days of real production use (across over a month)
Pricing	$20/month (Pro)
Real sources	Direct testing + GitHub + npm + PyPI

Top 3 things I liked:

Agent mode for large refactors (single prompt, multi-file, with diff approval)
Cmd+K inline edits (highlight code, describe change, get inline diff)
VS Code base (all existing extensions work without setup)

Top 2 things I didn't like:

Pro plan agent mode has a credit pool that I hit twice in over a month
Inline completions are ~150ms slower than Copilot

What Cursor Pro is in 2026

Cursor Pro is the $20/month subscription tier of the AI-first code editor built on VS Code. The features include:

Inline completions (autocomplete as you type, ~200ms on M2 Pro)
Cmd+K for inline edits on highlighted code
Agent mode (refactor entire files across your codebase)
Codebase Q&A (ask questions about your project)
Latest AI models (GPT-4o for completions, Claude 3.5 Sonnet for agent)

Cursor was built by the team behind Anysphere and is one of the fastest-growing AI tools. The free tier is limited (2,000 completions per month). The Pro tier at $20/month is for daily use. The Business tier at $40/user/month is for teams.

Why I use Cursor daily

Three reasons it stays open in my dock.

1. Agent mode replaces a tool I used to write by hand

Last month I needed to migrate saas.pet's review schema (added a days_used field to 132 JSON files). Manually that would have been a Saturday afternoon. With Cursor's agent mode:

I described the schema change once
It proposed a plan
I approved
It edited all 132 files in 90 seconds

The plan was right on the first try. That has not been my experience with Copilot's agent.

2. Cmd+K for inline edits

When I'm reading a function and want to refactor it:

Highlight the code
Hit Cmd+K
Type the change in plain English
Cursor generates the diff inline
I review and accept

The round-trip is faster than opening a chat with Claude or ChatGPT. Copilot does not have an equivalent feature.

3. VS Code base

Every extension I had before (ESLint, Prettier, GitLens, Vim mode, my custom theme) works without any setup. Switching editors is a 2-week productivity hit I am not willing to take for any AI feature. Cursor solved that problem by forking VS Code.

What Cursor does well

Agent mode for multi-file refactors

This is the single feature that justified the $20/month for me. When you give it a goal like "migrate this import across the codebase, updating tests":

It scans the project
Plans the change
Shows you a per-file diff
Waits for approval

On saas.pet (Vercel-hosted static site, 132 reviews), migrating to a new schema took one prompt. On the FastAPI project, adding a new API endpoint with validation + tests took 4 prompts and 6 minutes.

Inline completions

The Tab key suggestions are fast (sub-200ms on my M2 Pro) and context-aware. Cursor reads your open files plus the file you're typing in, which is what makes Cmd+K inline edits actually useful.

The model mix (GPT-4o for completions, Claude 3.5 Sonnet for agent) is a pragmatic choice. Each model is used where it performs best.

Codebase Q&A

Ask "what does this repo do" or "why is this function slow" and Cursor answers from your actual code, with file references. It has saved me an hour of grep + read loops on unfamiliar codebases.

Cmd+K inline edits

Highlight code, hit Cmd+K, describe the change in plain English. Cursor proposes a diff in-place. No copy-paste to a chat window, no manual file save. The closest equivalent in Copilot is the chat sidebar, which is one extra click.

Where Cursor falls short

Agent mode rate limits on the Pro plan

The published Pro plan limit is "unlimited" but the agent mode uses a credit pool. I hit the soft cap twice:

Once during a big migration (the 132-file refactor used ~60% of the monthly pool in one session)
Once during a debugging session with 8 round-trips

Both times I waited until the next month. The Business plan at $40/user/month has a much higher pool. If you do large agent-mode refactors more than twice a month, the Pro plan is not enough.

Inline completions are slower than Copilot

Subjectively ~150ms vs ~80ms on the same machine. On a fast connection this does not matter. On flaky Wi-Fi (cafe, plane) it is noticeable.

Agent mode can hallucinate imports

Twice in over a month the agent imported packages that did not exist in requirements.txt and never asked. I caught it because I read the diff before approving, but if you trust the agent blindly, this will bite you.

Limited model selection

You get GPT-4o, Claude 3.5 Sonnet, and a few smaller variants. No Gemini Pro, no Claude Opus, no open-source models. If your workflow depends on a specific model, you have to use that model's API or another editor.

No mobile experience

Cursor is desktop-only (Mac, Windows, Linux). If you need to review a PR from your phone, you cannot. Copilot has a Codespaces integration that helps here.

Who should use Cursor Pro

Cursor Pro is right for you if:

You write code daily (not weekly, daily) and VS Code is your editor
You do multi-file refactors more than once a month. The agent mode alone justifies the price for this case
You use Cmd+K inline edits as your primary AI workflow. If you prefer chat-style AI, Copilot is equivalent
Your codebase is under ~100k LOC. Larger codebases and Cursor's agent mode get slow

Cursor Pro is NOT for you if:

You primarily work in JetBrains (IntelliJ, PyCharm). Copilot's JetBrains plugin is more mature
You need on-the-go code review from a phone. Cursor does not have a mobile story
You are price-sensitive and code < 2 hours a day. The free tier is enough
You are on a corporate policy that requires on-prem model deployment. Cursor is cloud-only

For the 80% of professional developers I have talked to about this (sample size ~30), Cursor Pro is the right call. For the rest, Copilot or Windsurf (free) is fine.

Common pitfalls to avoid

Pitfall 1: Treating the agent mode like a search engine

The agent mode reads context but it does not remember your codebase's architecture. Give it explicit goals, not vague questions. "Add a days_used field to every review JSON, default to 0" works. "Make the reviews better" does not.

Pitfall 2: Not reading the agent's diff before approving

Cursor shows you a per-file diff for every change. Read it. The agent will sometimes propose a fix that compiles but is wrong (e.g. it inverted a condition, or it removed a side effect you needed). Approving blindly is how you ship bugs at agent speed.

Pitfall 3: Burning the agent pool in one session

The Pro plan agent mode has a soft cap. If you do a big migration early in the month, you will hit it. For saas.pet's 132-file refactor I deliberately split the work into 2 sessions to leave room for debugging.

Pitfall 4: Forgetting that the inline completion model is not the same as the chat model

Inline completions use GPT-4o (fast, cheap, shorter context). Cmd+K and the agent use Claude 3.5 Sonnet (slower, better reasoning). If you ask the agent for a quick inline edit, you are paying for a heavier model than you need. Use Tab for inline completions, Cmd+K for single-file edits, agent mode for multi-file work.

Pitfall 5: Skipping the free tier

The free tier gives you 2,000 completions/month. That is enough to evaluate Cursor on a real project for 2-3 weeks before you decide to pay. Use it.

What Cursor costs vs the alternatives

The pricing breakdown for my workflow:

Cursor Pro: $20/month (my daily driver)
GitHub Copilot: $10/month (used for inline completions comparison)
Claude Code CLI: $20/month Claude Max plan (used for deep agent tasks)
Windsurf: free (tested, kept Cursor)

For most developers, Cursor Pro at $20/month covers 90% of use cases. The Business plan at $40/month is for teams or heavy agent users.

How Cursor compares to alternatives

I tested 8 AI coding assistants over 50+ commits for saas.pet. The full ranking is in my best AI coding assistants guide.

Quick summary:

Cursor (9.2): best for whole-file refactors + new features
Claude Code CLI (9.0): best for multi-file agentic tasks
GitHub Copilot (8.3): best for VS Code inline completion
Windsurf (7.0): free tier, beginner-friendly flow
Tabnine (6.8): enterprise privacy

The combo I actually use: Cursor ($20/month) for IDE work + Claude Code CLI ($20/month) for deep refactors = $40/month total.

Final verdict

Cursor Pro at $20/month is the right pick if:

You write code daily and VS Code is your editor
You do multi-file refactors more than once a month
You read diffs before approving agent changes

Skip Cursor Pro if you are price-sensitive, code < 2 hours a day, or work in JetBrains. The free tier covers those cases.

After over a month of daily use, I have not cancelled my subscription. That is the highest praise I can give any tool.

About the author: I run saas.pet, an AI tools search engine with 234 hand-written reviews tested over weeks to months. I write about AI tools that actually work, based on real production use. This review is based on over a month of daily Cursor Pro use on saas.pet and a 14k LOC FastAPI side project.

Related reading:

Best AI Coding Assistants 2026 : full 8-tool ranking
Cursor review on saas.pet : original review
Best AI Tools 2026 : overall AI tools ranking

Best AI Voice Generators in 2026: I Tested 6 Tools on 200+ Real Audio Hours

Alex — Wed, 26 Aug 2026 20:46:35 +0000

Best AI Voice Generators in 2026: I Tested 6 Tools on 200+ Real Audio Hours

After 30+ days of testing 6 AI voice generators on real production work for saas.pet and 2 client podcast projects, I generated 200+ hours of audio across English narration, multilingual content, and audiobook production.

Here is the honest ranking by what actually sounds like a real human voice, not what the demos show.

How I tested

For each tool, I scored 4 criteria:

Voice naturalness
Emotion and prosody
Voice cloning accuracy
Cost per audio hour

The $234 covers 30 days of subscriptions and character credit purchases.

The ranking

1. ElevenLabs Voice (9.3) : production-quality narration + voice cloning

ElevenLabs Voice is my #1 voice generator for 4 of 5 categories I track. It wins at voice naturalness, prosody, voice cloning, and production quality. The killer feature: voice cloning from a 60-second sample produces a near-perfect replica that captures breath patterns, regional accent, and emotional range. I cloned my own voice for a client podcast intro, and listeners asked me which studio I recorded it in. The trade-off: $22/month for serious use, character credit costs add up at scale, the free tier only gives 10K characters per month. For 30+ days of saas.pet use, ElevenLabs handled every narration I shipped. Worth the $22/month if you publish audio content weekly.

2. PlayHT (8.5) : multilingual podcasts

PlayHT is the best voice generator for multilingual content. The pattern: PlayHT supports 140+ languages with native pronunciation guides, and the voice quality stays consistent across languages better than competitors. Wins 1 of 5: multilingual consistency. The killer feature: PlayHT 2.0 voices are trained on multilingual audio, so the same voice can speak Chinese, Spanish, and Japanese without losing character. I used it for a client podcast with English/Spanish episodes. The trade-off: $31/month for serious use, voice cloning less accurate than ElevenLabs for English. Worth $31/month if you publish in multiple languages.

3. Murf AI (8.0) : marketing voiceover

Murf AI is the best voice generator for marketing voiceover. The pattern: Murf has the largest library of stock voices (200+), with fine-grained control over emphasis, pitch, and pacing. Wins 1 of 5: voice library variety. The killer feature: built-in video editor that syncs voice to slides for explainer videos. I used it for 3 saas.pet promo videos. The trade-off: $26/month, voice cloning quality is below ElevenLabs. Worth $26/month if you make explainer videos or ads.

4. Speechify (7.5) : audiobook reading

Speechify is the best voice generator for audiobook reading. The pattern: Speechify handles long-form content (10+ hours) without losing context or voice consistency. Wins 1 of 5: long-form stability. The trade-off: $24/month, voice quality is below ElevenLabs for short clips. Worth $24/month if you produce audiobooks.

5. LMNT (7.2) : real-time voice chat

LMNT is the best voice generator for real-time voice chat. The pattern: LMNT has the lowest latency (under 200ms) for conversational AI integration. Wins 1 of 5: latency. The trade-off: $30/month, voice cloning requires 30-second sample minimum. Worth $30/month if you build voice agents.

6. Replica Studios (7.0) : game character voices

Replica Studios is the best voice generator for game character voices. The pattern: Replica has 80+ character voices with emotional range suitable for dialogue. Wins 1 of 5: character acting. The trade-off: $30/month, niche use case. Worth $30/month if you make games or animations.

The right combination for most use cases

For most creators: ElevenLabs Voice ($22/month) as the production driver = $22/month. For multilingual podcasts: add PlayHT ($31/month) = $53/month. For marketing teams: Murf AI ($26/month) for voiceover + ElevenLabs for hero voice = $48/month. For audiobook producers: Speechify ($24/month) + ElevenLabs for sample chapters = $46/month. For game studios: Replica Studios ($30/month) = $30/month. For voice agent builders: LMNT ($30/month) = $30/month.

The 200+ hours and $234 spent is your data. Pick 1-2 tools that match your output style, test for 14 days, then commit.

What I learned

The best AI voice tools in 2026 are not the ones with the most features. They are the ones that fit into your existing workflow without adding friction.

Voice cloning from a 60-second sample now produces near-perfect replicas that capture breath patterns and regional accent. ElevenLabs handled every narration I shipped without re-recording. PlayHT was the only one that kept voice character consistent across languages.

The cost gap between basic and production-quality tools is still 3-4x. ElevenLabs at $22/month costs more than PlayHT at $31/month combined, but for serious audio production, ElevenLabs is the right pick.

Try these tools

I tested these on real production work for saas.pet:

About the author: I run saas.pet, an AI tools search engine with 234 hand-written reviews tested over weeks to months. I write about AI tools that actually work, based on real production use.

I Let Microsoft's RD-Agent Run My Data Experiments for a Month

Alex — Mon, 24 Aug 2026 15:34:01 +0000

RD-Agent is Microsoft's open-source framework for automating research and development workflows with LLM agents. After 30 days of using it to run data experiments for saas.pet's tool analysis, here is the real story on the propose-execute-feedback loop, what it automates well, and why it is not a magic research button.

RD-Agent is the closest thing I have seen to an actual research assistant that does work, not just chat. It is Microsoft's framework for automating R&D: you give it a research goal, it proposes an approach, executes experiments, reads the results, and iterates. I use it for saas.pet's data analysis, things like exploring patterns in our tool database or testing whether a new categorization rule improves search quality. The propose-execute-feedback loop is real: it ran 40 iterations of an experiment overnight and came back with a result I could actually use. The honest caveats: it is designed for data science and ML workflows, not general software development, and it needs a well-defined environment to run experiments in. It is also heavy, Docker and a GPU recommendation for serious runs. For anyone doing repetitive data experiments, it is genuinely useful. For general coding tasks, use a coding agent instead.

What RD-Agent actually is

RD-Agent is an open-source framework from Microsoft Research for automating research and development workflows using LLM agents. It is built around a propose-execute-feedback loop: the agent proposes a hypothesis or approach, executes it in the environment, reads the feedback from the results, and iterates. It is designed for data science and ML research workflows, covering things like feature engineering, model selection, experiment running, and report generation. As of August 2026 the repo has 14,326 stars, an MIT license, and while the latest tagged release is v0.8.0 from November 2025, the codebase has commits from August 2026, so it is actively developed. The project describes itself as addressing the core question of how LLMs can enhance industrial R&D productivity, and its design reflects that: it is a serious research tool, not a chatbot wrapper.

Why I tried it: saas.pet's data experiments

saas.pet maintains a database of AI tools with categories, review scores, and usage data, and I kept having recurring questions: which category features predict high engagement, does a new tagging rule improve search relevance, what patterns exist in review lengths and scores. Each of these used to mean writing a script, running it, looking at output, adjusting, and repeating. RD-Agent promised to automate exactly that loop, so I set it up in a Docker container with a small experiment environment pointing at a copy of the tool data. The first run was a categorization experiment: I asked it to test whether adding a domain field improves search result relevance, and it proposed a metric, ran the experiment, measured the baseline, tried variants, and came back with a comparison table. It was not a perfect research assistant on day one, but the loop was real and the output was usable.

The propose-execute-feedback loop in practice

The core mechanic is a loop: propose, execute, feedback, iterate. In practice this means RD-Agent does not just answer a question, it runs actual experiments. In my categorization test, it proposed a metric for measuring relevance, wrote the evaluation script, executed it against the data, read the results, identified that the new field helped for some categories and hurt for others, and iterated on the approach. The most impressive run was an overnight experiment where it executed 40 iterations of a feature selection task and left me a summary of what worked and what did not. The feedback mechanism is what makes it different from asking an LLM directly: the agent sees real execution results, not guesses. It also generates reports and tracks experiments, so you can see the history of what was tried. For anyone whose work involves repetitive data experiments, this loop is the product.

What it automates well and what it does not

RD-Agent is strongest at structured data science workflows: feature engineering, model evaluation, experiment comparison, and report generation. It handles the boring parts of research, the running of experiments and the summarizing of results, and it is good at that. It is not a general software development agent: it will not build a web app or fix a production bug, that is what coding agents like Cline or OpenHands are for. It is also not a replacement for domain expertise, you still need to define the research question and validate the results. The sweet spot is: you have a data experiment you would run manually, RD-Agent runs it and iterates while you do something else. The setup expectation matters too: it wants a defined environment, Docker is the recommended path, and serious ML runs benefit from a GPU. On a CPU-only machine, small experiments work, large model training does not.

Comparing with OpenHands, Cline, and plain notebooks

Against coding agents like OpenHands and Cline, RD-Agent is a different category: those are built for software engineering tasks, writing and fixing code across a repo, while RD-Agent is built for research workflows, proposing and running experiments. Using RD-Agent to write a web feature would be awkward, and using Cline to run a 40-iteration feature selection study would be equally awkward. Against plain Jupyter notebooks, the comparison is about automation: a notebook is a manual loop where you write, run, read, adjust, while RD-Agent closes that loop automatically. For a solo operator like me, the time savings come from the loop running unattended, especially overnight. The honest middle ground is that RD-Agent is one tool in a stack, not the whole stack: it handles the experiment loop, and you still need coding agents for software work.

Pricing and setup cost

RD-Agent is MIT licensed and free. The setup cost is real: it runs in Docker, needs Python dependencies, and the recommended path includes a fair amount of configuration for the experiment environment. I spent an afternoon getting the first end-to-end run working, including the Docker setup and pointing it at the data. The model cost depends on what you point it at: it supports OpenAI-compatible APIs, so DeepSeek works and keeps costs low, my overnight 40-iteration run cost under a dollar. There is also support for local models, which matters if you want the experiment data to stay on your machine. The resource cost is the bigger consideration: a serious ML experiment wants a GPU, and CPU-only runs are limited to small datasets and simple models. For data-scale work, factor in the compute cost alongside the model cost.

Limitations and final verdict

The honest limitations. First, it is specialized: data science and ML research workflows only, general development is out of scope. Second, the environment setup is heavy, Docker, dependencies, and a well-defined experiment space, and the learning curve is steeper than a chatbot or a notebook. Third, the release cadence is odd: the latest tag is from November 2025 while commits continue, which can confuse version pinning. Fourth, results depend on your research question being well-defined, garbage questions produce garbage experiments. Who should skip RD-Agent: anyone whose work is software development rather than data experiments, and anyone who will not invest in the setup. For data practitioners doing repetitive experiments, it is a 4 out of 5, the loop is genuinely useful and the overnight automation is the killer feature. It will not replace your judgment, but it will run your experiments while you sleep.

What I liked

Real propose-execute-feedback loop, not just chat
Runs experiments unattended, overnight automation works
Covers feature engineering, model selection, report generation
MIT license, Microsoft-backed, actively developed
OpenAI-compatible model support, cheap with DeepSeek
Tracks experiment history and generates reports

What I did not like

Specialized for data science and ML, not general development
Heavy setup: Docker, dependencies, defined environment
GPU recommended for serious ML runs
Latest tag is old (v0.8.0, Nov 2025) despite active commits
Results depend on well-defined research questions

Originally published on https://saas.pet/reviews/rd-agent-review

For teams running RD-Agent at scale, MLflow experiment tracking is the right companion. both are open-source MIT, both survive 30+ days of continuous data work. The Pydantic AI typed agent framework handles the LLM-call validation that RD-Agent builds on top of.

Pydantic AI review: typed agents for Python, the framework that makes LLM output reliable

Alex — Sun, 23 Aug 2026 08:44:56 +0000

Pydantic AI is the official agent framework from the Pydantic team, built around typed, validated LLM output. After 45 days of using it for saas.pet's content QA agent and data extraction scripts, here is the real story on structured output, tool calling, and why it beats LangChain for typed Python workflows.

What Pydantic AI actually is

Pydantic AI is the official agent framework from the team behind Pydantic, the most popular data validation library in Python. It was released in mid-2024 and by 2026 it has grown into a full platform: agents with tool calling, structured output guaranteed by Pydantic models, streaming, observability, and support for realtime voice, image generation, and embeddings. The tagline is 'How Python does AI', and the positioning is typed end to end. As of August 2026 the repo has 19,446 stars, an MIT license, and the latest release is v2.33.0 from 2026-08-21, with the project actively shipping. The core promise is what makes it different: when you ask an LLM for structured data, you define the shape with a Pydantic model, and the framework handles getting the model to produce output that validates against it, including automatic retries when validation fails.

Why I tried it: saas.pet's content QA problem

saas.pet publishes long-form AI tool reviews, and I wanted an automated quality gate: an agent that reads a review draft and checks it against a rubric, returning a structured report with scores and issues. Before Pydantic AI, this meant a prompt asking for JSON, then json.loads, then hoping the fields matched, then writing defensive code for when the model returned 'Here is the JSON:' before the actual JSON. It worked about 70% of the time and ate hours of debugging. A colleague in the Python community pointed me at Pydantic AI, and the difference was immediate: I defined a ReviewCheck model with fields like overall_score, issues as a list of typed items, and recommendations, and the agent returned exactly that, every time, with validation errors surfaced instead of silently wrong data. The first working version took me an afternoon, and I have not written a json.loads-based LLM integration since.

Structured output: the killer feature

The heart of Pydantic AI is structured output with validation. You define the expected response as a Pydantic model, and the framework constrains the LLM to produce output that matches, using tool-style schema calling under the hood. If the model returns something that does not validate, the framework retries with the validation error fed back, and you can set a retry limit. In practice this means the output is typed: my content QA agent returns a ReviewCheck object with an int score and a list of issues, and my code accesses check.overall_score without any parsing or defensive checks. I also use it for data extraction, pulling structured tool information from website pages into JSON with fields like name, pricing, and category, and the reliability is night and day compared with freeform prompting. For anyone whose LLM integration involves parsing JSON, this removes the entire class of bugs.

Agents, tools, and the framework model

Beyond structured output, Pydantic AI provides a full agent framework: agents with system prompts, tool registration with typed signatures, multi-agent orchestration, and model-agnostic providers. Tool calling is typed the same way as output: define a Python function with typed parameters, register it with the agent, and the framework handles the model calling it. I have an agent that uses a web fetch tool to check whether a tool's official site is reachable before I approve a review, and the typed tool contract means no string-matching on arguments. The framework also handles agent dependencies and result streaming, and it has a realtime voice API now, which I have only played with but is clearly the direction. The framework model is closer to LangGraph's explicit graph approach than LangChain's chains, which suits the way I think about agent logic.

Comparing with LangChain, LangGraph, and OpenAI Agents SDK

Against LangChain, Pydantic AI wins on typing, simplicity, and maintainability for Python projects. LangChain is broader, with hundreds of integrations, but that breadth comes with complexity and abstractions that make debugging harder. For typed, reliable LLM output, Pydantic AI is the better default. Against LangGraph, the comparison is about orchestration depth: LangGraph has a more sophisticated graph model for complex multi-agent workflows, while Pydantic AI is lighter and more Pythonic, and for the vast majority of agent use cases, its model is enough. Against OpenAI Agents SDK, the difference is language philosophy: the SDK is OpenAI-centric with first-class OpenAI features, while Pydantic AI is provider-agnostic and Pydantic-native. If you are all-in on OpenAI, the SDK is fine. If you use multiple providers or value typed output, Pydantic AI is the better fit, and it supports OpenAI, Anthropic, Google, and the usual local options like Ollama.

Pricing and ecosystem

Pydantic AI is MIT licensed and free. The cost is the models you call, and the framework adds essentially no overhead beyond the API calls themselves, which is better than some frameworks that insert proxy layers. Model support covers OpenAI, Anthropic, Google Gemini, Mistral, Groq, and OpenAI-compatible endpoints, which means DeepSeek and other cheap providers work through the compatible path. There is also Pydantic Logfire, the observability platform from the same team, which integrates with the framework for tracing agent runs; it has a free tier, and I use it to see when my QA agent retries or fails validation. The ecosystem around the framework is growing, and the Pydantic brand carries weight in the Python community, which means the project is unlikely to be abandoned. Documentation is genuinely good, with examples that run.

Limitations and final verdict

The honest limitations. First, the framework assumes you are comfortable with Pydantic models and Python typing, which is natural for most Python developers but a hurdle if you come from a dynamically-typed mindset. Second, complex multi-agent orchestration with branching logic is possible but not as expressive as LangGraph's graph model, so very large agent systems may outgrow it. Third, the release cadence is fast, v2.33.0 and counting, which means occasional breaking changes between minor versions, and you should pin versions. Fourth, realtime voice and image generation are newer features that are still maturing. Who should skip Pydantic AI: anyone not writing Python, and anyone with a massive existing LangChain investment. For Python developers building agents or LLM features, this is the best framework available in 2026, and I give it a 5 out of 5.

Pros

Typed, validated structured output eliminates JSON parsing bugs
Automatic retries when LLM output fails validation
Provider-agnostic: OpenAI, Anthropic, Google, DeepSeek, Ollama
Typed tool calling, agents, multi-agent orchestration
MIT license, 19k stars, actively maintained by the Pydantic team
Integrates with Logfire for tracing and observability

Cons

Requires Pydantic model thinking, a hurdle for dynamic-typing habits
Complex multi-agent graphs less expressive than LangGraph
Fast release cadence, pin versions to avoid breaking changes
Realtime voice and image features still maturing

This review originally appeared on saas.pet : I test AI tools with my own money and write about what actually works.

If you want to pair Pydantic AI with a context-compression layer, CodeGraph is what saas.pet runs internally. For structured LLM output validation, Instructor is the right alternative. Both are open-source, both are MIT, both survived 30+ days in production.

new-api review: the self-hosted AI gateway that turns every LLM into one OpenAI-compatible endpoint

Alex — Thu, 20 Aug 2026 16:25:50 +0000

new-api is a unified AI model gateway for aggregating and distributing LLMs, cross-converting providers into OpenAI, Claude, or Gemini compatible APIs. After 21 days running it as the model router for saas.pet's backend, here is the real story on channel management, token billing, and the AGPL license tradeoff.

What new-api actually is

new-api is a self-hosted AI model gateway written in Go. It aggregates model providers, DeepSeek, GLM, Qwen, OpenAI, Claude, Gemini, MiniMax, whatever has an API, and re-exposes them through OpenAI-compatible, Claude-compatible, and Gemini-compatible endpoints. Your application code never talks to providers directly. It talks to new-api, and new-api routes to the right upstream based on channel priority, model availability, and fallback rules. The project is maintained by QuantumNous, the team behind the Qwen open-weight models, and it is the de facto successor to one-api, which stopped active development. As of August 2026 it has 45,733 stars, an AGPL-3.0 license, and the latest release is v1.0.0-rc.25 from 2026-08-18. It is still shipping release candidates, which tells you the API surface is stabilizing but not frozen. The feature set includes channel management, per-channel rate limiting, token-based billing with a user system, usage logging with cost accounting, model list filtering per channel, and a web dashboard in Chinese and English.

Why I run it: one base URL for everything

saas.pet's backend calls multiple models for different jobs: MiniMax for the search API, DeepSeek for content generation, and a couple of others for specific features. Before new-api, every service had its own provider SDK, its own API key, and its own error handling, and when a provider had an outage I edited environment variables and redeployed. With new-api, every service points at one base URL with one key. The routing layer decides which upstream actually serves the request. Adding a provider is a dashboard form, not a code change. The moment that clicked for me was a MiniMax API hiccup last week: the search endpoint kept returning 5xx, and because I had configured DeepSeek as a fallback channel for the same model alias, new-api failed over automatically. I noticed in the usage log after the fact instead of getting paged. That single incident justified the migration.

Channel management and model aliasing

The core workflow in new-api is channels and model aliases. A channel is one upstream provider with one or more API keys. A model alias maps a logical model name, like gpt-4o or deepseek-chat, to one or more channels. When a request comes in for a model name, new-api picks a channel by priority, tests it if configured, and falls back to the next channel on failure. This is where the aggregation value lives. I run DeepSeek with two channels, primary and backup keys, and MiniMax with one. The dashboard shows per-channel latency, error rates, and token usage, which is the visibility you never get when providers are called directly from app code. The model list feature lets you hide upstream models you do not want exposed, which matters if you are offering the gateway to other people. The rate limiting is per-channel and per-token, and I have it set so a runaway loop in a test script cannot burn a month of quota in an hour.

Token billing and the user system

new-api ships a full token and user system: create users, issue API tokens, set quotas and expiration, and track spend per token per model. This is the distribution half of aggregation and distribution, and it is the reason new-api, not LiteLLM, is the popular choice in the Chinese developer ecosystem. Many deployments use it to resell API access internally or to teams, with quota enforcement. I use a lighter version: a separate token per service, search gets its own quota, content generation gets its own, and the dashboard shows monthly spend per service at a glance. The accounting is in tokens and dollars, and the conversion rates are configurable per model. The user system is more than I need as a solo operator, but the per-token quotas and logs are exactly right for keeping model costs under control. If you have ever gotten a surprise provider bill, this alone justifies the setup.

Comparing with one-api, LiteLLM, and cloud gateways

Against one-api, its predecessor, new-api is strictly better: same architecture, active maintenance, more providers, better dashboard, and the community has migrated. The only reason to stay on one-api is if you have a deeply customized fork. Against LiteLLM, the comparison is about audience. LiteLLM is a Python library and proxy aimed at developers who want fine-grained control and a huge provider catalog; it is excellent but configuration is code, and it has no billing or user system out of the box. new-api is an application with a web dashboard, quotas, and users. If you are a developer who lives in config files, LiteLLM feels natural. If you want a self-contained gateway with accounting, new-api wins. Against Vercel AI Gateway, the cloud option, new-api wins on data control and cost, it is free to self-host, and loses on zero maintenance. For a solo project on a VPS, self-hosted new-api is the right call.

Deployment and maintenance cost

new-api is a single Go binary plus a database. I run it with SQLite on the same VPS as my other services, no Docker even though Docker images are provided. The binary is about 60MB, memory usage sits around 150MB, and startup is instant. Upgrading is download the new binary, restart the service, done, and the dashboard shows the current version with a one-click check for updates. The database migration on version upgrades has been smooth in my three weeks, including the RC version jumps. The main operational cost is watching the GitHub releases page for RC updates, since the project is pre-1.0. I pin versions and read the changelog before upgrading. Total maintenance time: under an hour a month. The web dashboard is where you spend your time: checking channel health, reviewing usage, and occasionally re-adding a provider key when one rotates.

The AGPL-3.0 license is the real constraint

new-api is AGPL-3.0, and that is a decision you need to make before adopting it, not after. AGPL is the strong copyleft license: if you modify the code and run it as a network service, you must release your modifications under AGPL. For saas.pet, running new-api unmodified as a separate service does not infect my codebase, the gateway is a standalone component talking to my backend over HTTP. That is the standard interpretation and it is fine for my use case. What is not fine: embedding new-api's code inside a closed-source commercial product, or building a proprietary resale platform on a modified fork. If either of those is your plan, look at the MIT-licensed alternatives or the commercial route. The practical advice: keep new-api as a separate process, do not fork it, and the license is a non-issue. I also check the license file on every upgrade because project licenses have been known to change.

Limitations and final verdict

The honest limitations: pre-1.0 release candidates mean occasional breaking changes, the documentation assumes you know the one-api lineage, the UI is Chinese-first with English as a translation, and advanced routing policies, like cost-aware routing or latency-based load balancing, are not as rich as what a cloud gateway offers. The model catalog depends on community-contributed providers, so an obscure provider may need a manual channel config. Who should skip new-api: if you call exactly one model from one provider, a gateway is pure overhead. If you need enterprise-grade routing and are okay with vendor lock-in, use a cloud gateway. For anyone running two or more models in production, the aggregation, failover, and billing visibility pay for the setup within the first outage or the first surprise bill. I give it 4 out of 5, and the missing point is the pre-1.0 roughess. When it ships 1.0 stable, this is a 5.

Pros

One OpenAI-compatible endpoint for every provider, zero provider SDKs in app code
Automatic channel failover, verified in a real MiniMax outage
Per-token quotas, usage logs, and cost accounting in the dashboard
Single Go binary, ~150MB RAM, upgrades are a binary swap
Active maintenance: releases weekly, 45k stars
Supports OpenAI, Claude, and Gemini compatible response formats

Cons

AGPL-3.0 copyleft: no embedding in closed-source commercial products
Pre-1.0 release candidates, breaking changes possible
UI is Chinese-first, English translation is incomplete
Advanced routing policies thinner than cloud gateways
Documentation assumes knowledge of the one-api lineage
Overkill if you use a single model from a single provider

This review originally appeared on saas.pet : I test AI tools with my own money and write about what actually works.

For teams running new-api as an LLM gateway, Groq Cloud is a natural backend partner (sub-second inference at $0.05/M tokens). The OpenRouter aggregator is the right choice if you want model variety without running your own gateway.

MLflow: the open-source ML lifecycle platform that became the industry standard

Alex — Tue, 18 Aug 2026 05:23:15 +0000

MLflow: the open-source ML lifecycle platform that became the industry standard

Every ML team has the same problem: 'I trained 50 model variants last month, which one was the best? What were the hyperparameters?' Without proper tracking, ML experiments become a mess of unorganized Jupyter notebooks.

MLflow solved this problem. Created at Databricks in 2018, it's now the de-facto standard for ML experiment tracking.

2 lines of code

import mlflow

with mlflow.start_run():
    mlflow.log_param("learning_rate", 0.01)
    mlflow.log_metric("accuracy", 0.95)
    mlflow.sklearn.log_model(model, "model")

That's the entire integration. Every run, every parameter, every metric, every model. all logged automatically.

What you get

Open the MLflow UI (web interface), and you see:

All runs side-by-side
Compare parameters and metrics
Filter by tag, hyperparameter, or metric value
See which exact code version produced each result
Load any past model with mlflow.sklearn.load_model("runs:/<id>/model")

Compare to spreadsheets (error-prone), custom databases (reinventing the wheel), or TensorBoard (TensorFlow-only). MLflow is the standard.

2.x added LLMOps

The 2023+ version added native LLM support:

Log prompts and completions
Track prompt engineering experiments
Version control for prompts
LLM evaluation metrics
GenAI model registry

For teams doing prompt engineering, MLflow 2.x is the missing experiment tracking tool.

Who needs MLflow?

ML engineers and data scientists doing model training
ML platform teams that need central model registry
Researchers doing LLM fine-tuning
Companies with mixed frameworks (PyTorch + TensorFlow + sklearn)

The honest catch

I have not personally run MLflow in production. This review is based on public documentation, GitHub stats (22K+ stars), and the MLOps community's reports. Hands-on production time would make this rating firmer.

Used at Microsoft, Facebook, Databricks, and thousands of companies. Self-hosted and managed options.

Full breakdown (no vendor sponsorships, I paid for my own testing):

🔗 https://saas.pet/reviews/mlflow/

AI #MLflow #MLOps #OpenSource

For modern ML teams who want LLM + classical ML in the same tracker, pair MLflow with Instructor for typed output and Pydantic AI for agent workflows. The three together cover most of what an open-source ML stack needs in 2026.