The agent runtime with a cost cap and an approval gate.
APG (Agents Proving Ground) runs your agents on your own machines. Every agent is declared in a registry, held to a spend limit and watched for health. Anything that would leave the building waits for a person to approve it. CRM and Drengur run on APG, and so can your own apps.
The app running
One job on the engine
Every job follows the same steps.
A request arrives, an agent drafts, exact code checks the details, and a person approves. The record shows every step.
- A first draft
- The agent reads the request and writes a draft.
- A cheap check
- A second, smaller pass scores the draft against a gate.
- Plain code
- Amounts and dates are filled by exact steps, the same way every time.
- You approve
- Nothing goes out until a person says yes. The result is recorded.
Done: 3 reminders approved and queued
Done- A request arrives
- First draft
- Cheap check
- Plain code
- You approve
- Result recorded
How it works.
Step 1
A request arrives and the agent drafts.
The engine takes the job, finds what it needs and writes a first draft.
Engine, your agentsDemo data
Step 2
Exact steps check the details.
A cheap check scores the draft. Then plain code fills in amounts and dates the same way every time.
Engine, your agentsDemo data
Step 3
The result is recorded.
Every run ends on the record: what it did, what it cost and whether a person approved it. Nothing goes out until someone does.
Engine, your agentsDemo data
The runtime, screen by screen.
These are illustrations of the runtime, drawn with invented demo data. They show what the runtime shows: drafts waiting for you, runs completed and time given back. No real client appears in them.
Home
What is waiting for you, what completed this week and the time given back.
Runs
Every run and what came of it, with the steps of a draft that is waiting for a person.
Spending
A monthly cap for each agent and what it has spent against it.
Schedules
Recurring runs, when each one last fired and when it fires next.
Activity
The record of what the system did, in plain words, with failures shown as failures.
Agent runtimes make you pick lock-in or plumbing.
Hosted platforms keep your agents, your telemetry and your operating data on their runtime. Leaving means a migration you keep putting off.
Open-source frameworks hand you a toolkit. They run agents, and the rest is yours to build: cost caps, health checks, and a human approval step that does not exist out of the box.
So teams pick a lane. They pay either in vendor dependency or in the quarter of plumbing it takes to make a framework safe to run.
A runtime that treats an agent run like production.
- The agent registry is the single record of which agents exist and how each one is configured.
- Output is structured and checked with Zod at every domain boundary, so a malformed model response throws an error.
- The runtime enforces spend limits per agent and per run, so an overspending agent stops before the cost reaches your bill.
- Every agent reports its health, so a model that starts degrading shows on the dashboard while it is happening.
- By default an outbound action stops until a person approves it. Agents read and reason on their own, but they need that approval to act.
- The dashboard is the control plane. It gives you a read-only view of what the runtime is doing, and there is no chatbot layered on top.
# the runtime runs on your infrastructure $ tar xzf apg.tar.gz $ cd apg && docker compose up -d APG runtime on http://localhost:8080 · registry empty · inference: sovereign
A run reads, reasons, proposes and waits at the gate.
A run validates its input deterministically, reasons with the model only where it needs to, checks the cost cap and health, and stops for a person before any outbound action.
If you run the sovereign tier, Solutions Factory takes no inference margin. One config edit moves an agent to your own GPU.
$ apg run lead-intake --input ./lead.json [deterministic] input validated · schema ok [inference: byok] reasoned · 1,240 tok · $0.0041 itemized [guard] cost 0.0041 / 0.50 cap · health ok [propose] outbound reply drafted, awaiting operator confirm [operator] approved [deterministic] output written · zod-validated run ok · inference billed per token, itemized # one config edit sends inference to your own GPU, with no SF margin $ apg config set inference.tier sovereign
An agent earns its production tag before a client meets it.
The name describes the process. Every agent that reaches a customer started as an unproven entry in the registry.
Registry-bound
An agent exists because it is declared in the registry, with its inputs, outputs, tools and cost cap written down. Nothing runs off a prompt someone pasted in.
Proven on fixtures
It runs against recorded cases until its output validates every time. A run that returns the wrong shape counts as a failure and does not get retried.
Tagged for production
Only then does it get the tag that lets it touch live data. The tag is revocable the moment its numbers drift.
Three layers of tenant isolation
Every run carries a tenant, and the tenant is enforced three times. At the database, each tenant's data sits in its own schema. In the service layer, a query without a tenant scope will not execute. At the runtime boundary, an agent is handed only the context of the tenant it was invoked for.
One layer would be a policy. With three, crossing tenants means defeating the database, the service layer and the runtime in the same request.
Model choice is a configuration line
The model an agent uses is a field in its registry entry. It is not a dependency compiled into the agent. Moving one agent from a hosted model to a local open-weights model is an edit and a redeploy. Moving all of them is the same edit repeated.
That matters on the day a provider changes its terms, raises a price or removes a model. Teams whose agents were built against an SDK spend that day rewriting. Teams on APG spend it editing configuration.
Three tiers, and one config line moves you between them.
Tier 1, SF managed
When it opens, inference will route through Solutions Factory's model proxy, metered per token and itemized like a utility bill. Until then, start on Tier 2 with your own key.
Tier 2, BYOK
Bring your own model key and bill your model provider directly. Solutions Factory charges software and support only.
Tier 3, sovereign
Self-host a local model on your own GPU. There is no inference bill from us and none from a model provider, and you pay for the hardware and the electricity. This tier is for businesses with the strictest privacy needs.
Software fee plus the inference you use.
We license the runtime for a software fee. You self-host it on your hardware, or we manage it for you per workspace. Inference is separate and itemized. You pay your model provider directly at Tier 2. At Tier 3 you pay neither of us and run the model on your own GPU. Once Tier 1 opens, you pay Solutions Factory per token.
Serious teams run the runtime itself.
“AI agent” is mostly branding. The teams doing real work want the runtime underneath. They want to choose the model, cap the cost, see every agent's health, trust the registry and put a gate in front of anything that acts.
When you self-host APG, none of that depends on a vendor staying in business or holding your operating data. Inference stays a utility you can move from metered to sovereign.
For the operator evaluating the runtime.
The technical fact sheet, in one place.
- Output discipline
- Structured JSON with Zod validation at every domain boundary.
- Inference
- BYOK, a hosted model you choose (Tier 2); a self-hosted local model (Tier 3); a hosted model via SF (Tier 1) coming soon. Switching is a config edit.
- Reliability
- Per-agent and per-run cost caps, health observability, deterministic-first execution.
- Human-in-the-loop
- An approval gate on outbound actions. Agents read and reason freely and need approval to act.
- Control plane
- Read-only observability dashboard; the agent registry is the single source of truth.
- Deployment
- Self-hosted on your own infrastructure; Docker and docker-compose.
- Status
- Runtime engine live, multi-agent orchestration running
- Anchor metric
- Successful agent runs per dollar of inference.
How APG differs from the two usual routes.
Hosted agent platforms and open-source agent frameworks are where teams usually start. The table compares APG with the category and names no product.
| Capability | APG | Hosted agent platform | Open-source framework |
|---|---|---|---|
| Where it runs | Self-host or managed | The vendor's cloud | Your infrastructure |
| Changing the model | A config edit | Usually a code change | A code change |
| Cost caps | Enforced by the runtime | Vary by platform | You build them |
| Human approval gate | Built in | Varies by platform | You build it |
| Your data and runtime | Stay on your machines | Live on the vendor's runtime | Stay on your machines |
Where deployments stand today.
APG runs the agents behind our own CRM and Drengur, and our own company runs on them. We name customer deployments here once they are live and the operators agree to be referenced.
Inference: BYOK (Tier 2), sovereign on your own GPU (Tier 3), SF managed (Tier 1, metered and itemized, coming soon). See Infrastructure.
Run an agent on your own runtime.
Follow the quickstart to stand up APG and your first agent, or tell us about a managed deployment.