Services

Your users won’t start from a blank canvas

Our engineers build the launch agents that ship inside your product — so your users have something to clone on day one.

Book a scoping call Jump to how we work

Fixed scope · Fixed price · You own everything we build

Book a scoping call

Integration takes an afternoon. Then your users open the builder — and stop.

The agents that get adopted are the ones people can clone and edit, not the ones they have to invent from nothing.

We’ve built agents across support, sales, operations and automation. We’ll build yours.

Two paths

Two ways to get agents into production.

Both are real. Most platforms take the first one, and that is exactly as it should be.

Platform + your team

Self-serve

Integrate in about 15 minutes
Your engineers own it end to end
Any model, full control
Templates library included

Start building

Platform + GTWY engineers

Co-built

Our applied AI architects co-build your first agents
We productionize the complex ones
Full ownership transferred to you
No lock-in, no retainer

Book a scoping call

Fit

Whether this is for you.

The price isn’t on this page, so here is how to work out where you stand before you spend an hour on a call.

A good fit if

You’ve integrated GTWY, or are evaluating it, and are planning a launch
Your users need agents specific to your domain
You have a defined launch date
You want to own what gets built

Probably not a fit if

You want us to run your agents ongoing
You’re looking for an open-ended retainer
You haven’t decided on the platform yet
You need help with integration itself — that’s 30 minutes and the docs cover it

What we build

Four things, defined up front.

Launch agents

The core of most engagements

A working set seeded in your panel, in your branding, ready for your users to clone on the day you go live. We start from what your users already do rather than from what is impressive to demo.

Automation platforms

Agent nodes for the workflows their users already run.

Helpdesk tools

Triage, response drafting, escalation, summarisation.

CRM and sales tools

Enrichment, follow-up drafting, meeting prep.

Vertical SaaS

Agents matched to your industry and your customers’ work.

Industry templates

A template library your users browse inside their own panel, built around your vertical and private to your platform. Nothing published to the shared library, nothing visible to another customer.

Custom tools and integrations

Internal APIs, proprietary systems, unusual auth — anything outside the standard integration set. Built as tools in your panel so they appear to your users alongside everything else.

Complex agent productionization

The hardest part

Multi-step, multi-agent, high-stakes workflows — where the distance between a demo that works and a system you would put in front of customers is the whole project.

Evaluation

A test set that says whether a change made it better, not just different.

Guardrails

What it must never do, enforced rather than prompted.

Edge cases

The inputs that break it, found before your users find them.

Failure handling

What happens when a tool is down or a model refuses.

How we work

Four phases, with dates on them.

Timelines below are for a typical launch engagement. A larger scope moves them; nothing about the shape changes.

Scope

Week 1

We review your product, your users and what they are actually going to build. Domain sessions with your team, and a look at what your users already do most.

You get — a written scope: the agent list, what each one does, what your users can change, and the success criteria we will be measured against.

Build

Weeks 2–4

We build the agents in your panel, in your branding, against your staging environment. You watch it happen rather than waiting for a reveal.

You get — working agents in your environment, updated as they land, not a deck about them.

Review

Week 5

You put them in front of real users. What comes back is usually about wording, thresholds and edge cases — the things nobody can predict from a scope document.

You get — iteration against the success criteria agreed in phase one.

Handover

Week 6

Documentation, a walkthrough with your engineers, and the transfer of everything we built.

You get — full ownership, written documentation, and a team that can extend the work without calling us.

What we need from you

Five things, or this slips.

A named point of contact — one person who can make decisions
A staging environment — with the embed configured
Domain knowledge sessions — two or three hours in week one
Sample data or documents — real ones, not invented examples
Review turnaround inside five working days — the single most common cause of overrun

Who works on it

The people who build the platform.

A small group of applied AI engineers who work on GTWY every day. They are not a separate consulting arm and they are not contractors — which is why the queue is short, and why what they learn on your engagement tends to end up in the product.

If we are at capacity we will say so and give you a date, rather than starting late and finishing later.

Ownership and IP

You own everything we build.

Your agents, your prompts, your configurations. This is the section procurement will read most carefully, so it is written to be read that way.

01You own the workEvery agent, prompt and configuration we build is yours
02No licence on itWe keep no rights to what we built for you and no ongoing dependency
03Documented at handoverWritten down, not held in someone’s head
04Exportable if you leaveAgent definitions come with you if you stop using GTWY

After handover

What happens when it ends.

Your team owns it

Maintaining and extending the agents is yours from handover. That is the point of the documentation and the walkthrough.

Support continues normally

Platform support runs through the usual channel, exactly as it does for any customer who never bought services.

Further work is scoped separately

If you want more agents later, that is a new engagement with its own scope and its own price.

This is not a retainer

There is no monthly services fee and no standing allocation of our time. The engagement ends.

Boundaries

What we don’t do.

We don’t do your integration

That is about 30 minutes and the docs cover it. If we sold you help with it, we would be admitting it was hard.

We don’t run your agents for you

You own them after handover. They are yours to change, extend and break.

We don’t do open-ended retainers

Engagements have an end. Further work is separately scoped, or it doesn’t happen.

Pricing

Scoped, then priced.

Every engagement is scoped to what you’re launching, so we price it after we understand it. Scope and price are fixed before work starts — you’ll know the cost and the timeline before you commit.

Platform usage is billed separately at standard rates. An engagement covers the build; the runs those agents make are on your normal platform pricing.

Availability

We take a small number of engagements at a time.

The people who would build your agents are the people who build the platform. We keep the queue short on purpose — if we are full, we will tell you rather than take the work and be slow.

Questions

Before you scope anything.

How long does a typical engagement take?

About six weeks for a launch set: a week to scope, three to build, one to review, one to hand over. A vertical template library runs closer to ten. Complex productionization is scoped individually, because an honest estimate needs to see the workflow first.

What if we need changes after handover?

You make them. That is what the documentation and walkthrough are for — your team owns the agents and can change anything. If you want us to do a further piece of work, it is scoped as a new engagement rather than drawn from a retainer.

Do we own what you build?

Yes. Every agent, prompt and configuration, with no licence retained by us and no dependency after handover. Agent definitions are exportable even if you later stop using GTWY.

Can we do this later instead of at launch?

Yes — and plenty of platforms should. Integrate, launch, watch what your users try to build, and come back when you know which agents are worth seeding. You will scope a better engagement with three months of real usage behind you than you can before launch.

Nothing about the platform requires this. If you never buy services, the product works exactly the same.

Do we still pay for platform usage?

Yes. Services is the build; runs are billed on your normal platform pricing throughout the engagement and afterwards. An engagement does not include platform credit.

What if our users need different agents than we scoped?

That is what the review phase is for, and it is why the scope names success criteria rather than just a list. Within the agreed scope we iterate. If real usage points somewhere genuinely different, we would rather re-scope with you than deliver agents nobody clones.

Can you work under our NDA and security requirements?

Yes. We sign your NDA, work in your staging environment rather than copying data out of it, and our engineers can complete your security onboarding before the scoping phase starts. Bring your requirements to the first call and we will tell you plainly what we can and cannot meet.

Next step

Book a scoping call.

An hour on your product and your users, and you’ll have a written scope with an agent list and a price. No obligation to take it.

Or start building yourself → — the platform works exactly the same either way.