The catalog

Pick the box that matches your problem.

Most clients start with one package and add a second once it’s running. Every box below opens to a full scope: what you get, the three package sizes, add-ons, and what is deliberately not included.

01Best first step

AI opportunity audit

One week inside your workflows. You get a ranked list of what AI should touch, what it shouldn’t, and a build plan with effort estimates you can run with us or anyone else.

  • Every candidate workflow mapped, with volume and cost-per-run
  • Each one scored on value, risk and feasibility
  • A sequenced build plan you own outright
Delivery
5 working days
Iterations
1 round
Ends with
90-min readout
InvestmentScoped on the call

What you get

  • A workflow map of the area you pick — steps, systems, handoffs, and where time actually goes
  • A scored shortlist: value, data readiness, risk, and engineering effort for each candidate
  • Honest “don’t automate this” calls, with the reason written down
  • A sequenced build plan with effort estimates per item
  • A 90-minute recorded readout with your team, plus the written report

Package sizes

Single workflow

One process, one team. “Should we automate ticket triage?”

  • Up to 3 interviews
  • One workflow mapped end to end
  • Build plan for that workflow
3 days delivery1 iteration roundWritten report
TeamMost chosen

A whole function — support, ops, finance, research.

  • Up to 8 interviews across the team
  • All candidate workflows mapped and scored
  • Sequenced 90-day build plan
  • Recorded readout with Q&A
5 days delivery1 iteration roundReport + readout
Org-wide

Several departments, or a board that needs a defensible position.

  • Cross-department interviews
  • Data and platform readiness review
  • Spend model and build-vs-buy calls
  • Exec-ready deck and 12-month roadmap
10 days delivery2 iteration roundsDeck + roadmap

Add-ons

Working prototype of the top pickVendor / model cost comparisonTeam enablement sessionSecurity & compliance review

Not included

  • Implementation — the audit is deliberately separate, so the recommendation stays honest
  • Access to production systems; read-only samples and interviews are enough

Built with

Process mappingCost modellingFeasibility spikes
02Fastest start

Live working session

Screen shared, your codebase open, one senior engineer who has shipped this before. Leave with the fix, the architecture, or the decision — and a written summary you can forward.

  • Booked inside 48 hours, evenings and weekends included
  • Recording plus a written summary within one working day
  • No sales pitch — if we’re not the right build partner, we’ll say so
Delivery
Within 48h
Length
60 or 90 min
After
Written summary
InvestmentScoped on the call

What you get

  • A working session on whatever is actually blocking you — prompt behaviour, retrieval quality, agent architecture, cost, a bad eval, a flaky tool call
  • Concrete changes made live where possible, not homework
  • A recording and a written summary: what we found, what we changed, what to do next
  • Follow-up questions by email for 7 days

Package sizes

60 minutes

One question, one decision, one bug.

  • Single focused topic
  • Recording + summary
48h to book7 days email follow-up
90 minutesMost chosen

A codebase walkthrough plus a plan you can execute.

  • Deep review of your repo or agent
  • Prioritised fix list, written down
  • Recording + summary
48h to book7 days email follow-up
Team workshop

Bring the engineers who’ll maintain it.

  • Half day with up to 8 people
  • Live build of one small piece
  • Patterns doc your team keeps
1 week to bookHalf dayPatterns doc

Add-ons

Pre-session repo reviewNDA before we startRecurring weekly slot

Not included

  • Production changes on your infrastructure during the call
  • Ongoing implementation — that becomes a package or a retainer
03Most requested

An agent inside the product you already have

Your users ask in plain English. The agent calls your real APIs, streams its reasoning, and shows exactly what it did — inside your app, under your auth, in your design system.

  • Runs on your existing endpoints — no data migration
  • Every action traced, permissioned and reversible
  • Ships behind a flag to a pilot cohort first
Delivery
2–4 weeks
Iterations
2 rounds
Support
30 days
InvestmentScoped on the call

