Skip to content
ALGOLOGIX

Technology

What we use, and what we reach for first

The full inventory, grouped the way we actually choose. Below it, the handful of decisions we make the same way on most projects — and the conditions under which we do not.

167 tools across 14 layers

The stack

Fourteen layers, and an opinion about each

This is everything we work with, not everything that exists. The line under each group is the part worth reading — a list of tools says nothing about how a team picks between them.

Languages

Python where the models and the data live, TypeScript everywhere a person touches it. A third language needs a reason beyond preference.

7 tools

  • Python
  • TypeScript
  • Go
  • SQL
  • Rust
  • Swift
  • Kotlin

AI models & providers

Model choice is a per-task decision made against an eval set, not a company-wide allegiance. We build behind an abstraction so swapping one is a config change.

11 tools

  • Anthropic Claude
  • OpenAI GPT
  • Google Gemini
  • Meta Llama
  • Mistral
  • xAI Grok
  • DeepSeek
  • Qwen
  • vLLM
  • Ollama
  • Text Generation Inference

Model platforms

We host where your data already is. If a provider's API is enough, that beats standing up inference you then have to operate.

8 tools

  • AWS Bedrock
  • Amazon SageMaker
  • Google Vertex AI
  • Azure AI Foundry
  • Together
  • Fireworks
  • Groq
  • Replicate

Agent & LLM frameworks

A framework has to earn its abstraction. Most agent loops are a while loop and a tool registry; we reach for a graph runtime when the control flow is genuinely a graph.

12 tools

  • LangChain
  • LangGraph
  • LlamaIndex
  • Model Context Protocol
  • Anthropic Agent SDK
  • OpenAI Agents SDK
  • Vercel AI SDK
  • Pydantic AI
  • CrewAI
  • AutoGen
  • DSPy
  • Temporal

Retrieval & vector

We reach for pgvector before a dedicated vector database, because one fewer system to operate is usually worth more than the last 10% of recall.

12 tools

  • pgvector
  • Pinecone
  • Qdrant
  • Weaviate
  • Milvus
  • Chroma
  • Elasticsearch / OpenSearch
  • Redis Vector
  • Embeddings — OpenAI, Voyage, Cohere, BGE, E5
  • Rerankers — Cohere Rerank, BGE-reranker
  • Hybrid BM25 + dense
  • GraphRAG

Speech & voice

Turn-taking latency is the product. We pick the stack that holds the budget end to end, then optimise the hop that is actually slow.

12 tools

  • Whisper
  • Deepgram
  • AssemblyAI
  • ElevenLabs
  • Cartesia
  • PlayHT
  • OpenAI Realtime
  • LiveKit
  • Pipecat
  • Twilio
  • Daily
  • SIP / WebRTC

ML & computer vision

A gradient-boosted tree beats a neural network on tabular data more often than anyone admits. We start with the simplest model that could work.

14 tools

  • PyTorch
  • TensorFlow
  • scikit-learn
  • XGBoost
  • LightGBM
  • Hugging Face Transformers
  • PEFT / LoRA
  • Ray
  • OpenCV
  • YOLO
  • Detectron2
  • Segment Anything
  • ONNX Runtime
  • TensorRT

Backend & APIs

Boring, typed and observable. FastAPI when the work is Python-adjacent, Node when the team is, Go when the hot path justifies it.

16 tools

  • FastAPI
  • Django
  • Node.js
  • NestJS
  • Express
  • Hono
  • Go — Fiber, Chi
  • GraphQL — Strawberry, Apollo
  • gRPC
  • WebSockets
  • Server-Sent Events
  • Celery
  • BullMQ
  • Kafka
  • RabbitMQ
  • Redis Streams

Frontend & mobile

Server-rendered by default, client state only where the interaction needs it. Native only when the product genuinely needs the device.

11 tools

  • Next.js
  • React
  • Tailwind CSS
  • Vite
  • Motion
  • TanStack Query
  • Zustand
  • React Native
  • Expo
  • Flutter
  • SwiftUI

Databases

Postgres until it stops being the answer. Most schemas that were moved to a document store were really asking for a better index.

13 tools

  • PostgreSQL
  • MySQL
  • MongoDB
  • Redis
  • DynamoDB
  • ClickHouse
  • Cassandra
  • Supabase
  • Neon
  • PlanetScale
  • Prisma
  • Drizzle
  • SQLAlchemy

Data platform

The pipeline is what makes the AI worth having. We build it as software — versioned, tested and deployable — rather than as scheduled notebooks.

13 tools

  • Airflow
  • Dagster
  • dbt
  • Spark
  • Flink
  • Snowflake
  • BigQuery
  • Databricks
  • Redshift
  • Fivetran
  • Airbyte
  • Kafka Connect
  • Iceberg

Cloud, DevOps & platform

Your accounts, your Terraform, your bill. Managed services where they save operational time, and containers where portability matters more.

17 tools

  • AWS
  • Google Cloud
  • Azure
  • Vercel
  • Cloudflare
  • Docker
  • Kubernetes
  • Terraform
  • Pulumi
  • GitHub Actions
  • ArgoCD
  • AWS Lambda
  • Cloud Run
  • Fargate
  • ECS
  • API Gateway
  • CDN & edge

Observability & evaluation

Traces and evals from the first sprint. You cannot improve a model's behaviour you cannot see, and you cannot ship a change you cannot score.

