Skip to content
ByteKnot Labs

Track 01 · AI-native

Custom AI agents, RAG systems and private LLMs

Models you can measure, explain and run inside your own network.

Overview

Overview

ByteKnot Labs builds custom AI agents, retrieval-augmented generation (RAG) systems and private language models, and takes each through train, test, validate and deploy: fine-tune or index on your data, in your account; test against an evaluation set built from real cases; validate with guardrails, red-team checks and human sign-off; and deploy on Google Cloud, Oracle OCI or your own GPUs with tracing, cost limits and a rollback path. Classical machine learning for classification and forecasting runs through the same pipeline.

agents · RAG · fine-tuning · private LLMs

You probably need this if

  • Your data cannot leave your network, so hosted chatbots are off the table.
  • Prompting works, but it is too slow, too expensive or too inconsistent at volume.
  • Your RAG prototype finds the wrong passages and nobody knows why.
  • An auditor or regulator will ask how the model was tested.
  • Your team repeats the same multi-step task across several systems every day.

Capabilities

What we build.

AI agents

We build agents that work through a task step by step with a fixed set of tools: searching your systems, updating records and drafting replies for approval. Each agent is tested on scenarios from your real cases, and anything expensive waits for a person.

  • Tool use through your APIs or Model Context Protocol servers
  • Approval gates on expensive or irreversible steps
  • State that survives restarts, with checkpoints
  • Scenario tests that score the result and the path
  • Tracing and cost limits on every run

RAG systems

Retrieval-augmented generation answers from your documents and data, with a citation behind every claim. Most quality problems start in retrieval, so we tune how documents are split, searched and ranked on your own questions, and score retrieval separately from the answer.

  • Ingestion from PDFs, wikis, tickets, databases and APIs
  • Hybrid search and reranking tuned on your queries
  • Permissions applied at retrieval time
  • Citations, and a plain "not in the sources" when the answer is missing
  • Re-indexing as documents change

Fine-tuning and private models

When prompting cannot hold a style, format or behaviour at volume, we fine-tune an open-weight or hosted model on your examples, in your account. When data cannot leave your network, we serve open-weight models on your own GPUs or private cloud.

  • LoRA and QLoRA fine-tuning on your data
  • A held-out test set the model never sees in training
  • Serving with vLLM on OCI, Google Cloud or your own hardware
  • Model cards and data documentation for audits

Approach

How we build it.

  1. 01

    Train

    Fine-tune open-weight or hosted models on your data, in your account, or train a classical model where a language model is the wrong tool. Build the retrieval index with chunking, embeddings and reranking tuned on your own queries.

  2. 02

    Test

    A held-out evaluation set from real cases, scored automatically where possible and by people where judgement is needed, with a baseline and a regression run on every change.

  3. 03

    Validate

    Guardrails, constrained outputs, red-team checks, cost and latency budgets, and a human sign-off before anything reaches users. Agents get approval gates wherever an action is expensive.

  4. 04

    Deploy

    Serving on Google Cloud, OCI GPU compute or your own hardware with vLLM, behind your authentication, with a trace for every model call, monitoring and a rollback path.

Testing

How we test it.

The evaluation set is written before the first prompt and runs on every change after it.

Real cases, written down
Questions, documents and tasks from your team, with the answer or outcome you expect, including the requests it must refuse.
Retrieval and answers scored separately
For RAG, we check that the right passages came back and, separately, that the answer is correct and supported by its citations.
The result and the path
For agents, we score the outcome and the tool calls that led to it, including calls that should never happen.
Scored on every change
Every change to a prompt, model or data source runs the full set and is compared with the last release. Scoring is automatic where possible, with people where judgement is needed.
Checked before launch
Red-team checks, cost and latency budgets, and a sign-off from your side before anything reaches users.

Deliverables

What you get.

  • Model selection and benchmarking on your own test set
  • Fine-tuning (LoRA, QLoRA) on your data, in your account
  • RAG pipelines: chunking, embeddings, reranking and citations
  • Agent runtimes with tool use, memory and approval gates
  • Evaluation harness with regression tests and a quality dashboard
  • Guardrails, red-team report and human sign-off before launch
  • Inference serving with tracing, monitoring, cost limits and rollback
  • Model cards and data documentation for audits

Stack

What we build it with.

Chosen per project, benchmarked where it matters, and all of it something your team can run after us.

  • Python
  • PyTorch
  • Hugging Face Transformers
  • PEFT (LoRA, QLoRA)
  • vLLM
  • LangGraph
  • Gemini Enterprise Agent Platform
  • OCI GPU compute
  • Qdrant
  • Vector Search
  • Langfuse
  • OpenTelemetry
  • Ragas
  • promptfoo
Why we use each one

Typical builds

What this looks like in practice.

  • Contract and policy RAG

    Answers over a large document library, every claim linked to the clause it came from.

  • Ticket triage agent

    Reads the ticket, gathers account context, drafts the reply and routes it for approval.

  • House-style model

    A fine-tuned model that writes in your tone and output format, at a fraction of the prompt cost.

  • Classifier for a review queue

    A domain model that clears the routine cases and sends the hard ones to a person.

  • Private deployment

    Open-weight models served inside your network when data cannot leave it.

  • Forecasting

    Demand, revenue or capacity forecasts from your history, with the same test discipline.

Data

Where your data goes.

Written into every proposal, and the same for every AI product we build.

Where it lives
In your Google Cloud or Oracle OCI tenancy and your GitHub organisation. We do not copy production data to our own machines or accounts.
What trains on it
Nothing. Fine-tuning happens only when you ask for it, on your data, in your account.
Who can see it
Named engineers with least-privilege access that you grant and can revoke. Secrets live in a managed vault, never in a repository.
Which model providers see it
Only the ones you approve in the proposal, under their API data terms. Where that is not acceptable, we serve open-weight models inside your network.
Before we see anything
An NDA, yours or ours.
When we leave
Access is revoked and you keep everything: code, infrastructure code, prompts, evaluation sets and weights.