What you get

  • A tool layer over your existing API — typed, validated, permission-aware, one tool per real capability
  • The agent loop itself: planning, tool calls, streaming output, graceful failure when it doesn’t know
  • Front-end components in your design system — streamed answers, citations, an action log the user can read
  • Auth and tenancy respected: the agent can never see what the signed-in user can’t
  • An eval set built from your real questions, so changes get measured instead of guessed at
  • Deployment behind a feature flag, plus a runbook for your team

Package sizes

Pilot

Prove it works on one surface before you commit the roadmap.

  • Up to 5 tools
  • One screen or panel
  • Internal users only
2 weeks1 iteration round14 days support
ProductionMost chosen

Real customers, real traffic, real observability.

  • Up to 15 tools
  • Streaming UI in your design system
  • Eval suite + tracing + cost dashboard
  • Flagged rollout and runbook
3–4 weeks2 iteration rounds30 days support
Scale

Multi-agent, multi-tenant, or an enterprise security review ahead.

  • Unlimited tools, sub-agents, background jobs
  • Policy engine and audit trail
  • Load and cost tuning
  • Team handover sessions
6–8 weeks3 iteration rounds60 days support

Add-ons

MCP server for your APIVoice inputMobile surfaceSSO / enterprise authPrompt-injection review

Not included

  • Rebuilding the API the agent sits on — if endpoints are missing, that’s scoped separately
  • Model provider fees; you keep your own account and keep control of spend

Built with

Claude Agent SDKVercel AI SDKLangGraphMCPSSE streamingTypeScript · Python
04High volume

Support agent that answers from your own docs

Grounded in your documentation, help centre and past tickets. Cites its sources, refuses to guess, and hands to a human the moment confidence drops — with the whole conversation attached.

  • Every answer carries a link to the source it came from
  • Escalation rules you set, not ones the model invents
  • Weekly report of what it couldn’t answer — your content backlog
Delivery
2–3 weeks
Iterations
2 rounds
Support
30 days
InvestmentScoped on the call

What you get

  • Ingestion of your help centre, docs, PDFs and resolved tickets, with a refresh job that keeps it current
  • Retrieval tuned on your real questions — not a default vector search that returns plausible nonsense
  • Citations on every answer, and an explicit “I don’t know, here’s a human” path
  • Handoff into the desk you already use, with full conversation context attached
  • An answer-quality dashboard: deflection rate, escalations, and the questions it keeps failing
  • Embeddable widget or integration into your existing chat surface

Package sizes

Pilot

One knowledge source, internal team first.

  • One doc source
  • Internal Slack or web widget
  • Baseline quality report
1–2 weeks1 iteration round14 days support
ProductionMost chosen

Customer-facing, with escalation into your helpdesk.

  • Up to 4 knowledge sources
  • Helpdesk handoff + context
  • Citations, refusal rules, tone tuned to your brand
  • Quality dashboard
2–3 weeks2 iteration rounds30 days support
Scale

Multilingual, multi-product, or it needs to take actions.

  • Unlimited sources + auto refresh
  • Account-aware actions (refunds, plan changes) with approvals
  • Multilingual answers
  • Content-gap reporting to your writers
4–6 weeks3 iteration rounds60 days support

Add-ons

WhatsApp channelVoice lineZendesk / Intercom / FreshdeskCSAT feedback loop

Not included

  • Writing your documentation — we’ll tell you exactly which gaps hurt most
  • Helpdesk licences and model usage, billed to your own accounts

Built with

Bedrock Knowledge BasespgvectorPineconeClaudeAzure OpenAI
05Growing fast

Voice agent for calls you keep missing

Answers the phone, books the appointment, qualifies the lead, and writes it all back into your CRM. Escalates to a person on anything it wasn’t built to handle.

  • Answers in under two rings, 24 hours a day
  • Every call transcribed, summarised and logged to your CRM
  • Hard limits on what it may promise a caller
Delivery
2–3 weeks
Iterations
2 rounds
Support
30 days
InvestmentScoped on the call

