Notes from building agents.

Crypto-agility, or: why algorithm choice is the easy part.

Picking the right algorithm is a Tuesday-afternoon decision. Building a system that can swap that algorithm five years from now, without rewriting the application around it, is a multi-year discipline. That discipline is crypto-agility — and it has been the difference between teams that handled MD5, SHA-1, RC4, and TLS 1.0 quietly and teams that handled them as incidents. Here's what crypto-agility actually is, what an agile system looks like in code, and the four habits that make it real.

Post-quantum cryptography, without the panic.

A working quantum computer big enough to break RSA doesn't exist yet — but the day it does, every secret captured today becomes readable. NIST has shipped the algorithms that survive that day. Here's what post-quantum cryptography actually is, what NIST standardized, which systems should care now, and the one habit that matters more than picking the right algorithm.

The social-media agent system, designed.

People keep asking us the same question: can you build an agent system that handles social media — branding, content, scheduling, analytics, the lot? Yes. And the reason yes comes easily is that a social media operation is already a multi-agent system. Here's the architecture, agent by agent.

The loop that improves itself.

Most AI social media tools generate content and stop. The valuable part isn't the generation — it's the loop: post, measure, learn, adjust the content and the timing, post again. A social system that closes that loop gets better every week on its own. Here's how the self-improving loop is actually built.

Branding is the hardest agent to build.

In a social-media agent system, the content agent is easy and the scheduler is easy. The brand agent is the hard one — because brand voice isn't a style you set, it's a constraint the whole system must obey. Get it wrong and AI flattens your brand into the same competent mush as everyone else's.

Who presses publish?

An agent system can draft a brand's posts, schedule them, even reply to comments. The question every business actually asks me before they buy one is quieter and more important: who presses publish? Designing the human seam in an autonomous social system is the difference between a tool you trust and one you don't.

What playable ads taught me about agents.

A playable ad has about fifteen seconds to teach you a game, hook you, and convert you — with no instructions allowed. I've made a lot of them, and I love it. Those brutal constraints turn out to be the best training I ever got for designing how a person meets an AI agent for the first time.

Anatomy of a playable ad.

A playable ad is a fifteen-second interactive mini-game built to sell another app. It looks simple and it is brutally engineered. Here's the teardown — the first three seconds, the hook, the core loop, the call-to-action — what each part does, how each part fails, and why this is the most disciplined format in advertising.

The playable ad is the most honest ad format.

Every other ad format asks you to believe a claim — a video, a screenshot, a testimonial. A playable ad asks you to do something stranger: try it. You experience the actual product before you decide. An ad you can't lie with is a rare thing, and it changes what advertising can be.

A playable ad and an agent demo are the same problem.

A playable ad has to prove a game is fun, hands-on, in fifteen seconds, with no manual. An AI agent demo has to prove a system is valuable, hands-on, in minutes, with no manual. I make playable ads, I demo agent systems, and I've stopped treating them as different jobs.

Points, badges, leaderboards — for the agents, not the users.

Gamification's oldest triad — points, badges, leaderboards — is always pointed at users, to make them come back. We point it the other way. At GOGOGO the points, badges and leaderboards are for the agents: it's how a multi-agent system is scored, qualified, and improved. Gamify the machine, not the customer.

The game vs the casino.

A game and a casino both keep you playing — but they are moral opposites. A game rewards skill and gives you growth; a casino rewards compulsion and gives you nothing. Most 'gamified' products quietly became casinos. Here's the test that tells them apart, and the line we hold designing retention at GOGOGO.

Flow state for software.

Csikszentmihalyi's flow channel explains when a person is fully absorbed: the task is matched to their skill — too easy is boredom, too hard is anxiety. The same channel describes a multi-agent system. An agent given the wrong-sized task fails the same way a person does. Here's the orchestrator reimagined as a flow director.

What game tutorials know about onboarding that B2B software forgot.

A good game teaches you to play it in the first five minutes, without a manual, without a training call — and it feels like playing, not learning. B2B software onboarding is the opposite: a manual, a call, a slow climb. I sell agent systems for a living, and the tutorial level is the best onboarding design I know.

A day in the life of a token.

You typed a question. One of the words you typed is about to have a very eventful few seconds. This is the journey of a single token through a multi-agent system — narrated, for once, by the token itself. The most honest way to explain how the GOGOGO runtime works is to ride along with the smallest thing in it.

The agent that sleeps.

Your brain does its most important memory work while you're unconscious. Sleep isn't downtime — it's when the day gets sorted, compressed, and filed. Multi-agent systems have a memory problem that the same idea solves. This is the case for giving an agent a sleep phase: an offline pass where it consolidates, prunes, and — in a real sense — dreams.

What is agentic AI?

Agentic AI is artificial intelligence that takes actions to reach a goal, not just generates text in reply to a prompt. It plans, uses tools, observes results, and adapts — across multiple steps, with limited supervision. Here's a plain-English definition, the four properties that make AI 'agentic,' and how it differs from a chatbot.

