Castform + Neon: 100x Cheaper AI Search Than GPT-5.6

What happened

A 4-billion-parameter open-source model just matched GPT-5.6 Sol's search accuracy while costing 100x less per request. The result comes from Castform, a reinforcement learning (RL) post-training platform, running its pipeline directly against Neon's serverless Postgres (branded Lakebase) and its new Search extensions.

The numbers are the headline here. A typical multi-turn agentic search request using GPT-5.6 Sol takes more than 10 seconds and costs roughly $0.03 end-to-end. Small open-weight models are already around 100x cheaper to run — the catch has always been that, out of the box, they simply aren't accurate enough for production search tasks. Castform closes that gap by post-training the small model with reinforcement learning on real retrieval tasks, using Neon's Lakebase Search extensions (`lakebase_text` and `lakebase_vector`) as the search environment during both training and inference.

Cofounder Ying Hang Seah summed up the thesis behind the release: most companies already have the best training data they'll ever need sitting in their own databases — internal docs, support tickets, product records, wikis. The hard part was never finding data. It was turning raw rows into a usable RL training loop, and giving agents infrastructure to search and mutate that data cheaply at scale.

Why it matters

Agentic search has quietly become expensive. Back in 2022, most teams solved retrieval with embedding similarity search — pgvector became one of Neon's most downloaded extensions, and engineers hand-built RAG pipelines around it. That was a one-shot pattern: embed the query, fetch nearest neighbors, done.

By 2025, agents shifted to multi-hop search — decomposing a hard question into smaller ones and looping through several retrieval steps before answering. Each loop iteration means another call to a frontier model. Latency and cost compound with every hop, which is exactly why a 10-second, $0.03 request became the norm for complex queries.

That cost structure quietly caps how much agentic search any team can afford to ship. If every user query triggers three or four frontier-model round trips, a feature that looks cheap in a demo becomes a real line item at scale. RL post-trained small models change the economics: instead of paying frontier prices per hop, you pay once to train a 4B model that performs as well as the frontier model on your specific retrieval task, then run it at a fraction of the inference cost indefinitely.

How to use it today

Castform's pipeline plugs into Neon at four stages, and none of them require machine learning or GPU expertise from the team using it:

- Corpus storage — raw documents live directly in Postgres on Neon, no separate vector database to stand up.

- Synthetic data generation — Castform's training pipeline uses `lakebase_text` and `lakebase_vector` to auto-generate training tasks from that corpus.

- RL training — every rollout's search tool call runs against Lakebase Search on Neon, so the model learns to retrieve using the same infrastructure it will use in production.

- Production inference — the finished model calls the identical search tool it trained on, which avoids the usual mismatch between a training environment and a live one.

Effective RL post-training needs three ingredients: a task (answer a user's question), an environment (a search tool over your corpus), and a reward function (a way to score whether the answer was correct). Most companies stall out before step one because assembling a clean dataset of tasks and rewards from scratch normally requires heavy data engineering and manual labeling. Pointing Castform at an existing Neon database skips that step, since the corpus, the search tool, and the training loop all run on infrastructure that's already in place.

Teams experimenting with smaller AI tooling before committing to a full RL pipeline can also prototype lighter workflows with free utilities like the ones at [mykreatool.com](https://mykreatool.com), which is a reasonable first stop for testing prompt-level ideas before investing in post-training infrastructure.

Who benefits

This approach is most valuable for teams that already run search or Q&A features on top of proprietary data — internal documentation, product records, support articles, customer interaction logs, and operational databases. Enterprises with large volumes of unstructured internal content but no dedicated ML team are the clearest fit, since Castform's stated goal is to make post-training as approachable as prompt engineering.

Startups and creators building agentic products also stand to gain, since a 100x cost reduction on search-heavy requests can be the difference between a feature being commercially viable at scale or not. Marketers and product teams running high-volume, repetitive retrieval tasks (support bots, internal knowledge assistants, research copilots) get the most immediate return, since those workloads generate the multi-hop, multi-call costs this approach specifically targets.

Risks

The 100x cost and accuracy claims come from Castform's own benchmark against GPT-5.6 Sol on a specific search-retrieval task — results on other task types (reasoning, generation, multi-modal work) haven't been demonstrated and likely won't transfer directly. RL post-training also still requires a real reward function; tasks where "correct" is subjective or hard to score automatically will be harder to post-train for than clean-cut search accuracy.

There's also a lock-in consideration: the pipeline is built specifically around Neon's Lakebase Search extensions, so teams on other Postgres providers or separate vector databases would need to migrate data or adapt the approach before they can replicate these results. And as with any post-trained model, performance is only as good as the underlying corpus — messy, inconsistent, or sparse internal data will produce a correspondingly weaker model regardless of the training method.

Conclusion

Castform's results suggest that for well-defined retrieval tasks, small open-source models post-trained with RL on your own data can match frontier-model accuracy at a fraction of the cost — turning agentic search from a per-query expense into a fixed training cost. For teams already sitting on large, unused internal datasets, this is a concrete reason to revisit whether search infrastructure needs a frontier API call at all, or whether a purpose-trained small model quietly does the job for less.