What you get

  • A phone number (or your existing one, forwarded) answered by an agent trained on your business
  • Call flows for the jobs you actually get called about: booking, rescheduling, qualifying, triage, out-of-hours cover
  • Calendar and CRM writes — the call ends and the record already exists
  • Transcripts, recordings and summaries, searchable after the fact
  • Guardrails on pricing, promises and anything legally sensitive, plus instant human transfer

Package sizes

Pilot

Out-of-hours cover, or one repetitive call type.

  • One call flow
  • Voicemail-style capture + summary email
  • Transfer to a human on request
1–2 weeks1 iteration round14 days support
ProductionMost chosen

Inbound calls handled end to end, all day.

  • Up to 4 call flows
  • Calendar booking + CRM writes
  • Transcripts, summaries, escalation rules
  • Tone and script tuned over a week of real calls
2–3 weeks2 iteration rounds30 days support
Scale

Outbound campaigns, multiple locations or languages.

  • Outbound and inbound
  • Multi-location routing
  • Multilingual voices
  • Call analytics dashboard
4–6 weeks3 iteration rounds60 days support

Add-ons

WhatsApp follow-upSMS confirmationsPayment captureCustom voice

Not included

  • Telephony and speech provider fees — billed to your own account, typically per minute
  • Call-recording consent policy; we implement what your legal team specifies

Built with

Realtime speech APIsTwilioClaudeCalendar & CRM APIs
06Most requested

Back-office automation with a human in the loop

The repetitive half of the job runs itself; the judgement stays with your team. Built as real software with retries, audit logs and alerts — not a no-code flow that dies silently on a Tuesday.

  • Approvals land in Slack or email, one click to accept or correct
  • Every run logged: input, decision, output, who approved it
  • Failures alert a human instead of vanishing
Delivery
2–3 weeks
Iterations
2 rounds
Support
30 days
InvestmentScoped on the call

What you get

  • One workflow taken end to end: trigger, extraction, decision, action, confirmation
  • Human-in-the-loop approvals wherever a mistake would be expensive — with the reasoning shown
  • Integrations with the tools you already run: email, Slack, CRM, accounting, spreadsheets, internal APIs
  • Idempotency, retries and dead-letter handling, so a flaky API doesn’t corrupt your data
  • An operations dashboard: throughput, approval rate, time saved, failures
  • Runbook and handover so your team can change the rules without calling us

Package sizes

One workflow

The single process that eats the most hours.

  • One trigger, up to 3 systems
  • Slack or email approvals
  • Run log
1–2 weeks1 iteration round14 days support
DepartmentMost chosen

Three connected workflows and the dashboard over them.

  • Up to 3 workflows, up to 6 systems
  • Approval queue with audit trail
  • Ops dashboard + alerting
  • Team runbook
2–3 weeks2 iteration rounds30 days support
Operations platform

Automation as a system your team keeps extending.

  • Unlimited workflows on shared infrastructure
  • Role-based approvals
  • Self-serve rule editing for your ops team
  • Monthly reliability review
5–8 weeks3 iteration rounds60 days support

Add-ons

Document extraction (OCR)WhatsApp approvalsn8n / Make migrationOn-call alerting

Not included

  • Replacing systems that don’t have an API — we’ll flag those before you buy
  • Changing your team’s process for them; we automate the process you decide on

Built with

Python · CeleryClaude Agent SDKGmail · Slack · WhatsApp APIsn8n where it fitsPostgres
07Deep work

Document intelligence that cites its sources

Contracts, reports, policies, research, tickets — ask a question, get an answer with the paragraph it came from. Built so a reviewer can check it in ten seconds instead of trusting it blindly.

  • Page- and paragraph-level citations on every claim
  • Tables, scans and messy PDFs handled properly
  • Access rules enforced per document, not per index
Delivery
3–4 weeks
Iterations
2 rounds
Support
30 days
InvestmentScoped on the call

What you get

  • An ingestion pipeline that survives real documents: scans, tables, multi-column layouts, appendices, revisions
  • Chunking and retrieval tuned against a question set from your own domain experts
  • Answers with page-level citations, and a viewer that jumps to the source passage
  • Permission-aware retrieval — people only ever see what they’re cleared for
  • An eval set that measures answer quality and catches regressions before users do
  • Re-index jobs so new documents are searchable the day they land