RAG vs fine-tuning vs multi-agent: which does your problem need?

RAG, fine-tuning, and multi-agent systems solve three different problems, and most failed AI projects picked the wrong one. RAG gives a model knowledge. Fine-tuning gives it behavior. A multi-agent system gives it the ability to act over many steps. Here's a plain decision guide — what each one is, when to use it, and a decision tree.

How to evaluate an AI agent vendor: the questions to ask.

Buying an AI agent system is hard because the demos all look impressive and the hard parts are invisible. I sell agent systems for a living, and I'd still tell you to interrogate every vendor — including us. Here are the questions that separate a vendor who will still be working at 3am from one whose demo was the best part.

How AI search picks who to cite.

When ChatGPT, Perplexity, or Google's AI Overview answers a question, it cites a handful of sources and ignores the rest. Being one of the cited sources is the new SEO — it's called GEO. Here's how AI search actually chooses who to cite, why it's different from ranking on Google, and what makes a page citable.

Memory is not a database.

The most common mistake in multi-agent design is treating agent memory as a database — store everything, retrieve on query. A database remembers perfectly and forgets nothing, and that is exactly the wrong shape for a mind. Here's how we actually build agent memory at GOGOGO: episodic vs semantic, why forgetting is a feature, and the four-layer model we use.

What a Metin2 server taught me about distributed systems.

As a kid I ran a PvP server for an MMO called Metin2. I thought I was running a game. I was actually running my first distributed system — a live economy, a load problem, an abuse surface, and a few hundred users who'd find every bug in minutes. Everything I do now in multi-agent systems, I first learned wrong, then right, on that server.

The 3am failure: trusting agents nobody is watching.

A multi-agent system earns its keep by running while you sleep. But autonomy means the failure also happens while you sleep — at 3am, with no human in the loop. The hard question of agent operations isn't 'how do we stop failures.' It's 'what should the system do when it fails and nobody is watching.' Here's how we answer it at GOGOGO.

Meet GoBot — the face of every agent we ship.

GOGOGO is a multi-agent company: dozens of small specialized agents, one runtime. So why do we have exactly one mascot? Because every agent we ship is a GoBot. Same core, different hat. Here's what GoBot is, why the design looks the way it does, and why one face for many agents is the most honest thing we could put on the product.

Are we building simulations, or living in one?

I build multi-agent systems for a living — small worlds full of agents with memory, goals, and an environment. Every one of them is a simulation. That makes the simulation hypothesis stop being a stoner thought and start being a working engineering lens. Here's what building agent worlds taught me about the oldest question, and the more useful question it points to.

The sector map: where autonomous agents land next.

Every industry is being told that autonomous AI agents are coming for it. That's true — but not at the same time, and not for the same reasons. I sell agent systems to non-AI businesses for a living. Here's my honest sector-by-sector map: which industries are ready for autonomous agents right now, which are a year out, and the one signal that decides it.

Twelve archetypes, twelve agents.

Jung's twelve archetypes are a 100-year-old map of the recurring roles a psyche organizes itself around. Build enough multi-agent systems and you notice your agents keep falling into the same twelve roles. This is the full walk: each archetype, the agent it becomes, and how to use a century-old psychological map as a practical design tool for AI systems.

Shipping for a dead platform: Google Glass 2.

In 2019 I built an AR marketplace on Google Glass 2 — a two-sided product where a phone user could hire a glass-wearer in another city for hands-on errands. The platform was already dying when I shipped. Here's what building for a dead platform teaches you that building for a healthy one never will.

How we grade a multi-agent system.

The hardest engineering problem in multi-agent AI isn't building the agents — it's knowing whether they're getting better. Agent output is non-deterministic, so you can't diff it. Here's the eval harness we run at GOGOGO: four grader classes, the rule that every agent step is scored, and why a failing eval is a feature.

The hook model, applied to multi-agent AI.

Nir Eyal's hook model — trigger, action, variable reward, investment — was designed for habit-forming consumer apps. It maps almost too well onto how a multi-agent AI product earns customer retention. Four steps. Four examples from GOGOGO. Two warnings.

Censydiam in production.

Eight emotional motivations on two crossed axes. The Censydiam framework was built for FMCG brand strategy, but it's the cleanest way I've found to explain which AI product fits which customer type. Here's the wheel, and where each of our four products lives on it.

Jung, Freud, and how they show up in how I design agents.

I spent my quiet university years reading Carl Jung's archetypes and Sigmund Freud's structural model. I didn't know I'd use them. Twelve years later, the orchestrator I designed for GOGOGO's multi-agent runtime has the shape of Freud's ego, and the agent specialist roles map almost cleanly onto Jung's archetypes.

Quantum honesty: the I-Ching × quantum RNG algorithm.

