Custom Agentic Systems
built in days.
One specification becomes every layer of your system in days — mobile, web, backends, agents, infrastructure — reviewed by our engineers before it ships. What you get back is not a codebase you have to staff. We migrate the data, deploy it, host it, secure it and support it, Build the intelligence layer that knows your data, your rules and every department within your organization.
›Internal operations portal — React web app, iOS & Android, Postgres API, single sign-on, full audit trail, deployed to our own cloud.
Six workstreams, one specification. Front-end, back-end, test, QA and DevOps agents work them in parallel, and a human engineer signs off every one. An agency runs them in sequence — that is where the quarters go.
One brain, eight surfaces.
Unified data across every single department.
Every surface your product needs, from one engine.
Most agencies specialise in one layer and subcontract the rest. Marrinn creates all of them from the same specification, in days rather than months — which is why the estimate does not triple when you ask for the mobile app as well.
Mobile apps
iOS and Android from a single codebase — offline support, push, biometrics, store submission.
Desktop apps
Windows, macOS and Linux builds with auto-update, local storage and hardware access.
Web & front-end
Marketing sites, customer portals and internal dashboards — fast, accessible, responsive.
Backends & APIs
Data model, services, REST and GraphQL, authentication, permissions, third-party integrations.
AI agents
Assistants and copilots grounded in your own data, on the model you choose — including private, offline ones.
Automation
Workflows, approvals, document handling, scheduled jobs and integrations that remove manual steps.
DevOps & cloud
Docker, CI/CD, environments, observability, backups and cost-sane cloud architecture.
Data & migration
Pipelines, warehousing, reporting, plus migration off legacy systems with encryption end to end.
Months of work, delivered in days.
Speed here is not a shortcut. It is what happens when you remove the parts of software delivery that were always waste. Nothing is skipped — the slow parts are simply no longer done by hand.
No blank page
The engine is not new. It starts from a complete specification and a library of patterns already proven in production, so day one produces working software rather than scaffolding.
A fleet, not a model
Front-end, back-end, test, QA and DevOps agents work the same specification in parallel. Nothing waits for another team to unblock it, because there is no queue.
Review, not rewrite
When the Agent SDK does the typing, our engineers spend their day reviewing and judging output instead. That is where the compression comes from, and where the quality comes from too.
Tests written with the code
Test suites, checks and pipelines are produced alongside the feature, so quality is not the phase you run out of budget for.
Change stays cheap
Change the specification and the affected layers are regenerated. Late changes stop being expensive, so the scope can keep improving.
You own the output
A real repository, documented and deployable, handed over in full. No lock-in, and no dependency on us to keep the lights on.
And every build sharpens the next.
This is the part that does not show up on a feature list. Every system built on Marrinn returns something to the engine: the specification patterns that survived review, the architecture decisions that held under load, the security posture, the test suites, the shape of what a finished module looks like. The engine learns what good looks like from work that has already shipped. That is why the 35 modules in the suite share one data model and one permission matrix — they were not written 35 times. Your system starts from everything the engine already knows, and then adds to it.
The sky is the limit. Describe it, Marrinn builds it.
The Marrinn Agent SDK is a workflow trained on how enterprise software gets built. It turns your business into a written specification, the domain, the rules, the architecture, the security posture, then works that specification the way a delivery team does. It plans the build, writes the code, writes the tests alongside it, checks its own output, and stops at every stage for an engineer to sign off. Every layer is built from the one specification at once, so the mobile app, the API and the dashboard cannot drift apart.
The Marrinn AI core
The agent never starts from a blank page. It starts from what it has been trained on: the domain model, the architecture rules, the security posture and the coding standards that already survived review on systems running in production. That is the single source everything above is built from. Run it on the large language model you choose: OpenAI, Anthropic, Google, or a private one on your own hardware.
Reviewed by our Experts before Shipping to you.
AI has made software easy to produce and hard to trust. A company can describe what it wants and have a working system back the same week. The screens look right, the buttons do what they should, and everybody assumes the job is finished. What almost nobody can tell you is what sits underneath it. Whether there is a way in for someone who should not be there. Whether the free code it quietly pulled in from the internet is safe, still maintained, or supported by anyone at all. Whether it holds when a hundred people use it at once instead of one.
None of that is visible in a demonstration. It becomes visible months later, as a breach, an outage, or a rebuild you pay for twice. The problem is not that AI writes the software quickly. It is that nobody reads it afterwards.
Nothing leaves here on the AI’s word. Six specialists review every build before it reaches you, and between them they cover the parts you cannot see: who is allowed to reach which records, how the data is protected, every outside component the system depends on and whether it is still safe to depend on, what happens under real load, and whether an engineer you hire in three years can open it and work in it.
A generated codebase looks finished long before it is safe to run, and the gap is only visible to someone who has shipped software before. Speed is the AI’s contribution. Safety is ours.
Front-end engineer
Accessibility, state handling, error and empty states, and what the interface does on a slow connection. A model renders the happy path and calls it finished.
Back-end engineer
Schema and indexes, an authorisation check on every endpoint, input validation, transaction boundaries, and the queries that only turn slow once there is real data behind them.
QA engineer
Test coverage matched to risk rather than to file count — edge cases, permission boundaries, and the paths people take when they are in a hurry.
DevOps engineer
Secrets handling, migration safety, backup and restore, monitoring, and behaviour under load. Deployment is where generated systems fail first.
Principal engineer
Clean architecture, module boundaries, naming and duplication, read against the standards held in your specification. The real test is whether an engineer you hire in three years can open this and work in it.
Product designer
Hierarchy, spacing, the words on the buttons, and whether someone nobody trained can finish the task first time. A working interface and a usable one are not the same thing.
Seven layers, one enterprise AI operating system.
Large platforms sell this as a stack, and the stack is five separate products. You license the data layer, then the workflow layer, then the agent layer, then the analytics layer, then the place your people talk. Each one is a line on the invoice, and the whole thing only holds together if you agree to replace everything you already have.
Marrinn is one system with seven parts. You do not buy them separately, because they were never separate. And the seventh part is the one a replacement stack cannot have: it reaches out to the software you already run.
This operating system is not sold on its own either. It comes with the Marrinn Suite, so every module you turn on is already running on it — the same memory, the same permissions, the same Squids, from the first day.
-
01
The Kernel
The model, and it is your choice.
OpenAI, Anthropic, Google, OpenRouter — or a private Ollama model running entirely offline on your own hardware. The kernel is swappable because the platform was never built around one vendor’s model. Hosting is a separate choice: our cloud, your own cloud account, or your own servers. On a closed deployment nothing leaves the building.
See a worked example → -
02
The Core
Thirty-five modules on one data model.
One permission matrix across 235 actions. One audit trail. Every module reads the same records, so there is no integration between finance and HR to maintain, because there was never a seam. And because the model was written from your own specification, the meaning is already the model.
See a worked example → -
03
The Memory
One version of the truth, across systems you do not own.
The Memory holds your own records, the outside systems you connect, and the context every previous build left behind. It resolves them into one picture: the same client written four different ways across four systems becomes one client, with authority set per field — the CRM owns the relationship, the register owns the risk rating, and neither can quietly overwrite the other. When two systems disagree, you are shown the disagreement rather than the winner, and a Squid citing a figure names the system and the moment it came from. Connect a source read-only, choose which fields it may see, and mark it on-prem so it is never sent to a cloud model.
See a worked example → -
04
The Lens
Where the records become an answer.
Dashboards, scheduled board packs, and plain-English querying that respects row-level security — so the answer a person gets is bounded by what that person is allowed to see, not filtered afterwards.
See a worked example → -
05
The Squids
The operators, and one can lead others.
They think, they act, they report back. Each works a department, follows your written policy, runs inside the same permission matrix a member of staff would, and hands to a named human on anything that matters.
See a worked example → -
06
The Handoff
Where an agent stops and a person decides.
Approvals, escalations, clarifying questions and finished work land on the record itself, in the same notification bell, digest, activity feed and audit trail a person’s own request uses. No second product to license just to hear from your own agents, and the gate does not care whether the actor is human.
See a worked example → -
07
The Ports
And it reaches what you already run.
MCP in both directions, plus the tools layer. A Squid can do work in the CRM, the EMR or the ticketing system you already own, granted per action, capped, and written to the same audit trail. This is the layer that means you take the modules you need instead of replacing what works.
See a worked example →
Read the seven from the bottom and it is an operating system: a kernel, a data model, memory, a way to see, processes that do work, a place those processes meet people, and ports to everything outside. Read them from the top and it is the answer to one question — why an agent here knows what your data means. The other platforms have to bolt on a layer that teaches theirs, because the schema was theirs before it was ever yours. This one was written from your specification, so there is nothing to teach it.
These seven layers are Built into the Marrinn Suite. Take five modules and you get all seven underneath them, because there is no version of the platform without them. The Agent SDK is the thing that writes into this architecture — which is why a module built from your own specification arrives with the same permissions, the same audit trail, the same reporting and the same agents as everything else. It lands on the same seven layers.
Automate your workflows with Specialised Squids.
Most companies buy software and then hire people to operate it. Marrinn ships the operators with the system. We call them Squids, and each one is built for a role rather than bolted on as a chat window: it thinks, it acts, and it reports back. A Squid reads its department’s live data, works out what your written policy says to do, and carries out the task on behalf of your staff.
Take a ready-made Squid from the library, or have one built for the exact role you want. Either way it is bound by the same permission matrix a member of staff would be, so the routine work stops waiting for somebody to have time for it.
And a Squid does not wait to be asked. You set the run up once, saying what it should do, which records it may reach and who hears the result, and after that it starts on its own: on a clock, every Monday morning or the first working day after month end; on something happening in your own data, a deal slipping a stage or an invoice passing thirty days; or on a call from a system outside Marrinn. One Squid can carry all three.
A Squid takes the shape of the work it does — and of the business it does it in. None of them acts alone. Each runs inside your permission matrix, writes to the same audit trail your staff do, and hands back to a named human on anything that matters.
Marrinn built the foundation. You bring the requirements.
Most enterprise suites are sold finished. The data model was settled before your company was ever in the room, and the implementation is the long, expensive job of bending the business until it fits. Anything the model cannot express becomes a customisation, and every customisation becomes something that breaks at the next upgrade.
The Marrinn Suite is an ERP. Finance, stock, manufacturing, people, customers and governance: 35 customisable modules on one data model, one permission matrix, one audit trail. You do not configure it yourself. Send us the business requirements document for the module you need, finance or HR or whichever one it is, and we build to it. Your BRD is the specification the engine works from, which is why customising a module here is ordinary work rather than a special project, and why it does not become debt you pay for at the next upgrade.
The AI operating system described above is part of the Suite, not an upgrade to it. It is the floor every module already stands on from the first day, rather than an assistant bolted to the side of a finished ERP. You are not buying modules and then buying the intelligence that reads them. And it does not ask you to replace what you already run before any of it works.
The two are one system seen from two ends. The Marrinn Suite is what the Agent SDK has already built. The Marrinn Agent SDK is what builds everything the Suite does not cover.
Both are called agents, and they do opposite jobs. The Agent SDK builds software: websites, mobile apps, web apps, internal systems, whatever you specify, handed over as a repository you own. The Squids do the work inside it. A Squid writes no software. It completes tasks on your behalf under a written policy, holding a role in the same 235-action permission matrix your people hold. A department Squid is shared by a team and can lead other Squids beneath it; a personal Squid belongs to one person. One builds the system, the other operates it. The Squids →
The AI operating system
Seven layers, one system. It comes with the Marrinn Suite, it is not sold separately, and it is not counted among the 35 modules. Every module in the six families that follow already runs on it.
The AI operating system
Seven layers. They come with the Suite, and they are not counted among the 35.
The Kernel
The model, and it is your choice. OpenAI, Anthropic, Google, OpenRouter, or a private model on your own hardware.
See the layer→ 02 IncludedThe Core
Thirty-five modules on one data model, one permission matrix across 235 actions, one audit trail.
See the layer→ 03 IncludedThe Memory
One version of the truth across systems you do not own. When two disagree, you are shown the disagreement rather than the winner.
See the layer→ 04 IncludedThe Lens
Where the records become an answer, with the question asked in your own words.
See the layer→ 05 IncludedThe Squids
The operators, and one can lead others. A department Squid is shared; a personal Squid belongs to one person.
See the layer→ 06 IncludedThe Handoff
Where an agent stops and a person decides. Nothing outbound leaves without the gate it was given.
See the layer→ 07 IncludedThe Ports
And it reaches what you already run, rather than asking you to replace it first.
See the layer→Or build your own on the metadata engine.
The same engine that produced all 35 modules is available to you. Describe a module and it joins the suite with the same permissions, the same audit trail, the same reporting and the same agents as everything else. No fork, and no plugin architecture to learn.
Everything above, proven on our own product.
TagFlow is a finished product. It packages three modules from this suite — agile delivery, OKRs and a native CRM — into one workspace, and it was specified and built on the platform described on this page. It inherits the same data model, the same 235-action permission matrix and the same audit trail as everything else here. The screenshot is TagFlow.
See what TagFlow does →
Your model. Your cloud. Your decision.
An octopus takes the colour of whatever it sits on without changing what it is. The engine, the data model and the permission matrix are identical in every configuration below. Only the surroundings change. Pick a model and a place to run it, and read what that combination actually commits you to.
Bring us the system you have been putting off.
Tell us what you need built. We will show you the platform on your own problem — architecture, screens and a realistic delivery plan, not a canned slide deck.