Package sizes

Pilot corpus

One document set, one team, proof of quality.

  • Up to 1,000 documents
  • Search + cited answers
  • Quality baseline report
2 weeks1 iteration round14 days support
ProductionMost chosen

The whole library, in front of the people who need it.

  • Up to 100k documents
  • Permission-aware retrieval
  • Source viewer + eval suite
  • Scheduled re-indexing
3–4 weeks2 iteration rounds30 days support
Regulated

Audit trails, retention rules, reviewers who sign off.

  • Millions of documents
  • Full audit log of every query and answer
  • Reviewer workflow and sign-off
  • Knowledge graph over entities where it helps
6–10 weeks3 iteration rounds60 days support

Add-ons

OCR for scanned archivesEntity graph (Neo4j)Clause comparisonBulk summarisation

Not included

  • Legal or clinical interpretation of what the documents mean — the system surfaces sources, your experts decide
  • Digitising paper archives; we integrate with a scanning vendor if you need one

Built with

Bedrock Knowledge BasespgvectorPineconeNeo4jClaude · Azure OpenAI
08Deep work

Talk-to-your-data analytics

Plain-English questions over your warehouse, answered with a chart and the SQL underneath it. Built on a semantic layer your analysts define, so the numbers match the numbers they publish.

  • Every answer shows the query it ran — auditable, not magic
  • Metric definitions owned by your data team, not the model
  • Read-only, row-level-security aware
Delivery
3–4 weeks
Iterations
2 rounds
Support
30 days
InvestmentScoped on the call

What you get

  • A semantic layer: your metrics, dimensions and joins defined once, in version control
  • Question → SQL → chart, with the generated query visible and copyable
  • Guardrails: read-only credentials, row-level security, query cost limits, no destructive statements
  • Saved questions and scheduled digests into Slack or email
  • An eval set of your real business questions with known-correct answers

Package sizes

One domain

Revenue, or funnel, or support — one subject area.

  • Up to 15 tables modelled
  • Chat + chart answers
  • SQL shown on every answer
2 weeks1 iteration round14 days support
ProductionMost chosen

The metrics the company actually runs on.

  • Full semantic layer in version control
  • Row-level security + cost limits
  • Saved questions, scheduled digests
  • Accuracy eval suite
3–4 weeks2 iteration rounds30 days support
Embedded

Ship it to your own customers inside your product.

  • Multi-tenant isolation
  • White-labelled UI in your design system
  • Usage metering and per-tenant limits
  • Load and cost tuning
6–8 weeks3 iteration rounds60 days support

Add-ons

dbt model reviewAnomaly alertsSlack digestsForecasting

Not included

  • Fixing an unreliable warehouse — if the data is wrong, plain English won’t save it, and we’ll tell you first
  • Replacing your BI tool; this sits alongside it

Built with

ClaudePostgres · Snowflake · BigQuerydbtBedrock AgentCore
09Founder favourite

AI-native product, built end to end

The whole thing: auth, billing, dashboard, admin, infrastructure — and the AI core that makes it worth paying for. Shipped as a codebase your own engineers can pick up on day one.

  • Weekly demo on a real URL from week one
  • Conventional stack, documented, no bespoke framework
  • Your repo, your cloud, your accounts, from the first commit
Delivery
4–8 weeks
Iterations
Weekly cycles
Support
30 days
InvestmentScoped on the call

What you get

  • Product scoping: the smallest version that proves the thing, with everything else written down for later
  • Front end, API, database, background jobs, and the AI layer — one coherent codebase
  • Auth, roles, billing, admin tooling and the boring parts founders forget to budget for
  • CI/CD, environments, error tracking and logging set up from the start
  • Weekly demo on a live staging URL, and a written changelog you can forward to investors
  • Handover: architecture docs, runbook, and a walkthrough with whoever takes it over

Package sizes

Prototype

Something real to show users, investors or your board.

  • One core flow, clickable and working
  • Demo auth, seeded data
  • Deployed staging URL
