Stack / model-agnostic by design

The AI models we build on

Model-agnostic by design. The right model is the one that holds up in production at the price the workload can bear — which is rarely the one at the top of a benchmark table.

Anthropic Claude

Our default stack. Direct API, not a wrapper and not a reseller.

Opus
Deep reasoning, complex logic, architectural work — where the answer has to be right more than it has to be cheap.
Sonnet
The workhorse. Balanced cost and capability, and where most production paths land once they are tuned.
Haiku
High-volume inference at production scale, where per-call cost is the constraint that decides whether the feature ships at all.

Claude runs across our own platforms today: astrology interpretation in VedicPupil, content generation in Keywrd Scribe, and transaction classification in Arthastra’s reconciliation path — where it sits as the paid fallback tier behind a free model and a deterministic rules engine, and costs a fraction of a cent per call precisely because it is asked so rarely.

The rest of the stack

Chosen per workload, not per preference. Every one of these is in production somewhere in the portfolio.

OpenAI

GPT models where the ecosystem, tooling or multimodal fit is stronger. Some workloads are simply better served by what has already been built around a provider, and pretending otherwise costs the client months.

Sarvam AI

Indian-language models. Hindi and regional inference built for Indian users, with data staying in India. In Arthastra it is the tier-one model for exactly this reason: a translation round trip to an English-first model loses the accounting nouns that carry the meaning.

Cerebras and Groq

Inference infrastructure for sub-second response, used where latency is the product rather than a metric on a dashboard. A model that answers correctly in nine seconds has failed an interactive flow no matter how good the answer was.

How we choose

Four questions, asked in this order, on every workload.

01

Cost per useful output

Not cost per token. A cheap model that needs three attempts and a human correction is more expensive than the one that answers once. The unit that matters is the finished, accepted result.

02

Latency budget of the actual flow

Measured against what the user is doing, not against a benchmark. A batch reconciliation can wait eight seconds. A confirm modal cannot wait one.

03

Failure mode

What happens when the model is wrong. If a wrong answer posts money, the model does not get to post — it proposes, and something deterministic decides. This question eliminates more candidate designs than the other three combined.

04

Data residency and DPDP exposure

Where the inference physically happens and what the provider retains. For Indian personal data this is now a compliance question with a deadline attached, not a preference — see DPDP compliance engineering.

We don’t sell you a model. We build the system around it.

Model choice is 10% of the work

The other 90%

Swapping a model is a configuration change. Everything that makes the model dependable is engineering, and it is where the entire budget of a serious AI build actually goes.

  • Prompt architecture — structured, versioned, and testable, rather than a paragraph someone tuned once and nobody dares touch.
  • Retrieval — grounding answers in your data so the model is reasoning over facts it was given, not recalling something adjacent.
  • Output validation — every call returns structured output against a schema. Invalid output is a failed call, never an answer.
  • Fallback chains — tiered by cost and capability, with a defined safe result at the end. No model is ever a hard dependency.
  • Cost ceilings — capped context, bounded history, per-workload budgets, and learned patterns that permanently remove recurring cases from the model’s workload.
  • Evaluation harnesses — that catch drift before your users do, because a model that quietly gets worse produces no error and no alert.

Picking a model
is the easy part.

Capacity: 2–3 engagements per year

Start a conversation →

Tell us the workload, the latency budget and what a wrong answer costs. The model follows from those three answers.