Find the answer.
Show the source.
Search internal documents and return answers with references. Respect source permissions, test retrieval quality and define what happens when the evidence is missing.

AI delivery
We take one real workflow from idea to production. Built in your accounts, tested against failure, secured, and handed to the team who will run it.
Your account. Your repositories. Scope agreed before work starts.
An agent built around a real workflow.
Permissions, evaluation and agreed tests.
Monitoring, a runbook and a named owner.
Model training
AI delivery
Content safetyWe also build and operate software ourselves. tMinus1 built Automatum, a multi-tenant platform with marketplace integrations and metered billing. That work informs how we approach identity, integration and ongoing operations.
Platform engineering experience; this case study does not demonstrate an AI outcome.
We start with the handoffs, repetitive decisions and information gaps your team deals with every day. Then we decide where AI helps, where conventional software is enough and where a person stays in control.
Search internal documents and return answers with references. Respect source permissions, test retrieval quality and define what happens when the evidence is missing.
Extract information, classify a request and prepare the next action in an existing system. Require human approval before sensitive or irreversible changes.
Turn incoming documents into structured records. Validate required fields, surface uncertainty and send exceptions to the person who owns the process.
Illustrative use cases. We agree feasibility, data access and acceptance criteria with your team.
The model is only part of the system. We design the application, data, identity and operating layers together, with controls from the outset, so the workflow has a defined place in your environment.
A business application, internal interface or service workflow. Clear inputs, useful responses and an obvious route to a person when the system cannot complete the task.
Task routing, model requests, retrieval and tool calls. Explicit limits on what can run, how long it can run and which actions need approval.
Approved documents, search indexes and application APIs. Permissions, source ownership and data quality are part of the design, rather than assumptions made by the model.
Identity, secrets, deployment, logging, evaluation and cost visibility. Separate environments and a documented route to release, rollback and recovery.
Illustrative architecture. The components and deployment pattern depend on the agreed workflow and environment.
Connections and boundaries
Identify the sources that are authoritative for the task. Work through document ingestion, metadata, retrieval and references, including how content is updated or removed.
Connect through agreed APIs and service identities. Separate reading from writing, validate inputs and decide which actions should be prepared for approval rather than executed automatically.
Map how information moves through the application, model and supporting services. Agree the handling of sensitive information and the records needed for your review.
Design principles
A scoped identity, approved data sources and explicit tool permissions. The agent only gets the access its task requires.
Representative test cases, retrieval checks and agreed failure scenarios. Test prompt injection, data exposure and unauthorised tool use within an approved environment.
Human approval points, exception handling, audit traces and monitoring. A named owner knows when to intervene and how to operate the system.
We agree what useful means before treating the workflow as ready. Evaluation combines representative work, difficult cases and the failures your process cannot afford to overlook.
Check answers or structured outputs against representative examples and a documented review rubric.
Inspect retrieved material, source references and behaviour when the relevant information is missing or contradictory.
Exercise tool permissions, approval gates and requests outside the intended task. Record blocked actions and unexpected behaviour.
Observe latency, request volume, model usage and failure handling under agreed conditions. Use the findings to discuss service expectations.
A different prompt, model, document set or integration can change behaviour. We leave a repeatable evaluation approach so your team has a way to assess subsequent changes against the agreed baseline.
Adversarial testing is scoped with your team. We agree the targets, environment, access and test window, then document the observed behaviour, its implications and the response.
What happens when a request or retrieved document tries to redirect the agent away from its task? Test whether untrusted content can influence tools, outputs or approval decisions.
Can one request reach information or functions beyond the caller’s authority? Exercise the boundaries between the user, agent identity and connected service.
Can sensitive information appear in a response, tool call or diagnostic record? Examine the agreed data paths and the controls around them.
Does the workflow stop, retry or escalate when a tool fails or an answer is uncertain? Check that incomplete work is visible and consequential actions stay controlled.
Testing reduces uncertainty within the agreed scope; it cannot establish that a system is free of vulnerabilities.
A typical build runs six to eight weeks. The example below shows a six-week shape for a contained workflow. We confirm the actual schedule after reviewing access, integrations, complexity and your approval process.
Map the workflow, data and permissions. Agree success measures, exclusions and who approves the work.
Connect the systems and develop the workflow with representative test cases and controls in place.
Run agreed adversarial tests, investigate failures and refine permissions, guardrails and monitoring.
Walk through evidence and remaining limitations. Your team decides deployment and takes ownership.
Source code, evidence and a handover. Your team keeps the implementation and the context behind the decisions.
Source code in your repositories, integrations with agreed systems and configuration in your environment. Acceptance criteria connect the build to the process you want to improve.
The scenarios tested, observed failures, changes made and remaining limitations. Your reviewers can see the evidence rather than rely on a demonstration.
Identity and permissions, data flows, guardrails, logging and monitoring documented for your internal review. Deployment remains your approval decision.
A walkthrough, runbook, ownership and escalation paths. Ongoing engineering or operations support can be agreed separately if your team needs it.
The system needs an owner when a document changes, a tool stops responding or a user reports a poor answer. We plan that responsibility during the build. Your team can take ownership, or we can scope continuing engineering support.
You do not need to arrive with an architecture or a model selected. We can help define the first workflow, engineer a scoped implementation or assess what is preventing an existing pilot from moving forward.
Work through the business process, available data, integration constraints and ownership. Leave with a proposed scope, acceptance criteria and the uncertainties to resolve before building.
Starting point: a process and a technical owner.
Deliver the agreed workflow with integrations, evaluation, controls and handover. Review progress against concrete examples of the work and the acceptance criteria.
Starting point: a bounded use case and access to the systems.
Inspect an existing pilot’s architecture, permissions, evaluation and operations. Prioritise the gaps and agree which engineering changes are needed next.
Starting point: a pilot, repository or system to assess.
These are engagement starting points, not fixed packages. Scope, fees and responsibilities are agreed in writing.
Not sure which workflow comes first? Start with the free sprint. Already have a use case and an owner? Go straight to a pilot.
Free
AcceleratorBring a process owner, examples of the work and someone who understands the connected systems. We will work through feasibility and scope together.
Scope before price. We quote a fixed fee after agreeing deliverables, assumptions and acceptance criteria. Changes are agreed in writing.
Your environment. Your code. Access and responsibilities are agreed before the build starts. The implementation stays with you.
Funding is conditional. Qualifying projects may be eligible for AWS support, subject to AWS assessment and approval. We confirm eligibility rather than assume it.
Discuss anything specific to your team or environment.
Because scope is what kills these projects. One process gives us a real number, a contained blast radius, and a security review that can actually finish. Once the first one runs, the second is faster.
We prepare evidence for your reviewers: evaluation results, permissions, data flows, audit logging and monitoring. We test in an agreed environment and document remaining limitations. Your team makes the approval decision; approval is not guaranteed.
Whichever one the process needs, and we will argue for the boring choice. Model selection matters far less than scope, permissions and monitoring, which is where these projects actually fail.
We agree the environment, targets, permissions and test window in advance. Findings are documented and prioritised, with fixes and retesting included in the agreed scope.
The system is yours, running in your AWS account. Some clients keep us on a monthly engineering and operations retainer so they do not staff for it. Others take the runbook in-house. Both are fine, and we will tell you which we think fits.
It may. We apply for proof-of-concept funding on qualifying projects and tell you in the first call whether yours is likely to qualify. Funding is at AWS's discretion and is never guaranteed.