The AI and automation capability of a much larger company, without hiring the team — delivered as a service, on your own infrastructure where it matters.
Initial capability pack · August 2026
Every growing business we meet has the same four problems, in the same order.
Meetings, email, documents, formatting, chasing. The work that actually earns money happens in the gaps.
Nobody on the payroll can turn that into something that runs reliably on Monday morning, on your data, without breaking.
Staff pay for chatbot subscriptions themselves. Usage is scattered, unmeasured and occasionally puts your material somewhere you would not choose.
An AI engineer is slow to find, expensive to keep, and one person leaving takes the whole capability with them.
Capability without headcount is now a buildable thing.
Every AI output is evidence for a human decision, never the decision itself.
The meeting transcript feeds the knowledge base. The knowledge base grounds the drafts. The drafts are watched by the same monitors, run by the same panel, on the same governed data. Each stage makes the next one cheaper.
Every capability slide that follows highlights the stage it serves, and each stage in this diagram is a link. The point is not any single feature: it is that the six stages share one foundation.
Plenty of vendors sell a feature. We build the connected capability — an in house asset your business owns outright.
This is our own working estate — the tools we run our own company on, daily — built and operated by the same small team that would build yours. Nothing here is a client deployment, and we do not present it as one. The gold chips link to the appendix slide that justifies each claim.
The call recording is collected automatically after the meeting ends
Transcribed on your own hardware, with speaker attribution — nothing leaves the building
A structured summary: decisions, open questions, who said what
Action items with owners and due dates, deduplicated against what is already on the list
Uploaded before people are back at their desks
Measured against the ~50 minute manual pipeline it replaced. It runs on local models, so the AI fee per meeting is $0.
Transcript quality is scored first. If it fails, every downstream step is blocked — you get a warning, never a confident summary of a bad recording.
Nicknames, initials and full names map to real people, so an action lands on the right list rather than in a paragraph nobody owns.
This runs on our own meetings, every week. Appendix A1
The agent is structurally prevented from sending mail as a person. Allowed and blocked addresses are checked when the service starts, not when it is about to send, so a misconfiguration fails at boot rather than in your client's inbox.
Nothing is sent on your behalf without a human deciding to send it. The system's job is to make the decision take ten seconds instead of ten minutes.
Running as a daemon on our own mailboxes across email and messaging channels. Appendix A2
Decades of documents, email exports and notes sit in folders nobody searches. We turn that into a knowledge base your team questions in plain English, with every answer citing the file it came from.
Proven on a genuinely private archive: 18,000 files of email and notes processed on premises into 68,464 searchable chunks, with people profiles, organisation profiles and reconstructed email threads. Accuracy is measured against a fixed benchmark question set before anyone relies on it. Appendix A3 Appendix A4
The machinery is demonstrated on investment watchlists in our own estate — 6 monitoring services in scheduled production. Retargeting it is configuration, not a rebuild.
One person can genuinely watch three things. The monitors watch everything you name, around the clock, and tell you where to look first. Appendix A5
Newsletters, articles, videos and audio fetched on a schedule, transcribed, and summarised into structured digests you can actually skim.
3 published content feeds produced and shipped hands off, plus a video channel watcher that briefs us every morning before anyone opens a laptop.
The publish step checks its own output and refuses to ship a broken feed. A pipeline that fails silently is worse than one that does not run.
The same machinery drafts your newsletters, client briefs and monthly reports — in your voice, grounded in your own documents, with citations attached for the human who signs it off. Appendix A6
Everything published still passes a person. The pipeline removes the assembly, not the judgment.
An agent asked to do something ambiguous asks a specific question instead of guessing. Demonstrated in our ticket to pull request pipeline, which runs unattended around the clock.
No agent can send mail as a person. The allow and block lists are checked when the service starts, so a mistake fails at boot.
Low confidence outputs are parked for a person rather than pushed through. Confidence is a number the system reports, not a feeling.
Anything that only needs to read cannot write. Enforced by the database and the operating system, not by the application asking nicely.
An automation you cannot describe the limits of is not an automation you should be running.
~30 services and scheduled jobs: live status, last run, logs, start and stop, and a run now button. No terminal, no guesswork.
Backup tiles turn the banner red when a copy goes stale. The absence of a success is itself checked, every day.
Identical discipline on Mac and Windows, so the estate does not depend on which machine somebody happened to use.
You always know what ran, what failed, and what it cost. Appendix A7 Appendix A9
This is the layer most AI projects skip, and the reason so many of them quietly stop working three months after launch.
The boring superpower. One governed database instead of scattered spreadsheets and files nobody can join together.
700M+ rows across 44 stores in a single governed database, so a number in one report can be joined to a number in another.
Generated from the live system, not hand written. Documentation that disagrees with reality fails its own check.
Automated audits run against the estate and have found 2 real defects that no person had noticed.
Least privilege enforced by the server, immutable history, twice daily backups with a verified copy shipped off site nightly.
We learned the hard way that sync is not backup — and we wrote up why. Appendix A8 Appendix B3
| Value lever | Where it lands | Illustrative before → after |
|---|---|---|
| Cut cost | Meeting minutes, document intake, routine reporting, chasing follow ups | A meeting: ~50 minutes of write up → ~3 minutes, at $0 in AI fees. Supplier documents: manual re keying → structured data with exceptions flagged. |
| Scale capacity | What one person can watch, read, draft and produce in a week | Watching the market: three things by hand → everything you name, around the clock. A monthly report: assembled → regenerated. |
| Raise quality | Provenance, institutional memory, consistency, fewer manual errors | "Where did this figure come from?" → answered with the source attached. A leaver's knowledge → stays in the business. |
The same lean team, with materially bigger reach. We deliberately quote no percentage saving: the honest number depends on where your hours actually go, which is what the first conversation is for.
No pricing in this pack. Commercial structure is shaped in conversation once the first use case is chosen.
| When | What happens |
|---|---|
| 07:30 | The morning digest is waiting: the inbox already triaged, two mentions worth knowing about, one competitor announcement, each with a thirty second summary. |
| 09:15 | Someone asks the knowledge base "what did we quote this client last time, and on what terms?" — a cited answer in seconds, from your own files. |
| 11:00 | Supplier documents land as structured data instead of attachments. Anything that does not reconcile is flagged for a person, never guessed. |
| 14:00 | The team meeting ends. Decisions and action items are on the right people's lists before anyone is back at their desk. |
| 16:30 | The monthly report regenerates from live data. Checked and sent inside the hour, rather than blocking a day. |
| 17:30 | Everyone goes home. The estate keeps collecting, transcribing, watching and filing, and it is all in tomorrow's digest. |
Nobody's job changed. Everybody's reach did.
A scoped, embedded engagement — typically four weeks, two consultants working alongside your team. The use case is chosen together in week 1, and you finish with a working first version, not a slide pack.
Training and build in one. Designed explicitly against the documented reasons most AI projects fail. Appendix B2
Your AI function, without the headcount. A weekly working session, a visible request board, and everything documented inside your own estate as it is built.
Yours to keep. If we disappeared, a competent successor could pick it up from the documentation alone. Appendix B1
The meeting pipeline, email triage, the knowledge base, the monitors — stood up as services on your infrastructure.
These are honest generalisations of tools we already run internally, adapted to your systems. That is a real build, not a shrink wrapped product. In build per client
Or name the workflow that hurts most, and we will tell you honestly whether we can reach it. Every door leads onto the same shared foundation, so wherever we start, the next step is already half built.
Zero trust access for anything browsable: an allowlist, a one time code, identity checked on every single request. Nothing sits open on the internet waiting to be found.
Dashboards and viewers hold no credential that could write, so a compromised page cannot corrupt anything.
Enforced by the database server itself. Collectors write only their own area; everything else reads. Secrets live in a vault, never in code or files.
Private workloads run on local models on hardware you control — nothing leaves the building. Cloud models touch only non sensitive work, and only under a policy you agree in advance.
Collected data is never edited in place; every structural change is versioned and logged; twice daily backups with a verified copy off site nightly, and an alarm if the chain ever breaks.
This is how our own estate already runs. Governance was not added for this deck.
Not a proposal to integrate other people's products. A working estate: capture, knowledge, monitors, publishing, one ops panel, one governed database — operating together today. This deck was produced and shipped by the estate it describes.
Published negative results and written post mortems, including the publishing bug in Appendix A6. A partner who only shows wins is a vendor.
You do not need to find, afford and retain an AI engineer to have the capability. We provide it as a service, one workflow at a time, with no enterprise rollout.
We build alongside your people and document everything in your own estate. Transferable by design, so the capability outlasts any individual, including us.
A working session with the people doing the work: where do the hours actually go, and which of them would you most like back?
A consulting sprint, an embedded retainer, or a productised tool stood up on your infrastructure. Whichever fits how you prefer to buy.
A first working outcome within weeks of the build starting, with go and no go gates throughout, so you are never committed beyond the last proven step.
Initial capability pack for discussion — not a formal engagement proposal. Prepared in the United Kingdom. ApisQ provides technology and workflow capability; nothing here constitutes legal, financial or professional advice.
For the person who wants to see how it actually works before recommending it. Everything described here is our own estate, running today.
The nine capabilities from the main pack, taken apart: pipelines, gates, engines, numbers and the post mortems
Phasing and gates, the embedded engagement, build versus buy, and what a first engagement needs from you
The questions everyone asks first, and plain language definitions of every term used in this pack
The recording and any auto transcript are pulled once the meeting ends
Local speech model on your own hardware — no upload, no per minute fee
Who spoke when, separated into distinct speakers
Words and speakers reconciled into one attributed transcript
Two passes: structure first, then decisions, risks and open questions
Actions checked against what is already on the board before anything is created
Tasks created with owner, due date and the transcript link attached
Every transcript is scored before the summary stage. Below the bar, the pipeline stops and says so. A confident summary of an unusable recording is the worst possible output, so it is the one thing the design makes impossible.
A maintained map turns a nickname, a set of initials and a full name into one person, so an action reaches a real list. Unmapped speakers are flagged rather than assigned to nobody.
~50 minutes of listening back, writing up and chasing, per meeting. Now ~3 minutes end to end, at $0 in AI fees, because transcription and summarisation both run locally.
Demonstrated on our own weekly meetings. The pipeline is not a demo path: it is how our action lists get written. Demonstrated
| Stage | What happens | Worth knowing |
|---|---|---|
| Classify | Every message labelled: client inquiry, billing, partnership, supplier, admin, newsletter, spam | The taxonomy is yours to edit; categories are configuration, not code |
| Extract | Genuine requests become tasks with an owner, a due date and a priority, linked back to the thread | A message that is not a request creates nothing — silence is a valid outcome |
| Route | Each category goes to the right person or channel automatically | Works across email and messaging channels, same rules |
| Digest and radar | A morning summary of what arrived and what was created, plus threads you sent that went quiet, resurfaced on a schedule | The radar is the part people notice most: nothing slips because everyone was busy |
The agent cannot send mail as a person. Allowed and blocked addresses are validated when the service starts, so a bad configuration stops the service at boot rather than surfacing in a client's inbox.
Mailbox credentials sit in a vault, refresh automatically, and are scoped to the minimum permission the job needs. A token about to lapse raises an alert on the ops panel Appendix A7 rather than failing silently at 3am.
Raw files reorganised into a consistent structure with clean text, not left as a folder dump
People, organisations, dates and commitments pulled out of the text
A knowledge graph plus a vector index, so related facts surface together
A profile per person and per organisation, assembled from everything that mentions them
Questions answered only from retrieved passages, each claim citing its file
Scattered replies and forwards are stitched back into coherent conversations, so "what did we actually agree" has one place to look rather than eleven.
A fixed benchmark question set with known answers is re scored after every change. Retrieval quality is a number we can show you, not a claim.
Our own private archive, processed on our own hardware. The same pipeline pointed at your archive produces the same result. Demonstrated
25,000+ documents machine transcribed to date. Any format in, clean searchable text out, with a path back to the source page.
| What comes in | How it is read | Why that route |
|---|---|---|
| Digital documents | Direct text extraction | Exact, instant and free — never send a machine readable file to a model |
| Scans and photographs | Two vision engines plus mechanical extraction, results fused | Engines disagree; taking the best of three beats trusting any one |
| Slides and spreadsheets | Structure aware extraction | A table read as prose is worse than not reading it at all |
| Audio and video | Local speech model, then the summariser | Same engine as the meeting pipeline Appendix A1 |
| Handwriting | Vision engine, low confidence flagged | Anything uncertain is marked for a person, never quietly guessed |
Every output records which engine produced it and from which source page. When a downstream answer looks wrong, you can find out why in one step instead of re running the batch.
We benchmarked the engines against each other and wrote up where each one fails: dense tables, multi column layouts, faint scans, rotated pages. Choosing a route per document is data, not a preference.
| Step | What happens | Worth knowing |
|---|---|---|
| Collect | Scheduled collectors pull news, public attention and social chatter for each subject you name | The news tier runs at zero subscription cost |
| Understand | A language model reads each item: is it really about you, and what is it actually saying? | "Great, another outage" is not praise |
| Aggregate | Weighted by reach, per subject, against a rolling baseline of what normal looks like | Measured against that subject's normal |
| Alert | Threshold breached, alert raised with a written narrative and links to the underlying items | Written for a thirty second read |
3 published content feeds produced and shipped hands off, a newsletter and article digest pipeline, and a video channel watcher that briefs us each morning. Demonstrated
Fetch → transcribe → summarise → assemble → validate → publish. Every stage is restartable, and running it twice produces the same result rather than a duplicate.
The feed is checked against its own specification before publishing. A pipeline that ships a broken feed quietly is worse than one that stops.
Two machines running the same publishing job allocated the same episode number 105 times. Because the feed derived each item's identity from that number, podcast apps treated the collisions as the same episode and silently hid the duplicates. Nothing errored. Nobody noticed until a listener asked where an episode had gone.
The fix was not a patch: we made the collision structurally impossible by changing how identity is allocated, then added a validator that fails the publish if two items ever share one. We wrote it up rather than quietly correcting it — because finding the failure mode you would never have looked for is most of what this work is.
~30 services and scheduled jobs on one screen, in a browser, with no terminal involved.
Always on daemons: triage, monitors, collectors. Live status, uptime, start and stop, and the last hundred log lines without leaving the page.
Every scheduled task with its last run, its outcome and a run now button — so "did the backup happen?" is a glance, not an investigation.
Backup freshness tiles turn the banner red when a copy goes stale. The absence of a success is checked, which is the failure people miss.
Capabilities can be turned off without a deployment, so a misbehaving pipeline is stopped in seconds by whoever is at the desk.
The same panel and the same discipline on Mac and Windows. Cross platform parity is deliberate: an estate that only works on one person's machine is a liability, not a capability.
This is the layer that decides whether an AI project is still working in six months. It is also the layer nobody demos. Demonstrated
Our own estate, under exactly this discipline. Backup strategy and the resilience story: Appendix B3 Demonstrated
Every AI call records what it cost, which model served it and which job asked. "What are we spending on AI?" has a number behind it, broken down by workflow.
Simple, high volume work runs on local models at no per query fee. Cloud models are reserved for the genuinely hard queries, under a policy you set.
A job that would silently bypass a flat rate plan and start billing per call refuses to start. The guard checks which credential is in play before any work begins.
The expensive failure in AI operations is not a big bill you notice. It is a misconfigured job quietly running on a metered credential for a fortnight while everyone assumes it is covered by the subscription. Making that condition impossible to start is cheaper than monitoring for it, and far cheaper than discovering it on an invoice.
The meeting pipeline is the clean case: transcription and summarisation both run locally, so the AI fee per meeting is $0 Appendix A1. Where local inference replaces a metered call, the saving is estimated from the measured per run cost rather than asserted.
Map where the hours go; choose the first use case together
A working first version, visible to the whole team
Extend along the six stage spine, one gate at a time
Your team runs it; the capability is yours
| Phase | Focus | Example deliverables |
|---|---|---|
| Discover | Where the hours go; what documents, data and tools exist; agree the success test | Workflow map of your business · prioritised opportunity list · scoped first build |
| First capability | Deliver the chosen use case end to end, visibly, on your infrastructure | Meetings to actions live · inbox triaged · a first corpus answerable |
| Compound | Extend along the spine, each capability reusing the foundation the last one built | Monitors on your subjects · publishing pipeline · ops panel · governed data |
| Institutionalise | Your team runs it; we advise, extend and keep the estate healthy | Documentation and catalogs · runbooks · training · roadmap reviews |
| Documented failure mode | What we do about it |
|---|---|
| Technology before problem | The use case is chosen from your hours in week 1. No tool is selected before the problem is written down. |
| No measurement | A success test is agreed up front: what, observed by whom, would make this a clear win. |
| Sponsorship decay | One named sponsor, a weekly session in the diary, and a visible request board anyone can read. |
| The scaling wall | A pilot that cannot become production is a demo. Governance, the ops panel and backups are part of the first build, not phase two. |
Foundation models, storage, mail plumbing, meeting capture. No pride of authorship where a vendor is genuinely better value. Vendor evaluations are written down before spend, not justified after it.
Your knowledge layer, your triage rules, your monitors, your publishing voice, your catalog. The things no vendor can sell you because they are yours.
The integration layer and the documentation. That is the defence against subscription sprawl, and it is handed over rather than held hostage.
File sync copies your mistakes at the speed of light. Delete something, or corrupt it, and the healthy copy is overwritten before you have noticed — which is exactly what a backup is supposed to prevent. We learned this on our own estate and rebuilt around it.
What replaced it: twice daily verified dumps, a copy shipped off site nightly, a separate ledger recording that each link in the chain actually happened, and an alert when one does not. Restores are tested, because a backup nobody has restored from is a belief, not a backup. Appendix A8
One person who owns the engagement and joins the weekly session. Roughly half a day a week, mostly deciding rather than doing.
Read only access to the systems in scope for the chosen use case, granted one step at a time. Never everything on day one, and never more than the job needs.
A representative sample of the real material — the messy scans, not the tidy ones — so quality is measured on your documents from the first week.
Written down before we start: what, observed by whom, would make this a clear win. It is also what makes the first gate a real decision.
What we do not need: a data migration, a platform decision, a committee, or anybody's job description to change.
No, and we would not take an engagement framed that way. It changes what their hours buy. The system collects, transcribes, sorts, drafts and files; your people question, decide, and hold the relationships.
The scarce resource in a growing business was never headcount. It was attention.
Trust is engineered, not assumed. Answers cite the file they came from; knowledge bases ship with a benchmark question set re scored on every change; low confidence outputs go to a human review queue; and nothing leaves the company without a person signing it off.
That is precisely what the ops panel Appendix A7, the written documentation and the retainer exist for. One screen, plain language, a run now button, and someone to call.
If a capability needs a specialist on staff to survive, we have not finished building it.
The honest counterpoint: any capability you come to rely on creates a dependency. The question worth asking a supplier is whether the dependency is on them or on the thing they built you. We build for the second.
| Term | What it actually means |
|---|---|
| LLM (large language model) | AI trained to read and write text. Useful as a tireless junior who has read everything, and who must always show its sources. |
| Agent | An AI given tools and a goal, which decides its own steps — "find every message about this order and summarise what was promised" rather than one question, one answer. |
| RAG (retrieval augmented generation) | The AI answers only from documents retrieved for that specific question, and cites them. It is the main defence against confident invention. |
| Knowledge graph | A map of who and what your documents mention and how they connect: supplies, invoices, employs, agreed. It answers questions a keyword search cannot. |
| Vector index / embedding | A mathematical fingerprint of meaning, so the system finds passages that say the same thing in different words. |
| Grounding & citations | Forcing the AI to answer from retrieved source text and show where each claim came from. The single most important control on trustworthiness. |
| Hallucination | An AI stating something fluent and false. Grounding, citations and benchmark testing reduce it to something you can audit rather than something you hope about. |
| Local model | An AI model running on hardware you own. Data never leaves the building and there is no per use fee. |
| Benchmark question set | A fixed list of questions with known answers, re scored after every change. It is how retrieval quality gets proved instead of asserted. |
| MCP (model context protocol) | A common plug standard that lets an AI assistant use your tools and data sources without a bespoke integration for each one. |
| Term | What it actually means |
|---|---|
| Least privilege | Every system gets the minimum rights it needs and nothing more, so a tool that only reads cannot write, even if something goes wrong inside it. |
| Immutable history | Collected data is never edited in place. Problems are flagged alongside it and corrections applied in a separate layer, so nothing is silently rewritten. |
| Audit trail & provenance | The recorded path from a number on a screen back to the document it came from. It is what lets anyone ask "where did this come from?" and get an answer. |
| Zero trust access | Every request verifies identity first. Nothing is trusted merely for being "inside the network", and nothing is left open on the internet. |
| Shadow AI | Staff using AI tools nobody sanctioned, on their own accounts. Usually well intentioned, always unmeasured, and occasionally puts your material somewhere you would not choose. |
| Human in the loop | A person reviews before an output has effect. Applied where the cost of being wrong is real, rather than everywhere, so the review still gets read. |
| Idempotent pipeline | Running it twice produces the same result as running it once. It is what makes a failed job safe to simply restart. |
| Daemon / service | A program that runs continuously in the background rather than when somebody launches it. The triage and monitoring capabilities are services. |
| Quality gate | A check that stops the next step when its input is not good enough — the reason a bad recording produces a warning instead of a confident, wrong summary. |
Tell us where the hours go, and we will tell you honestly what we can give back.
info@apisq.co
Initial capability pack, v1 · August 2026 · Prepared in the United Kingdom for discussion purposes only. This document is not a formal engagement proposal. Every capability described is drawn from ApisQ's own working estate and is labelled Demonstrated, In build or Roadmap accordingly; no client implementation is claimed or implied. ApisQ provides technology and workflow capability; nothing here constitutes legal, financial or professional advice.
Read the main pack; dip into the appendix only where you want the evidence. Most readers spend about fifteen minutes on the first twenty slides and never need the rest — but every claim in them links to the appendix slide that backs it up.
Scrolling moves one slide at a time, so nothing lands halfway. Arrow keys, space and page keys do the same, as do the ▲ ▼ buttons at the bottom right. Click the gold page number to jump anywhere.
👍 / 👎 rates the slide you are on in one click; 💬 Feedback leaves a written note. Both genuinely shape the next version.
Any dotted gold term jumps to its plain language definition in the glossary, and a ← Back button returns you to exactly where you were.
This pack is public and we do not ask who you are. It records anonymous usage analytics — how long each slide is open, and any reactions or notes you choose to leave. The timer pauses whenever you switch away, nothing else is collected, and it is used only to improve the next version.