Questions, answered.

You do, at onboarding. Lens doesn't arrive with opinions about your business; it learns them. When you come on board, we work with you to understand what you're watching for, what counts as urgent, and where the lines are — and we set the goals accordingly. From then on, Lens applies your judgment at machine speed, not ours. And it always shows its work: every flag traces back to the signal that triggered it, so you can see why it surfaced and correct it if it's wrong.

No, and yes. Every item Lens raises carries its reasoning — which thread, which feed, which number moved. You can inspect that logic, override it, and Lens learns from the correction. Nothing acts on its own: actions wait for approval, and everything leaves an audit trail.

Early on, you tune it. The first weeks are a calibration: you tell Lens when it over-flags and when it under-flags, and the thresholds adjust to your business. It's an assistant you train, not an oracle you obey — and because every decision is traceable, a wrong call is a five-minute fix, not a mystery.

That depends on what Lens has to watch. We run two tracks. Self-serve — for signals that are already structured and standard: digital marketing performance, campaign and social feeds, political narrative monitoring. You connect your accounts and Lens is reading within minutes. This is the genuinely-instant path. Engineer-led — for the physical and operational worlds: poultry sheds, retail floors, restaurants. Here Lens has to perceive things that don't come pre-labeled — camera feeds, sensor streams, your specific operational vocabulary — and that means our engineers work with you to select, configure, and in some cases train the models that feed Lens. It takes longer, by design, because getting it reliable is worth more than getting it fast. The depth is the moat: a competitor can't replicate a model tuned to your sheds over a weekend.

Because perception is the hard part. A marketing dashboard's data is already digital and standardized — Lens just reads it. A poultry shed produces reality: birds, heat, movement, mortality, captured by cameras and sensors that have to be interpreted before there's any "signal" to watch at all. That interpretation layer is what our engineers build with you, and it's why the result is something off-the-shelf tools can't match.

No. Lens delivers where your team already works — WhatsApp, in their own language. The leader gets one optional screen; the team changes nothing. The tools that fail are the ones that ask people to change their day, so we built Lens to ask for none of that.

Yes, and we recommend it. Most engagements begin with a scoped pilot — a defined slice of your operation, success metrics you set on day one, a fixed window. You prove it on your own terms before you scale.

Your data stays under your control — deployed in your private cloud or on your own servers, depending on the engagement. It is never used to train models for anyone else, never visible to other clients, and the data-processing agreement reaches your legal team before a single source is connected.

Never. Every demo screen runs on simulated data — invented names, synthetic numbers — and it's labeled as such. The day a vendor shows you another client's live operation is the day you learn what they'll do with yours. We don't.

Lens is white-labeled. Your customers, staff, and stakeholders see your brand; Lens does the work underneath. Raviga builds the engine; you run it under your name. The intelligence is ours; the face is yours.

Pricing fits the engagement — typically a monthly subscription scaled to the slice of your operation Lens runs, with the pilot priced so you're proving value before you commit at scale. For outcome-heavy deployments (livestock, for example), pricing can be tied to the value Lens protects rather than a flat seat count.

You define what "working" means, in writing, at the start of the pilot. If Lens misses that bar in the agreed window, you walk away — and in outcome-based engagements, you don't pay. We'd rather earn the renewal than trap you in a contract.

No. The pilot is the contract that matters. Prove it first.

Most monitor; Lens decides. It doesn't just show you a mortality number — it catches the spike against your own baseline, attaches the likely cause, and pushes it to your supervisor's WhatsApp in Telugu or Tamil before the next shed visit. Pilots are built for skeptics: a set of instrumented sheds against your own controls, the methodology signed off by your production head before anything scales, and our own flock records on the table first. Camera-based behavior detection is on our roadmap and labeled as roadmap — we sell it when it's proven, not before.

It runs on machines you own, in a room you control; we hold no remote access. The proof isn't a slide — we run a live demo against a past surge you choose and show whether we'd have caught it before your team did. References are arranged through channels you already trust, not a list we hand you. And the demo screens are explicitly simulated, because nothing from a real war room ever leaves it.

Footfall, the floor, sales, and the reviews and mentions landing in real time — synthesized into the few things that need a manager's attention now, not at the end-of-day report. It's the floor sense of an owner who can't be everywhere, running while you're closed.

Dashboards wait for you to look. Lens tells you, unprompted: the campaign bleeding spend, the creative dragging the stack, the channel quietly carrying the quarter — with the recommended move attached. You don't query it; it briefs you.

Both, depending on the world. For structured, digital signals it genuinely is minutes-to-live. For physical operations, "simple" means simple for you — your team does nothing new — while our engineers do the hard configuration behind the scenes. We won't pretend a shed instruments itself; we will make sure the complexity lands on us, not on you.

The engine is general; the configuration is specific. The same way an EA can run a hospital or a farm because the skill — watch, judge, act — transfers, while the knowledge is learned on the job. For physical operations, that learning is exactly what our engineer-led onboarding installs. Breadth in the engine, depth in the deployment.