How to use Harness2, TinyFish, and Run:ai to optimize your business in 2026
In today's technology landscape, three open-source solutions are redefining what business optimization with AI means. Google's Harness2, TinyFish, and NVIDIA's Run:ai GPU platform together provide a closed loop: from prompt generation to web reading and compute resource orchestration. Integrating these tools now means achieving deeper automation, full cost visibility, and unprecedented scalability. Recent advances like the MiniMax M3.1 Flash model and the open-source release of Run:ai reinforce the relevance of this triad.
Why these three tools represent the new frontier of business optimization
Each tool solves a different bottleneck, but together they create a coherent workflow:
- Harness2
- TinyFish
- Run:ai
Using them together enables companies to automate the entire data lifecycle: from collection (TinyFish) to processing (Harness2) and deployment (Run:ai), minimizing the need for human intervention.
Harness2: the prompt testing framework that continuously improves agents
Harness2 acts as a "meta-tester" that observes an agent's performance on new data and automatically generates a more effective harness. This means your LLM models become more capable as they encounter new domains, without needing manual prompt rewrites.
Example integration
Below is a snippet showing how to connect an agent using Harness2 to a GitHub repository for continuous performance monitoring:
import harness2 as hb
import requests
# Load the benchmark repository
hb.load_repo("https://github.com/tua-azienda/benchmark-data")
# Start the improvement loop
agent = hb.Agent(model="glm-5", harness="default")
while True:
metrics = agent.evaluate()
if metrics["f1"] > 0.85:
break
agent.harness = hb.auto_refine(agent.harness, metrics)
print(f"New harness adopted: {agent.harness}")This loop ensures that the agent automatically adapts to new business data patterns, maintaining high answer quality and reducing time-to-market for new use cases.
TinyFish: read the web without hidden costs
One of the biggest problems with agents that read the web is uncertain costs. TinyFish calculates two key metrics: the retrieval cost per page and the "reading budget" for each task. You can set a spending limit, and TinyFish intelligently selects which URLs to visit. Recent updates make TinyFish especially adept at leveraging free search APIs while keeping extraction costs transparent.
Practical implementation of TinyFish in a business workflow
Suppose you want to extract up-to-date competitor pricing information. TinyFish lets you define an extraction prompt and a daily budget:
from tinyfish import Agent
agent = Agent(api_key="YOUR_API_KEY")
# Define your extraction goal
agent.set_task("Extract product name, price, and availability from https://example.com/")
agent.set_budget(max_cost=0.05) # 5 cents per run
# Perform reading, with automatic selection of most cost-effective URLs
results = agent.crawl_and_extract()
print(f"Extracted {len(results)} records at a total cost of {agent.total_cost:.4f} $")The system tracks every request, alerting you if you're about to exceed the budget. This makes large-scale data collection economically sustainable and transparent.
Run:ai: open-source GPU orchestration for intensive workloads
When deploying large models or training deep neural networks, GPUs become a bottleneck. Run:ai abstracts underlying GPUs into resource pools, allowing teams to request "X GPU-hours" instead of manually managing nodes and drivers. Since NVIDIA open-sourced Run:ai under Apache 2.0, the platform now includes the KAI Scheduler and CUDA 13.4 GPU fragmentation, making it easier to integrate into existing clusters.
Integrating Run:ai with your existing AI workflows
If you already use Kubernetes, you can add Run:ai as an operator. Here's an example deployment script that uses the built-in KAI scheduler:
api = client.BatchV1Api()
pod_spec = {
"apiVersion": "batch/v1",
"kind": "Job",
"metadata": {"name": "fine-tune-gpt"},
"spec": {
"template": {
"spec": {
"containers": [{
"name": "trainer",
"image": "nvcr.io/nvidia/pytorch:22.12",
"resources": {
"requests": {"nvidia.com/gpu": 2},
"limits": {"nvidia.com/gpu": 4}
}
}],
"restartPolicy": "Never"
}
},
"backoffLimit": 0
}
}
# Submit the job; Run:ai will schedule it on available GPU nodes
api.create_namespaced_job(namespace="default", body=pod_spec)
print("Job 'fine-tune-gpt' submitted to Run:ai for GPU orchestration")Run:ai handles GPU allocation, workload balancing, and job resumption, freeing DevOps from manual hardware management.
A complete example: from data collection to continuous optimization
Imagine a company that wants to keep a pricing model up-to-date with competitor rates. Here's how the three tools integrate into an end-to-end workflow:
- Data collection
- Data preparation
- Model training
- Testing and improvement
- Deployment
This continuous cycle reduces time-to-market from weeks to days, keeping costs under control and maximizing GPU utilization.
Practical takeaways for professionals
- Start a pilot project with Harness2to automate prompt improvement. Begin with a simple classification agent and observe how the framework generates new harnesses.
- Define clear budgets for TinyFishfrom the start. Its ability to select URLs based on costs lets you get more data for less money.
- Implement Run:ai in your existing clusterto unlock hidden GPU capacity. Start with a single training job to evaluate scheduling benefits.
- Monitor system-level metrics(cost per extraction, GPU utilization, model latency) to continuously optimize the workflow.
- Document your workflowswith sequence diagrams. Clarity in processes facilitates team adoption and future scaling.
Conclusion
In 2026, business optimization is no longer about a single tool, but about an integrated AI ecosystem. Harness2, TinyFish, and Run:ai together provide a complete loop: economical and controlled data, dynamic prompts, and scalable compute resources. Recent advances like the MiniMax M3.1 Flash model and the open-source release of Run:ai reinforce the relevance of this triad. By adopting these tools, companies can achieve faster processes, lower costs, and unprecedented scalability, staying competitive in the age of advanced AI.
Get started today: set up Harness2 for your agent, set a budget for TinyFish, and deploy your first job on Run:ai. The future of optimization is already here.