What happens on the scope call?

Thirty minutes on video. You describe the function you want off a desk; we map the systems it touches and the decision it would have to make alone. You leave with a yes, a no, or a narrower version that is worth doing. If an agent is the wrong answer you hear it on the call.

Do you publish prices?

Not as a list, because every system is priced against its own blueprint. The price is fixed, in writing, before any build work starts, and the blueprint itself is priced on its own so the build price is never a surprise.

Why are there no testimonials or client logos?

We publish operating parameters and systems we actually run, not results we cannot show the log for. The work page lists what runs for us today; Mira is a live system you can watch. We think that is a better test than a quote.

Who owns the system at the end?

You do. It is built in your accounts, on your keys, under version control you hold. Handover includes the repository, the deployment and a runbook written on the assumption that we are gone.

What do you need access to?

As little as the blueprint names, and read-only first. Credentials are issued by you, scoped to the system, and revoked by you at the end. We never hold the only copy of anything.

What do you refuse to build?

Volume plays that get accounts or domains banned, agents that have never run live, black boxes you could not take over, and anything whose safety depends on a prompt instead of a limit in code.

Darko AI works remotely with clients in any time zone; the calendar shows the slots we hold open.

Process and ways of working

From one call to a system that runs on its own.

Four stages, each with a written output you keep whether or not the next stage happens. The price is fixed against the blueprint before anything is built, and the blueprint is priced on its own so the build price is never a surprise.

30 minutes

Scope

One call. We map the function you want an agent to own, the systems it has to touch, and the decision it is allowed to make on its own. If an agent is the wrong answer we say so on that call.

You get

A yes, a no, or a narrower version worth doing
The function named, the systems it touches, the decision it would own
A written note of the call within a day

We need

The job you want off a desk, in plain words
Who owns it today and what it costs when it goes wrong
Thirty minutes, camera on

3–5 days

Blueprint

A written architecture: the action loop, the data it reads and writes, the model chain with its measured fallbacks, the limits, and the failure behaviour. Fixed price attached before a line is written.

You get

The action loop and the data it reads and writes
The model chain with measured fallbacks and budgets
Limits, failure behaviour, kill switch, and a fixed build price

We need

Read-only access to the systems the blueprint touches
Sample inputs: real ones, not idealised ones
One decision-maker who can sign the blueprint

2–4 weeks

Build

Built against the real APIs from day one. No mock data, no staging fiction. You get access to the run logs while it is being built, not after.

You get

Built in your accounts, on your keys, under version control you hold
Run logs open to you from the first day
A supervised production run with its log as the acceptance test

We need

Scoped credentials, issued by you, revocable by you
A weekly 20-minute check-in
Answers within a working day when a real input surprises us

Ongoing or handover

Run

It goes live under supervision, then under monitoring. Managed operation, or a full handover with the runbook and the repo. Your call.

You get

Monitoring with a written note for every stop, or a full handover
The repository, the deployment and a runbook written as if we were gone
Model re-benchmarks when a provider changes under the system

We need

A named owner on your side
The kill switch in your hands
Honesty about what the system is for, so the gates stay right

Engagement shapes

Four ways to work with us. No price list, on purpose.

Every system is priced against its own blueprint, fixed and in writing, before build work starts. Publishing a menu would mean pricing a system we have not scoped, and that is how surprises happen.

E13 to 5 days

Blueprint

A written architecture for one system, priced on its own. Take it to us or to anyone else.

The action loop, the data it reads and writes, the decisions it may take alone
The model chain with its measured fallbacks and token budgets
Limits, failure behaviour and the kill switch, specified
A fixed build price attached, in writing

Fit: You know the function you want off a desk and want the risk priced before anything is built.

E22 to 4 weeks

Build

The blueprint, built against the real APIs, run live under supervision, and handed over.

Built on your accounts and your keys, under version control you hold
Run logs open to you while it is being built, not after
A supervised production run with its log as the acceptance test
A runbook written on the assumption that we are gone

Fit: You have a blueprint, or want one folded in, and want the system live in weeks.

E3Monthly

Run

We keep the system live: monitoring, model re-benchmarks, gate tuning, incident reports.

Daily monitoring with a written incident note for every stop
Model chain re-benchmarked whenever a provider changes under it
Gate thresholds tuned against the run journal, in writing
Monthly readout: units produced, units blocked, cost per unit

Fit: You want the outcome, not the operations. Month to month, and the system stays yours whenever you stop.

E42 weeks

Audit

A fixed-scope review of a stack you already run, independent of any build.

Measured model table on your real prompts, three repeats minimum
Every gate classified: fails closed, fails open, never fires
Spend, compute and access reviewed with monthly figures attached
A ranked defect list your own team can act on

Fit: Something runs already and you want to know what it is actually doing before you scale it.

Before you sign anything

The questions buyers ask first.

What happens on the scope call?: Thirty minutes on video. You describe the function you want off a desk; we map the systems it touches and the decision it would have to make alone. You leave with a yes, a no, or a narrower version that is worth doing. If an agent is the wrong answer you hear it on the call.
Do you publish prices?: Not as a list, because every system is priced against its own blueprint. The price is fixed, in writing, before any build work starts, and the blueprint itself is priced on its own so the build price is never a surprise.
Why are there no testimonials or client logos?: We publish operating parameters and systems we actually run, not results we cannot show the log for. The work page lists what runs for us today; Mira is a live system you can watch. We think that is a better test than a quote.
Who owns the system at the end?: You do. It is built in your accounts, on your keys, under version control you hold. Handover includes the repository, the deployment and a runbook written on the assumption that we are gone.
What do you need access to?: As little as the blueprint names, and read-only first. Credentials are issued by you, scoped to the system, and revoked by you at the end. We never hold the only copy of anything.
What do you refuse to build?: Volume plays that get accounts or domains banned, agents that have never run live, black boxes you could not take over, and anything whose safety depends on a prompt instead of a limit in code.
Where are you based?: Darko AI works remotely with clients in any time zone; the calendar shows the slots we hold open.

Start with the call.

Thirty minutes. If an agent is the wrong answer, you hear it on the call and it costs you nothing.

Pick a time Other ways to reach us