2–3 weeksWeekly cycles14 days support
Launch MVPMost chosen

Real users, real payments, real support load.

  • Full product: auth, billing, admin, the AI core
  • CI/CD, monitoring, error tracking
  • Docs + handover sessions
  • 30 days of bug fixes after launch
5–8 weeksWeekly cycles30 days support
Launch + runway

Launch, then keep shipping while you hire.

  • Everything in Launch MVP
  • Three months of continued delivery
  • Hiring support for your first engineers
  • Gradual handover to your team
8 weeks + retainerWeekly cyclesOngoing support

Add-ons

Mobile appDesign systemSOC 2 groundworkData migrationAnalytics instrumentation

Not included

  • Brand and marketing design — we’ll work to your designer’s files or a clean default system
  • Ongoing feature work after handover, unless you move to a retainer

Built with

Next.js · ReactPython · FastAPI.NETPostgresAWS · AzureClaude
10Before you scale

Hardening: evals, guardrails, observability, cost

Take the AI feature you already have and make it safe to put in front of customers — measured, traced, permissioned, and cheaper per run than it is today.

  • A regression gate in CI, so quality stops depending on luck
  • Traces that show why a bad answer happened
  • Typical cost reductions come from caching and routing, not cheaper models
Delivery
2–3 weeks
Iterations
2 rounds
Support
30 days
InvestmentScoped on the call

What you get

  • An eval suite built from your real traffic and failure cases, running in CI on every change
  • Tracing across the whole agent loop: prompts, tool calls, retries, latency, cost per request
  • Guardrails: input validation, output policy, permission checks, prompt-injection defence
  • A cost model — where spend goes, and the caching, routing and context changes that reduce it
  • Alerting on quality and spend regressions, not just on uptime
  • A written report your CTO or auditor can read

Package sizes

Assessment

Find out how bad it is, with evidence.

  • Architecture and prompt review
  • Baseline eval run
  • Prioritised findings report
1 week1 iteration roundWritten report
HardeningMost chosen

Fix it, measure it, and keep it that way.

  • Eval suite wired into CI
  • Tracing + cost dashboard
  • Guardrails and injection defence
  • Cost reduction pass
2–3 weeks2 iteration rounds30 days support
Governed

Enterprise review, regulated sector, or a security questionnaire in your way.

  • Policy engine with per-role permissions
  • Full audit trail of agent actions
  • Red-team pass against your agent
  • Documentation for security review
4–6 weeks3 iteration rounds60 days support

Add-ons

Red-team exerciseModel migrationLoad testingTeam training on evals

Not included

  • Formal certification (SOC 2, HIPAA) — we produce the engineering evidence, your auditor signs it
  • Rewriting the feature from scratch; if that’s the real answer, we’ll say so in the assessment

Built with

Agent evalsOpenTelemetryCedar policiesAgentCore Runtime · GatewayPrompt caching
1172-hour start

Rescue: the AI feature that keeps breaking

It hallucinates, it times out, or last month’s bill was four figures more than it should be. Diagnosis in 72 hours with evidence, then a fix plan you can hand to anyone — including us.

  • First response same day, diagnosis inside three
  • Findings backed by traces and reproductions, not opinion
  • Works on code we didn’t write, including abandoned projects
Delivery
72h diagnosis
Then
1–2 week fix
Support
30 days
InvestmentScoped on the call

What you get

  • A reproduction of the failure, or proof that it can’t be reproduced the way it was reported
  • Root cause written plainly: retrieval, prompt, tool contract, context limits, concurrency, or spend
  • A fix plan ordered by impact, with effort estimates — yours to keep either way
  • The fix itself, if you want us to do it, with tests that stop it coming back
  • A short post-mortem your team can learn from

Package sizes

Diagnosis

You have engineers; you need the answer.

  • 72-hour turnaround
  • Root cause + fix plan
  • Handover call
72 hours1 iteration roundWritten report
Diagnose & fixMost chosen

Stop the bleeding, then make it stay fixed.

  • Diagnosis plus the top fixes implemented
  • Regression tests and monitoring
  • Post-mortem + runbook
