01
RAG and retrieval
Ground answers in your own knowledge with chunking, embeddings and vector search, so responses are sourced and citable.
- pgvector
- Embeddings
- Reranking
AI solutions and agents
AI solutions that turn your idea into a product in the world.
AI Solutions at Oxwyn Studio means turning your idea into a grounded, production-ready AI product: retrieval on your own data, agents with guardrails, evaluation before launch and observability after it, so real people can rely on what we ship.
Idea to product
Idea
Blueprint
Ground
Ship
Prompt
Grounded answer
Your policy gives a 14-day refund window on unused items, with store credit up to 30 days.
refund-policy.pdf p.2terms.md #returns
Sources
2 cited
Eval score
0.96
Cost
$0.004
From idea to live product
Your dream, engineered into something real
We take the idea, ground it in your real data, wrap it in guardrails and evaluation, and ship a product that holds up in front of real users.
- Idea
- Blueprint
- Ground
- Guard
- Ship
What we can build
Tell us the dream. We ship the product.
If you can describe it, we can probably build it. Here is how a handful of real wishes turn into grounded, production AI.
Support agent
“I wish customers could just ask our docs instead of emailing support.”
A support agent grounded on your docs and tickets, with citations and safe fallback to a human.
Research copilot
“My team spends hours reading reports to find three numbers.”
A research copilot that retrieves, summarises and cites across your document corpus on demand.
Document extraction
“We get thousands of invoices and someone types them in by hand.”
A structured extraction pipeline that turns messy PDFs into validated, typed data with confidence scores.
Action agent
“I want an assistant that can actually do things, not just chat.”
A tool-using agent that books, updates and queries your real systems through guarded function calls.
Semantic search
“Our users never find the right product in our huge catalogue.”
A semantic search and recommendation engine over your catalogue using vector embeddings.
Napkin to product
“I sketched an idea on a napkin. Can it even be built?”
A blueprint, a working prototype, then a hardened production build. We start from the napkin.
Where it starts
Bring us the idea you cannot stop thinking about. Napkins welcome.
Why you need this
The three things that kill most AI projects.
Pain 1
It worked in a notebook, it died in production
The demo dazzled, then real users arrived. Hallucinations, timeouts and runaway token costs turned a magical prototype into an unreliable feature nobody trusts.
Pain 2
Your knowledge is trapped in PDFs and old systems
The model has nothing real to stand on, so it confidently invents answers about your own product, pricing and policies. Without grounding, fluency is just a better-spoken guess.
Pain 3
There is no wall between user input and the model
Prompt injection, jailbreaks and unbounded spend stop being theory the moment you go live. Without guardrails, one crafted message becomes an incident, a leak or a bill.
See it for yourself
Grounded or guessing? Flip the switch.
Pick a question, then toggle grounding. Ungrounded, the model gives a confident, plausible guess. Grounded, it answers from your real data and cites the source.
UngroundedGrounded
Question
What is your refund window?
Grounded answer
Your policy gives a 14-day refund window on unused items, with store credit up to 30 days.
refund-policy.pdf, p.2terms.md #returns
The method
Five steps from concept to production AI.
A repeatable build path: frame the outcome, ground the data, wire the agent, evaluate and harden, then ship with observability your team can operate.
01
Frame the outcome
Define the job to be done, the success metric and the failure modes before any model is chosen, so we build a product, not a tech demo.
DiscoverySuccess metric
02
Ground the data
Ingest, chunk and embed your knowledge into a vector store so answers come from your truth, not the model's imagination.
IngestionpgvectorRAG
03
Wire the agent
Build the retrieval, tools and orchestration through the Vercel AI SDK with streaming, function calls and model routing.
AI SDKToolsRouting
04
Evaluate and harden
Add a prompt firewall, output validation and an eval harness that scores accuracy and hallucination before anything ships.
EvalsGuardrailsFirewall
05
Ship and observe
Deploy with cost caps, rate limits, tracing and dashboards so you see every call, every cost and every failure in production.
ObservabilityCost capsTracing
Grounded by design
Answers from your data. Guardrails on every call.
Grounded AI architecture
Every answer passes through defence in depth
- 01
User query
from your app
- 02
Prompt firewall
sanitise + detect injection
- 03
Retrieval
vector search on your corpus
- 04
Model
via AI Gateway
- 05
Output validator
schema + safety check
- 06
Cited answer
sourced + grounded
What's included
Every AI build ships with this.
- Grounded retrieval (RAG) over your own documents and data
- Agent orchestration with tools, streaming and model routing
- Prompt firewall and input sanitisation against injection
- Output validation and structured, typed responses
- Evaluation harness scoring accuracy and hallucination rate
- Cost caps, rate limiting and per-request budget controls
- Observability: tracing, token spend and latency dashboards
- A codebase you own, on the Vercel AI SDK and AI Gateway
What you receive
A working AI product you own, not a fragile demo.
Agent console
The working product: a streaming agent with tool calls, retrieved sources and a live token-cost meter.
Retrieval and citations
RAG over your corpus: ranked chunks, similarity scores and answers with inline, verifiable citations.
Evaluation harness
A test suite that scores accuracy and hallucination across prompt versions before anything ships.
Guardrails and firewall
Prompt-injection detection, content safety and budget caps, with a log of what was blocked and why.
Evaluation and hardening
We try to break it before your users do.
What we build
Six AI capabilities. One stack you fully own.
From retrieval and agents to guardrails, evaluation and model routing, every part is built into a codebase you own on the Vercel AI SDK, with no provider lock-in.
Grounded, cited, guarded
02
AI agents and tools
Agents that take action through guarded function calls, with orchestration, streaming and multi-step reasoning.
- AI SDK
- Tool calls
- Orchestration
03
Structured extraction
Turn messy documents into validated, typed data with schemas and confidence scoring you can trust downstream.
- Schemas
- Validation
- Typed output
04
Guardrails and safety
A prompt firewall, content filtering and output validation that stop injection, jailbreaks and unsafe responses.
- Firewall
- Filtering
- Validation
05
Evaluation and observability
Eval suites that score quality plus tracing, token spend and latency dashboards so you see everything in production.
- Evals
- Tracing
- Dashboards
06
Model routing
Route each task to the right model through the AI Gateway, balancing quality, latency and cost with caps and fallbacks.
- AI Gateway
- Routing
- Cost caps
No lock-in. The stack we build your AI product on, all of it yours to own, retrain and extend.
- Vercel AI SDK
- AI Gateway
- PostgreSQL + pgvector
- Next.js
- TypeScript
- Evaluation tooling
FAQ
Questions founders ask before they build with AI.
What does an AI solution from Oxwyn Studio actually include?
A real, deployed AI product: retrieval grounded on your data, an agent or assistant wired through the Vercel AI SDK, a prompt firewall and output validation, an evaluation harness, and cost and observability controls. You receive a codebase you own, not a locked demo.
How do you stop the AI from hallucinating?
Two ways. First, grounding: answers are retrieved from your own documents and returned with citations, so the model reasons over real text instead of inventing it. Second, an evaluation harness and output validation that score and catch unsupported or malformed answers before they reach users.
Can you turn my idea into a product even if it is just a concept?
Yes. That is the heart of this service. We start from the idea, frame the outcome and failure modes, build a grounded prototype, then harden it into a production build. The napkin sketch is a perfectly good starting point.
What is RAG and why does it matter?
Retrieval-augmented generation. Instead of relying on what a model memorised, we ingest your knowledge into a vector database, retrieve the most relevant passages for each question, and have the model answer from those. It is the difference between a confident guess and a sourced answer.
How do you protect against prompt injection and abuse?
Every request passes through a prompt firewall that sanitises input, detects injection and jailbreak patterns, and enforces rate limits and per-request budget caps. Outputs are validated against a schema before use, so a crafted message cannot leak data or trigger unsafe actions.
Which models and providers do you use?
We build on the Vercel AI SDK and AI Gateway, which let us route each task to the right model, OpenAI, Anthropic, Google and others, and switch or fall back without rewriting the app. You are never locked to a single provider.
How do you control AI running costs?
Model routing sends cheap tasks to cheap models, caching avoids repeat work, and hard cost caps plus rate limits stop runaway spend. Observability dashboards show token spend per feature so you can see and tune cost continuously.
Do we own the AI product and its data?
Yes. You own the repository, the vector store and the data inside it. There is no platform lock-in, and your proprietary knowledge stays in infrastructure you control.
Have an idea you cannot shake?
Let's turn it into a real, grounded AI product.
A senior engineer maps your idea to retrieval, guardrails and a working prototype plan, on a 15-minute call.
