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.