1–2 weeks2 iteration rounds30 days support
Takeover

The people who built it are gone.

  • Full codebase audit and documentation
  • Stabilisation sprint
  • Infrastructure and access recovered
  • Ongoing maintenance option
3–4 weeks3 iteration rounds60 days support

Add-ons

Emergency same-day startCost-reduction passOn-call cover for a launch

Not included

  • Guaranteed rescue of a system built on a broken premise — the diagnosis will say so honestly and early
  • Work on systems we’re not given read access to

Built with

Tracing · OpenTelemetryEval harnessesPrompt cachingLoad profiling

Don’t see your problem? That’s what the consultancy lane is for — or run the matcher below.

Scope matcher

Describe it in your words. We’ll name the package.

Four questions, about twenty seconds. You get the package that fits, the size we’d recommend, and what the first two weeks would look like — before you talk to anyone.

How buying works

A fixed quote before anyone writes code.

We don’t quote from a form. We spend thirty minutes on the actual workflow, then send a written scope with a fixed price. If it isn’t worth building, we say that instead — it costs you nothing.

Step01

Scope call — 30 minutes

You walk us through the workflow or the product. We ask about volume, systems, who approves what, and what “working” would mean in numbers. No deck.

Free · booked within 48 hours
Step02

Written scope and fixed quote — 48 hours

Deliverables, package size, delivery window, iteration rounds, support period, assumptions, and what’s explicitly out of scope. One page, no ambiguity.

Free · yours to keep
Step03

Build in the open

Your repo, your cloud. A demo every week on a real URL, a shared channel for questions, and a changelog you can forward. No black box, no month of silence.

Weekly demos
Step04

Handover and support

Docs, runbook and a walkthrough with the people who’ll own it. Then the support window: we fix what we built, no argument about whose fault it is.

14–60 days depending on package
You own everythingCode, prompts, evals and docs, in your repo from the first commit. No licence, no lock-in.
Your accountsModel and cloud usage bills to you directly, so you can see and cap the spend.
Fixed scope, fixed priceChange the scope and we requote before doing the work — never after.
NDA on requestSigned before the scope call if you need it. Client names stay private unless you say otherwise.
Questions

The ones that come up every time.

Why aren’t there prices on the cards?
Because the same package can be a two-week build or a two-month one depending on how many systems it touches and how clean your data is. Quoting a number before we’ve seen that would be guessing, and you’d pay for the guess. The scope call is free, the written quote is fixed, and both are yours to keep even if you go elsewhere.
What counts as an “iteration round”?
One consolidated pass of changes within the agreed scope — you try it, you send a list, we work through the list. Adding a new integration, a new surface or a new use case isn’t an iteration; that’s a scope change, and we requote it before starting rather than surprising you on the invoice.
What does the support period actually cover?
Anything we built behaving differently from the written scope — bugs, regressions, breakage from a provider change. It runs 14 to 60 days depending on the package. It doesn’t cover new features, and it doesn’t expire into a support contract you have to cancel.
Can you work inside our existing codebase?
Yes — that’s the normal case. We work in your repo, on branches, through your review process, in your stack. If the codebase needs work before the AI feature can land safely, we’ll tell you that during scoping rather than discovering it in week three.
Who owns the code and the prompts?
You do — all of it, including prompts, eval sets and infrastructure config. Nothing runs on our servers, nothing requires a licence from us, and nothing stops working if you never speak to us again.
What if AI isn’t the right answer?
Then we say so on the call. A lot of “AI problems” are a missing integration, a rules engine, or a report nobody built. We’ll tell you what would actually fix it, including when that’s cheaper than anything we’d sell you.
Which time zones and languages do you work in?
Remote and worldwide, with overlap arranged around your team — we currently work with clients across the Gulf, Europe and North America. All work and documentation in English.
Next step

Tell us the workflow. We’ll tell you the fit.

Thirty minutes, no deck, no obligation. You leave knowing whether this is worth building, roughly what it takes, and which package it maps to.

Book a scope call or email xawadamir0@gmail.com