Let's talk

Plugins & AI Skills · Your technical lever on AI

Every problem has an AI tool. We test, you grow safely.

We develop and test AI tools, plugins and skills for everyday problems, then offer you the best of them to implement your business processes.

The concept

The AI market is chaos. We’ve already tested what works.

  1. 01New toolsEvery week a new tool, plugin or agent comes out promising to change everything.
  2. 02Chaos and risksThe risk isn’t falling behind: it’s burning time and money on tools that shine in a demo but don’t hold up in production.
  3. 03We try themWe test them every day on our own systems, on real cases. Whatever doesn’t hold up, we discard.
  4. 04We present them to youTechnical consulting between peers: we bring you only what works, plugged into the processes you already have.

How we work

We test, select and plug in.

01

We test

We make the mistakes

Every day we try AI tools, plugins and skills on real cases from our projects. Whatever doesn’t hold up in production, we find out, not you: you inherit only what has already passed the field test, without burning weeks evaluating tools that look brilliant and then collapse at the first edge case.

02

We select

Only what works for you

The value isn’t in having “all the AI”, but in the few right tools for your case. We start from how you work and point out what you really need — a ready-made plugin here, a custom skill there, a connector somewhere else — cutting through the noise. Fewer tools, lower costs, less time wasted chasing every new release.

03

We plug in

In production, supervised

We don’t leave you with a list of recommendations: we integrate the chosen tools with what you already use — CLI, API, MCP, connectors — and take them into production with human supervision. We developed many of these skills ourselves in daily use: you plug them in already mature, not as prototypes.

What we integrate

What kind of skills and tools.

Six areas, with examples taken from the systems we use every day. It isn’t a rigid catalogue: we define the right mix for your case.

Memory & knowledge

Agents that remember

Persistent memory across sessions, RAG and management of a living knowledge base (for example one agent that writes and one that checks, to keep records up to date and verified).

Orchestration

Many agents, one flow

Coordinator agents that guide several agents through a process from start to finish (for example one that searches, one that analyses and one that checks, with quality checks at every step).

Connectors & integrations

Getting your tools to talk

MCP, API and CLI to the services you use (Notion, Drive, GitHub, n8n and others), so agents work on your real data, not in a test environment.

Vertical domain skills

Plugins by area

Skills built for specific functions: content, security, growth, brand, market analysis, SEO, compliance.

Operational automations

The repetitive work

Skills that carry out the tasks that eat up your time in administration, marketing and sales: the bridge to automation for SMEs, but quick to plug in.

Verification & guardrails

Quality under control

Control agents that check integrity and accuracy (against hallucinations, with a human in the loop): AI executes, a check validates.

How we help you

From choice to autonomy.

  1. 01One-to-one technical advisory: we guide you through the tool chaos and tell you what is really worth it for your case.
  2. 02Selection and securing: we choose and secure existing skills and agents, open source ones included, before they reach production.
  3. 03Custom development: we build skills and plugins around your specific processes, when ready-made ones aren’t enough.
  4. 04Integration into production: we integrate everything with your tools (CLI, API, MCP, connectors), with human supervision.
  5. 05Handover: we leave you self-sufficient: you understand how it works and you run it, without depending on us.

Most frequently asked questions

“Memory” isn’t one single thing, and that’s where people get lost. There’s session memory (the context window, which sooner or later runs out), persistent memory (the facts that carry over from one session to the next) and retrieval of broad knowledge (RAG on a vector store). In practice a mix works: file-based memory for the stable facts the agent must always have to hand, a vector store for knowledge too big for the context, and dedicated MCPs that expose all this to the agents cleanly. It’s the pattern we use on our own systems: agents “remember” because memory lives outside the model, not inside it. We show you what holds up and what to avoid, so you don’t build a memory that gets corrupted the first time it grows.

The honest answer is “both”. For common tasks, ready-made plugins and skills get you started in hours and there’s no point reinventing them. But on the processes that make you different — the ones specific to your business — ready-made tools become generic and the real value lies in custom work. We develop vertical skills and plugins for our own daily use: we give you the right ready-made ones where they’re enough and custom ones where they’re needed, without making you choose blindly or pay for development where a solid solution already exists.

Almost never from scratch. On GitHub there are mature repositories that cover 80% of what you need, and starting from there saves you months. The point is that “lots of stars” doesn’t mean “works in production”: many agents shine in the demo and fall apart on real cases. The work that matters is selection (which repository holds up), securing (closing the holes that only show up under load) and integration with your context. We do that part with you, so you start from a proven base instead of a blank page.

You don’t need an MCP for everything: it’s a common mistake that adds needless complexity. If a service already has a clean CLI or a well-made API, you can often use it directly and be done. A dedicated MCP pays off when you want to standardise access to that service for several agents, reuse it across different projects and give the model a stable interface. It’s a trade-off between speed and reuse, to be decided service by service: together we assess where an MCP is worth building and where a CLI or API is more than enough.

There’s no absolute “best”: it depends on what you put in. For short, stable facts a lightweight file-based memory works well; for broad knowledge you need a vector store with retrieval; for versioned documents an MCP that talks directly to the repository is the way to go. The risk is setting up a more complicated stack than necessary and ending up having to maintain it. We give you the stack we actually use for our own knowledge base — already tested, with its known limits — and adapt it for you, so you start from something that runs.

We don't have a price list: every project is priced on quotation. It's boutique work, tailored to your processes and hard to standardise. The quote comes after the discovery call, once we know what needs doing.

We integrate the right AI, without the chaos.

Free discovery call, 30 minutes, tech to tech. Tell us what you want to automate or grow: we’ll tell you which tools are really worth it and how to plug them into yours.