Every layer, concept to production

Take the whole stack, or only the layer you are missing. Each layer below says what you get, what we hand over and where we have already built it.

Apps and products

A product people actually use

What you get

  • Product design and interface, from first sketch to a tested release
  • Accounts, billing, search and the back end behind them
  • Plugins for the tools your teams already work in, such as Adobe Premiere Pro
  • Hosting, monitoring and releases set up so your team can ship

What we hand over

  • Web app
  • Back end and APIs
  • Editor plugins
  • Release pipeline

Built this way: Global Vision, GrantFit, Confport, Pigeonhole, Brainstead, Flow.

Agents and services

Work done end to end, signed off by a person

What you get

  • Agents that take a task from start to finish inside your tools
  • Read-only by default, with a named person approving every change
  • A log of every step, and a stop switch for every agent
  • Claude rolled out to the people who work beside them

What we hand over

  • Agent pipelines
  • Approval flows
  • Audit logs
  • Claude for teams

Built this way: ShipSteer, Global Vision, AgencyOS, Brainstead, Pigeonhole.

Claude rollout guide
MCP servers and integrations

AI that reaches the systems you already run

What you get

  • MCP servers on top of your CRM, ERP, documents and internal APIs
  • OAuth sign-in, so people act under their own permissions
  • One server that works from Claude, ChatGPT, Cursor and your own agents
  • Data pipelines and search across your documents

What we hand over

  • MCP servers
  • Data pipelines
  • OAuth
  • Retrieval

Built this way: Global Vision with 40+ OSINT tools, Flow, AgencyOS, Confport, Pigeonhole.

MCP server guide
Custom models

A model that knows your domain

What you get

  • A test set from your real work, so every model is measured the same way
  • Fine-tuning of open models such as Bielik, PLLuM, Apertus, Llama or Mistral when a general model falls short
  • Classical computer vision where it beats a neural network
  • Evaluation reports you can show an auditor

What we hand over

  • Evaluation set
  • Fine-tuned model
  • Evaluation report

Built this way: Orteris, with deterministic vision instead of a neural network.

Infrastructure and GPUs

Costs you can predict, data that stays where you say

What you get

  • A benchmark of open models on your hardware against hosted APIs, for cost, speed and data location
  • Kubernetes clusters with GPU nodes and inference serving, in your cloud, on your servers or Swiss-hosted
  • Infrastructure as code, monitoring and cost alerts
  • A runbook your team can operate

What we hand over

  • Benchmark report
  • Kubernetes cluster
  • Inference serving
  • Runbook

Benchmarked this way: Orteris, 12 ms per fix on one thread of a 2-core cloud CPU.

Three ways to start

Start as small as a call. Each step ends with something you keep, and you decide whether to take the next one.

Free

A first call

Thirty minutes with an engineer who will build it, about the idea at whatever stage it is.

  • An architecture sketch for your idea
  • A short list of what to build first
  • An honest no, if AI is not the answer
Free30 minutes, by videoBook the call
Fixed scope

Architecture check

Before anyone writes code: the use cases ranked, every layer designed, and the costs worked out.

  • Use cases ranked by value and risk
  • Architecture from GPU to interface
  • Cost model: your own GPUs against hosted APIs
From €10,0002–3 weeks, fixed price agreed up frontAsk for an architecture check
Fixed scope

A pilot

One use case built for real, on your data, with real users and success criteria agreed before we start.

  • A working slice in production
  • Evaluation against the agreed criteria
  • A plan and price for the full build
Priced after the check4–8 weeks, fixed scope and pricePlan a pilot

Four steps. One owner at the end

The same team carries the idea from a sketch to a running system, and at the end you own every layer.

  1. Concept

    Use cases ranked by value, an architecture for every layer, and a cost model that compares your own GPUs with hosted APIs.

  2. Prototype

    A working slice on real data with real users, and success criteria agreed up front.

  3. Build

    Infrastructure, models, integrations and the app, with evaluation and monitoring built in.

  4. Run

    We operate it with you or hand over code, models, runbooks and training, so you own the system.

Before you ask

How long does it take?

A first call can happen this week. An architecture check takes two to three weeks and a pilot four to eight; the full build is planned and priced at the end of the pilot.

Who owns the code and the models?

You do. Code, model weights you paid for, infrastructure as code, prompts and runbooks are handed over at the end of every engagement.

Can you work with our own engineers?

Yes. We often build alongside an in-house team and train them as we go, so the system has an owner on your side from day one.

Do you only work with Claude?

No. We are vendor-neutral and take no commission. We use Claude, ChatGPT, open models or a mix, whichever fits the problem, the budget and where the data may go.

Can we start with just one layer?

Yes. Many clients start with an MCP server for one system or a GPU benchmark, and add layers once the first one is in production.