Cost

What drives the cost.

Every proposal states the price before work begins. These are the things that move it.

Systems it touches
Each system the product reads from or writes to adds integration, permissions and tests.
Drafting or acting
A product that drafts for a person costs less to make safe than one that acts on its own.
The state of your data
Clean, text-based documents are quick to index. Scans, spreadsheets and many sources take longer.
The cost of a wrong answer
The more a mistake costs, the larger the evaluation set and the more approval steps it needs.
Where the model runs
A hosted model in your cloud account is quicker to set up than private GPUs in your network.
Running costs
Model usage, hosting and monitoring are billed monthly. We estimate the cost per request in design and watch it in production.

Fixed price for a fixed scope, or two-week sprints while the scope is still being discovered.

How a project runs

Process

Discover, then Design, then Build, then Launch and hand over. A working build every week, on a staging environment in your cloud.

How a project runs

Terms

Code in your GitHub, infrastructure in your cloud, nothing trained on your data, and everything yours when we leave.

Read the terms

FAQ

Agents, RAG and LLMs: questions

Last reviewed

How much does it cost to build an AI agent?

The price moves with six things: how many systems the agent touches, whether it acts or only drafts, the state of the data it reads, how many cases the evaluation set needs, the security and approval steps, and where the model runs. A drafting agent with one integration is a small project. An agent that updates records across several systems behind approval gates is a larger one. Running costs are separate: model usage, hosting and monitoring. Every proposal states the build price before work begins.

Do we need an agent, or would a workflow do?

Often a workflow is enough. If the steps are the same every time, a fixed workflow with a model at one or two points is cheaper to run and easier to test. We build an agent when the path changes from case to case and the model has to choose the next tool. We will tell you which one the job needs before we quote.

Could n8n, Zapier or another no-code tool do this instead?

Sometimes, and then you should use one. No-code tools are quick for linking apps and suit simple, low-risk flows. A custom build pays off when the agent needs your permission model, an evaluation set, audit logs, approval steps or private deployment, or when it becomes part of a product you sell.

How do you stop an agent taking an action it should not?

It can only call the tools we give it, and each tool has the narrowest access that does the job. Anything expensive or irreversible, such as sending an email, issuing a refund or changing a record, waits for a person to approve it. Every call is logged and traced. Content from documents and the web is treated as untrusted, and prompt-injection attempts are part of the red-team checks before launch.

Why do so many AI agent pilots stall before production?

Usually not because of the model. Nobody wrote down what a correct result is, the pilot ran on clean sample data, integrations and permissions were left for later, or the running cost was never modelled. We start with an evaluation set from real cases, connect to the real systems early and set a cost per request in the design.

What does train, test, validate and deploy involve?

Train: fine-tune or build the retrieval index on your data, in your account. Test: run a held-out evaluation set from real cases, with a baseline and a regression run on every change. Validate: guardrails, red-team checks, cost and latency budgets and a human sign-off. Deploy: serve it on your cloud or hardware with tracing, monitoring, cost limits and a rollback path.

Should we use RAG or fine-tuning?

RAG when the model needs facts that change or must be cited. Fine-tuning when it needs a consistent style, format or behaviour that prompting cannot hold at volume. Many products use both. We measure the gap on your test set before recommending either.

How do you measure whether a RAG system is accurate?

We score retrieval and answers separately. For retrieval, we check that the right passages came back for each question in the evaluation set. For the answer, we check that it is correct, that every claim is supported by a cited source, and that it says so when the sources do not contain the answer. Automatic scores run on every change, and people review a sample where judgement matters.

Can a RAG system respect who is allowed to see what?

Yes. Permissions are applied at retrieval time, using the same roles as the source system, so a user is only shown passages they could already open.

Will OpenAI, Anthropic or Google train on our data?

Not by default. OpenAI, Anthropic and Google Cloud each state that business and API data is not used to train their models unless you opt in or give permission. We use only the providers you approve in the proposal, under their API data terms, and serve an open-weight model in your network when no outside provider is acceptable.

Where do the models run?

Wherever your data policy allows: hosted models on Google Cloud or OCI for most products, or open-weight models served inside your network with vLLM when data cannot leave it. Both get the same evaluation and monitoring.

Do we need our own GPUs?

Usually not. Hosted models cover most products. We set up GPU compute when you need private inference, high volume or a custom model.

Which agent framework do you use?

It depends on the job. We use LangGraph for long-running agents that need checkpoints and human approval, a provider's own SDK when a product is built around one model family, plain code when a workflow is enough, and the Model Context Protocol to give agents audited access to your systems. The evaluation set, not the framework, decides what ships.

What is agentic AI?

Agentic AI describes systems in which a language model plans the steps of a task and calls tools to carry them out, rather than returning a single answer. It ranges from one agent with three tools to several agents passing work between them. The more autonomy a system has, the more testing and approval it needs.

Further reading

  • Released v1
  • Open weights
  • Apache 2.0
  • Runs on a CPU

Speech-to-text model

AksharSTT

Hindi, English and Hinglish speech to text that runs offline on a CPU.

model file
29.5 MB
real time on a CPU
96×
mean word error rate
22.28%

From our AI Lab

We train and publish our own models, with the weights, the training records and every score in public. It is the same method we use on client models.

Visit the AI Lab

Taking on new projects

Planning work on Agents, RAG and LLMs? Let's talk.

A short call, a written brief, and a straight answer on scope, price and timeline before any work starts. NDA first if you need one.