LinkedIn carousels

Buyer 3: the AI agent

An MCP server for every node.

The agent calls the same engine as the API and the dashboard. One set of primitives, three doors.

Question 1

Do you own the code?

The repo, the accounts, the domain should be in your name from the first commit. Not after final payment.

Question 5

What happens when you want to leave?

Lock-in is a red flag. You should be able to pause or walk with everything you paid for. We use 7 days' notice, no fee.

The constraint

Bid latency is the product.

The credit balance is the trust contract. Both have to be exact, both have to be instant.

The stakes

One hallucinated fundraise number ends the business.

An AI-native newsroom carries an asymmetric brand risk. Being wrong once is fatal.

Why one LLM call fails

A single model call has no reason to check itself.

So we did not build one call. We built a pipeline that audits its own work.

The problem

Self-hosting an agent is a non-starter for everyone but developers.

Updates break. Channels need OAuth per platform. The agent has to survive restarts.

Compose, don't code

Pick what your agent can do.

Skills compose in the UI. No infrastructure code, no deploy scripts.

One language

TypeScript, end to end.

Frontend, backend, and the mobile app share one type system. No translation layer, no drift.

The frontend

Next.js, TanStack Start, React Native.

Web that loads fast and ranks. Native iOS and Android from one codebase with Expo.

The AI layer

Claude, OpenAI, MCP.

Anthropic and OpenAI for the models. MCP servers so agents call your product directly.

The setup

13 microservices. Kubernetes on Google Cloud. Six developers.

Nobody set out to over-engineer it. It grew one 'best practice' at a time, until a team that should have been shipping was babysitting a cluster.

The diagnosis

The architecture wasn't the problem. The platform was.

Thirteen microservices is a fine shape. Running them on a self-managed Kubernetes cluster, with Eureka wired up for service discovery, was the tax.

How we did it

We let AI read the entire cluster first.

We pointed Claude at the GKE config: every manifest, service and env var. It mapped what was running and what each service needed to come back up on Railway.

What we deleted

Eureka was the first thing to go.

Railway does service discovery natively, so the whole self-managed discovery layer wasn't needed. Same thirteen services talking to each other, minus the plumbing.

The lesson

Sometimes the most senior move is to delete infrastructure, not add it.

Same product, same services, far less to run. The self-managed cluster is gone, and their developers build product now, not plumbing.

How it starts

The demo worked. Then real users showed up.

AI shipped something that looked finished in a weekend. Payments, auth, edge cases, scale: that is where the weekend ends and the real work starts.

The real risk

One person 'kind of' understands it. Usually the founder.

They have a mental model of the prompts that produced the code, not of the system. The day they're unavailable, so is the product.

The fix isn't anti-AI

We're AI-native too. We just keep the judgment in the loop.

Same speed. The review, the architecture, and the tests that make it last are not the slow part. They're the point.

Sign 1

Your team copies data between systems by hand.

Two tools that don't talk, bridged by a person and a spreadsheet. That person is your integration layer, and they are expensive.

Sign 3

You stopped asking for changes because they take months.

So people build quiet workarounds instead, and the workarounds become the process. The software now describes how you used to work.

Sign 5

You pay for software you've outgrown and software you don't use.

Off-the-shelf tools that almost fit, stacked on top of each other, each with a subscription and a gap nobody owns.

The pattern

The first 90% took a month. The last 10% takes three.

The demo looked done. Then came the edge cases, the error states, the real data, all the parts that don't screenshot well.

The part nobody mentions

Hourly billing rewards the slow path.

When the work is billed by the hour, 'almost done' is profitable. The model quietly pays for the outcome you don't want.

What changes it

Flat rate. You own the code. Pause anytime.

Nobody is paid to stretch it. The incentive is to keep your software healthy, which is the same incentive you have.

Why it matters

Your customers feel it, even when they can't name it.

AI-generated interfaces look fine in a screenshot and cheap in your hand. Here is what gives them away.

Tell 2

One purple gradient, everywhere.

Gradient text, gradient buttons, gradient blobs. When the accent is on everything, it means nothing.

Tell 4

Pure black, pure white, flat grey.

No tint, no warmth, no light in the room. Real interfaces tint their neutrals toward the brand so the screen feels lit, not printed.

Tell 6

A clean sans, then a random italic serif.

AI grabs a 'fancy' second font, an italic serif or a script, to add personality. It just adds noise. One type system, used well, says more than three.

How we fix it at Stacklane

We're AI-native. The taste is still human.

Committed colour, real type hierarchy, spacing with rhythm, motion with restraint. Every screen runs one test before it ships: could this be AI slop? If yes, it gets reworked.

Reason 01

You built it because you could.

Not because anyone needed it. When building was hard, conviction came first. Now the thing ships before anyone asks whether it should exist.

Reason 03

You never let a real buyer say no.

You built in a vacuum and called it stealth. Nobody who would actually pay has seen it, because hearing no is scarier than shipping.

Reason 05

Anyone can rebuild it in a weekend.

If it took you an afternoon with AI, it takes your competitor one too. No moat, no reason the win lands with you instead of them.

What survives

Start from a problem so real you'd build it even when building was hard.

That's the only moat left. Not the code. The conviction, the customer, and the specific pain someone pays to make go away.

Contracts, policies, reports. Every answer was in there somewhere, and finding it took hours of digging.

Answers come back in seconds, each with a citation you can click straight to the source.

How it works: RAG

The AI doesn't guess. It retrieves first, then answers.

Retrieval-augmented generation: before the model responds, we pull the most relevant passages from the client's own documents, and the answer can only use those.

The one question that matters

"But how do I know it isn't making things up?"

This is where most AI copilots fall apart. Ours can't.

Citations are easy to fake, so we don't trust the model to police itself. We verify each one against the retrieved source, structurally and with an LLM judge. If it doesn't hold up, the answer never ships.

The quiet failure

Vector search alone misses the queries that matter most.

Exact terms, product codes, names, numbers. Embeddings are great at meaning and bad at precision.

Vector search (HNSW cosine) for meaning. Full-text search for exact matches. Both run on every query.

Then reranking on top when precision has to be high.

On real questions

"Penalty clause in section 4.2" needs exact match. "How do we handle late deliveries" needs meaning.

A real product needs both, in the same query.

The honest answer

Most teams answer: vibes.

Demo vs product

A demo works on the three questions you already knew the answers to.

A product works after every change you make to it.

A fixture set of real questions and expected behavior runs on every change.

Plus LLM cost logging, so you see accuracy and spend, not a gut feeling.

The line

"It felt better" is not a metric. "Retrieval held, cost dropped 20%" is.

The other 80%

Nobody posts about the part that decides whether it survives real users.

A failed embedding doesn't lose a document. It retries, then lands in a dead-letter queue you can see.

A retried webhook doesn't double-fire. A job that crashes mid-run resumes where it left off.

Trace any request, cap abuse, and see what every answer cost.

And it's yours

The client owns the code. The data stays in the EU.

The wait

Ten seconds of a spinner reads as "it crashed."

The model is working fine. The user has already left.

With streaming

The same ten seconds reads as "wow, that's fast."

Words appear as they are generated. The wait becomes the experience.

Server-sent events on the AI-SDK wire format. The frontend renders each token as it arrives.

Citations are validated before the first token ships, so speed never costs you trust.

The takeaway

Streaming isn't a feature. It's the line between a demo and a product.