12 tools

  • LangSmith
  • Langfuse
  • Braintrust
  • Ragas
  • DeepEval
  • Weights & Biases
  • MLflow
  • OpenTelemetry
  • Datadog
  • Grafana
  • Prometheus
  • Sentry

Security & identity

Least privilege, short-lived credentials, and PII that never reaches a provider that has not signed for it.

9 tools

  • OAuth 2.0 / OIDC
  • Auth0
  • Clerk
  • HashiCorp Vault
  • AWS KMS
  • PII detection & redaction
  • Llama Guard
  • NeMo Guardrails
  • Snyk / Dependabot

Engineering standards

What we commit to on every build

Not adjectives. Six things we do on every engagement, each one specific enough that you can hold us to it in a review.

  • Evals before demos

    Every AI feature ships with a test set, a scoring method and a regression gate.

  • Latency and cost are requirements

    We set a p95 and a cost-per-run target in Discover, and hold the build to it.

  • Observable by default

    Tracing, structured logs and dashboards from the first sprint, not bolted on after an incident.

  • You own everything

    Your repo, your cloud accounts, your model weights, your prompts. No lock-in, no rented black box.

  • Security is not a phase

    Secrets management, least privilege, dependency scanning, PII handling and provider DPAs from day one.

  • Documented handover

    Architecture docs, runbooks and a walkthrough. Your team can run it without us — that's the point.

Our defaults

Decisions we make the same way, and why

A default is only useful if you also know when to abandon it. Each of these carries the condition that would make it the wrong call.

  • Why we reach for FastAPI

    FastAPI, with Pydantic models as the contract — instead of Django, Flask, or a Node service in front of Python workers.

    AI work is Python work — the model clients, the eval harnesses, the data tooling all live there — and a service in a second language means a serialisation boundary through which the interesting types do not survive. FastAPI's request and response models are the same Pydantic classes the pipeline already uses, so the API schema and the OpenAPI document are generated from the code rather than maintained beside it.

    When it is wrong

    When the product is mostly CRUD with an admin interface, Django's batteries save more weeks than the type continuity does. And when the hot path is a proxy that mostly waits on the network, Go is a smaller thing to operate.

  • Why pgvector before Pinecone

    pgvector in the Postgres you already have — instead of A dedicated vector database.

    One fewer system to operate is usually worth more than the last 10% of recall. The documents, their metadata, the permissions on them and their embeddings stay in one database, so a filtered search is a WHERE clause rather than a two-phase query against two stores that can disagree. Backups, migrations, access control and on-call all stay in a system your team already runs.

    When it is wrong

    Past roughly ten million vectors with a latency budget under 50ms, or when the workload needs sharded multi-tenancy, the dedicated store starts earning its operational cost. That is a measurement, not a guess — we run it against your data before moving.

  • When we don't use an agent

    A deterministic pipeline with one model call at the step that needs judgement

    Most problems described as agentic are a fixed sequence with one ambiguous decision in the middle. A loop that plans its own steps makes that pipeline non-deterministic everywhere, which turns a testable system into one you can only evaluate statistically — and makes every failure a transcript to read rather than a stack trace. If you can draw the flowchart, build the flowchart.

    When it is wrong

    When the sequence genuinely depends on what the last step found — research, triage across systems, anything where the tool set is large and the path is data-dependent — an agent is the right shape, and then it needs a trace, a step budget and an eval set from the first day.

  • Why evaluation comes before the demo

    A scored eval set written during design, gating every release — instead of Manual spot-checks and a stakeholder's judgement at review.

    Without a bar agreed in advance, 'is it good enough' is settled by whoever is most confident in the room, and every prompt change becomes a debate with no evidence. A set of real inputs with expected behaviour turns that into a number that moves. It is also the only way to change a model or a prompt six months later without re-testing by hand.

    When it is wrong

    For a two-week feasibility spike the eval set is three cases and a spreadsheet — proportionate, but never zero. The thing we do not do is defer it until after launch, which is when it is most expensive to write and least likely to happen.

  • Why the work lives in your accounts

    Your GitHub organisation, your cloud accounts, your provider keys, from day one — instead of Building in our environment and migrating at handover.

    A migration at the end is where estimates go wrong, and it is also where a dependency on the agency quietly becomes permanent. Building in your accounts means the IAM, the network boundaries and the quota limits are the real ones from the first deploy, so the constraints show up in week one rather than week eleven. You own the IP, the repository and the infrastructure definitions throughout.

    When it is wrong

    A throwaway Discover spike may run in our sandbox to avoid waiting on access provisioning. It is deleted, and nothing built there is carried forward into the build.

This site

Our own numbers

The claims on this page are testable on the page making them. These are this site's measurements, regenerated from the build rather than typed in.

100

Performance

100

Accessibility

100

Best practices

100

SEO

172.9 KB

First-load JS

19.4 KB

CSS

0.7s

LCP

0.00

CLS

Measured on 4 September 2026 against / at commit 0fcdd3c. Desktop preset, simulated throttling, Chrome 152, median of 3 runs.

Lighthouse scores depend on the machine that ran them, so the conditions are recorded beside them. The byte figures are re-measured on every build and fail it if they disagree with the page.

Bring us the hard part

The integration nobody wants to own, the model that works in a notebook and not in production, the pipeline that breaks quietly.

contact@algologix.coWe reply within one working day.