You bring the problem. We build the solution.
Two 42-trained, AI-native engineers. We design, build and ship custom software — AI systems, agents, automation, integrations and bespoke tools — the same disciplined way we teach it, and hand it over so you own it. No lock-in.
- Shipped, not slideware
- AI-native delivery
- You own the result
If it runs software, we build it.
AI is our sharp edge — not the boundary. We build all kinds of software, with AI woven in where it earns its place.
Implementation & integration
We ship software into your existing stack, tools and processes — AI woven in where it earns its place, not bolted on.
Automation & workflows
Pipelines and processes that run themselves — the repetitive, error-prone work taken off your team's plate.
Custom tools & apps
Bespoke software built around how your team actually works — internal tools, dashboards, apps, end to end.
AI agents & systems
Specialised and autonomous agents wired into real work — reliable, observable, and under your control.
SOPAIOS — our AI framework
Our own engineering backbone: a framework-agnostic AI OS (Claude, Codex and more) we build on — production-grade method, made repeatable.
The method we teach, applied to ship.
The same discipline behind our programmes, pointed at your delivery — so what we build is reliable, documented, and yours.
-
01 Spec-driven build
We write specs an AI can actually execute — the build is deliberate, not improvised.
-
02 AI-assisted testing
Tests generated with AI and reviewed by humans — output you can trust.
-
03 Documented & reproducible
Everything written down and repeatable — not locked in our heads.
-
04 Handed over
You own the result — the SOPs, habits and AI stay with you. No lock-in.
Every project is a skill.
Not a feature list. A problem we understood and how we solved it: the method above, made real.
Its owner isn't technical. He runs the whole site himself, just by talking to an AI.
FFG Bags: a B2B site its owner runs through AI
FFG Bags' bilingual B2B site: 200+ pages, live in production.
- What we saw
- FFG's owner already ran his own site, but on an old, rigid website builder: clunky to edit, costly, not optimized, and impossible to really grow without going outside. The ceiling was never the website. It was the tool.
- Our craft
- So we built him an operating system, not just a site. A prompt orchestration wired to a coding agent (Codex) lets him create and change features in plain language. Guardrails keep every change on-brand and safe, a bad edit can't reach the live site, and each one comes with an audit he can actually read.
- What it changes
- He runs and grows his own site himself, about a minute per change, with no developer in the loop. And he owns all of it. No lock-in.
Built with Codex (ChatGPT) · Bespoke system prompt · GitHub · Cloudflare Pages
“Add a winter collection page.”
- Reads the intent, keeps every change on-brand
- Codex writes the actual code change
- Preview-first: a bad edit can’t reach the live site
- Versioned in git, every change reversible
The job was never buying. It was chasing. So we automated the chase, and left every decision with a human.
An autonomous IT-purchasing agent
Built by our founder for the IT department he led at Decathlon Vietnam — a chat assistant plus an automation agent that runs IT hardware purchasing end to end.
- What we saw
- Every IT purchase ran by hand. The team became a human switchboard, chasing every party by email. The work wasn't buying. It was coordination.
- Our craft
- Two pieces on the existing stack: a chat assistant the lead talks to, and an agent that runs the whole back-office choreography. Humans stay in the loop throughout, so Finance keeps every spending authority.
- What it changes
- IT goes from making each purchase to approving it in a click. Roughly half an IT person's year given back, fulfilment about 40-50% faster, compliance auto-enforced. (Impact figures illustrative.)
Built with Open WebUI · n8n · Gemini API · Gmail / Sheets / Drive
- Emails suppliers · collects 3 quotes
- Routes to Finance — who keeps spending authority
- Sends every follow-up automatically
- Live status board + Drive archive
Pick a project, see the skill behind it.
We refuse to run our prompts on vibes.
ForgePrompt: our LLMOps workbench
The internal workbench we're building to version, test and iterate our prompts like real software.
- What we saw
- A prompt decides whether an AI feature works. Yet most teams edit them in a chat window and hope: no history, no way to compare two versions, no proof a change actually helped.
- Our craft
- We treat our prompts like software. Version every one, compare variants side by side, measure quality instead of guessing. It's the discipline we'd bring to your stack, dogfooded on our own first.
- What it changes
- When we build AI for you, the prompts behind it aren't disposable text. They're versioned, reviewable assets you own.
Built with TypeScript · Fastify · React · Prisma / Postgres
We don't trust a source. We make it prove itself, claim by claim.
A source fact-checker
An internal tool to fact-check our sources: transcript → claim extraction → verification → confidence score (video is one kind of source).
- What we saw
- AI gives you fluent, confident answers. Confidence isn't truth: a model will state something that sounds right and cite a source that doesn't actually back it. Trust a whole document, and one bad claim slips through unnoticed.
- Our craft
- We don't take a source at its word. We break it down into individual claims, check each one against the evidence, and tie it back to the exact moment it came from. Verifying is a step in how we work, not an afterthought.
- What it changes
- Everything we deliver rests on claims that were checked, not assumed. No hallucination quietly riding along in a document, a slide, or a knowledge base we hand you.
Built with React · Express / Postgres · AssemblyAI · OpenRouter
Anyone can demo an agent. Ours runs every day, while we sleep.
A daily AI-watch agent in production
An autonomous monitoring agent we run every day for our own AI/ML intelligence (dogfooding).
- What we saw
- Most AI agents are demos: they work once, with someone watching. The real test is an agent you can leave alone, running on live data day after day, that nobody has to babysit.
- Our craft
- We built one for our own daily AI watch, and we genuinely depend on it. The hard part isn't wiring the pipeline. It's making an agent dependable enough to run unattended in production, every day, on real data. It earned our trust by running, not by demoing.
- What it changes
- When we build an agent for you, it's held to that same bar: something that runs in production and does real work, not a demo that impresses once and stalls by week two.
Built with n8n · FastAPI · Claude CLI · MCP · PostgreSQL
If an agent did the work, you should be able to audit it. Git-truth, not vibes.
Observability for agentic workflows
Git-truth observability for our agentic workflows: what an agent actually did, audited.
- What we saw
- Hand real work to agents, especially several at once, and one question follows you: what did they actually change? Most tooling shows you what an agent said it did, its logs and traces. A self-report isn't proof.
- Our craft
- We don't take the agent's word for it. Its own log is just a claim, so we check it against ground truth: the real git diffs, commit by commit and in the working tree. What changed on disk is what happened. The same instinct we bring to sources, pointed at the agents themselves.
- What it changes
- The agents we build are accountable by construction, not a black box you trust on faith: a traceable record of what each one really did, for honest post-mortems and re-planning.
Built with TypeScript · MCP · Prisma / SQLite · Next.js · WebSocket
SOPAIOS
our AI framework / OS
Most AI memory is a guess: embed everything, and hope the right thing comes back. SOPAIOS works like a filing system instead, so the AI knows exactly where everything lives.
- Knows where everything lives (index-first, routed)
- Stays cheap as it grows (light navigation at any size)
- Never loses a thing (git-backed, reversible)
- Works with any tool (Claude, Codex…)
- Markdown
- MCP
- skills
- framework-agnostic (Claude, Codex)
Interconnected Markdown wikis the LLM maintains — index-first.
User context · MCP tool connections · reusable skills.
Let’s build
Have a project to build?
Tell us what you want to build — we’ll scope it with you, and you’ll own what we ship.