Provably-fair RNG for games of chance is a real problem. Most solutions use server-side hashes and ask players to trust the audit. I've been sketching a different approach for years on [ezagor](https://ezagor.com) — 64 hexagrams of the I-Ching crossed with hardware-quantum randomness, producing outcomes that are statistically uniform AND symbolically interpretable. Here's the algorithm.

What actually happens when your code runs.

Source code is not the same as the thing the machine executes. Every line you write descends through five layers of translation, ending in electrons in a transistor. Here's the staircase, layer by layer, in the most concrete language I can manage.

Thirteen languages, one career.

Over twenty-four years I've shipped real projects in thirteen programming languages — C, C++, C#, Python, Java, JavaScript, SQL, PHP, Swift, Kotlin, VB.NET, Assembly, MATLAB. Most of them I still use. Here's what each one taught me, and why I refuse to give up the unfashionable ones.

Pricing AI like natural stone.

In my early twenties I ran a natural-stone home-decoration company. The customers didn't pay for the slab — they paid for the kitchen they hadn't built yet. I price our AI products the same way today: outcome, not infrastructure. Here's the four-tier framework.

Four products on one runtime.

Goddo, GoPeople, GoVista, GoTrack — generative AI, HR over WhatsApp, digital-signage CMS, retail computer vision. Four different categories, four different customer types, one multi-agent runtime underneath. Here's the architecture, the decisions, and what nearly broke.

Sixteen with a production machine.

I ran a fishing-net components business when I was sixteen. Lead sinkers, plastic floats, monofilament line — my own machines, my own customers, my own invoices. Twenty years later I run an AI company and I still think every bad month at GOGOGO is easier than that summer.

How I sell AI to people who don't know what AI is.

Most enterprise demos talk to the wrong room. The director who decides whether to buy GoPeople doesn't care about our orchestrator pattern. She cares about her Tuesday. Here are the three reframes I use, the two phrases I refuse to say, and the one question that closes every demo.

The Happiness Manager playbook.

Before GOGOGO, my title at a corporate was 'Happiness Manager.' I half-mocked it at the time. Three years later I think it was the most important training I had for running an AI startup. Five lessons that travelled.

The brother model: founding GOGOGO with my brother.

We started GOGOGO LLC in 2023 — two brothers, equal partners, one company. Two years in, the question we get most is whether it works. This is the honest answer. Co-written by Atakan and Okan Özalan.

Multi-AI agents vs. multi-agent systems — the words we chose.

Both phrases describe orchestrated AI. Only one describes what we ship. The two-word difference is small; the operational difference is large enough to choose between architectures.

Multi-agent vs. RAG: when each one wins.

RAG is a retrieval pattern. Multi-agent is an orchestration pattern. They solve different problems, and most teams that pick the wrong one rebuild the system within a year. Here's the decision tree we use to pick — with the failure modes that tell you, in retrospect, you picked wrong.

I-Ching as a multi-agent design pattern.

Eight trigrams. Eight agent role archetypes. The 4,000-year-old framework for understanding how forces combine maps surprisingly cleanly onto how specialised agents combine into a working system. Here's the pattern we ended up with, and what each trigram actually contributes.

From AIML in 2015 to multi-agent in 2026: the 10-year arc of conversational AI.

I wrote XML rule trees for Turkcell BiP Messenger in 2015. I now build typed multi-agent runtimes for GOGOGO LLC in 2026. The path between the two isn't a straight line — it's a series of forced compromises with the model of the day, and each compromise produced a pattern that survived into the next era.

Shipping a multi-agent system isn’t shipping a chatbot.

We rewrote the orchestrator three times before we stopped treating it like a model. Here’s what changed when we started treating it like a runtime — typed hand-offs, replayable traces, and a strict contract between specialists and tools.

Why GoTrack uses a FAISS reranker on top of CLIP.

Pickup detection isn’t a classifier — it’s a similarity problem. We index live frames against a per-store catalogue and let a reranker decide what shopper actually grabbed.

Classifying WhatsApp HR messages with a router agent.

Our biggest win on GoPeople wasn’t a smarter answer — it was a smarter router. We split intent classification from response so each agent stays cheap and inspectable.

How Goddo turns one prompt into a five-agent pipeline.

Prompt rewrite, style guide, render, refine, watermark. Each step is its own agent — a single failure doesn’t take down the whole render, and we can swap any stage without redeploying.

Multi-zone scheduling without losing your mind.

Stores don’t have one screen — they have rails of them. We rebuilt GoVista’s scheduling engine around zones first, schedules second, and let an agent reconcile the two.

Observability isn’t an add-on — it’s the orchestrator.

Every hand-off, every tool call, every score — captured by default. We don’t bolt observability on after the fact; we make it the rail every agent walks on.

Six things we believe about agents that we used to be wrong about.

Bigger context windows aren’t a substitute for memory. RAG isn’t a feature, it’s a tool call. ‘Autonomous’ is a marketing word — what you actually want is reversible.

What we learned shipping Goddo to the App Store.

Apple review, content moderation, watermarking, pricing experiments — a notebook of what bit us and what we’d do again.