Solutions Factory · APG
The agent runtime appliance for self-hosted business software.
APG — Agents Proving Ground — is the runtime your software runs agents on. Registry-bound, cost-ceilinged, observable, and gated on operator confirmation for anything that leaves the building. CRM and DMC run on it; so can your own apps. Switching from Anthropic to your own model is a config edit, not a rewrite.
The problem
Agent runtimes ask you to choose lock-in or chaos.
The hosted platforms lock you in. LangSmith, LangGraph Cloud, AutoGPT cloud — your agents, your telemetry, and your operating data live on the vendor's runtime, and leaving means a migration you keep postponing.
The open-source frameworks hand you a toolkit and wish you luck. They run agents, but operator-grade reliability is yours to build: cost ceilings, health observability, and a human-in-the-loop discipline that does not exist out of the box.
So teams pick a lane and pay for it later, either in vendor dependency or in the quarter of plumbing it takes to make an open framework safe to run in production.
What it does
A runtime that treats an agent run like production.
- Registry-bound agents. The agent registry is the single source of truth for what exists and how it is configured.
- Structured output, validated. Zod validation at every domain boundary, so a malformed model response fails loud, not silent.
- Cost ceilings. Per-agent and per-run spend limits the runtime enforces, before the bill, not after.
- Health observability. Every agent reports health; the runtime sees a bad model day before your customer does.
- Operator-confirm gates. Outbound actions stop for human approval by default, per ADR 0021. Read and reason freely; act on a gate.
- Dashboard as control plane. A read-only observability surface over the runtime, not a chatbot wrapper.
Self-host the runtime
# 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: sf-default
See an agent run
Read, reason, propose, gate.
An APG run validates its input deterministically, reasons with the model only where needed, checks the cost ceiling and health, and stops for operator confirmation before any outbound action. Inference is metered and itemized — or free of SF margin if you run it sovereign.
$ apg run lead-intake --input ./lead.json [deterministic] input validated · schema ok [inference: anthropic via SF] reasoned · 1,240 tok · $0.0041 itemized [guard] cost 0.0041 / 0.50 ceiling · health ok [propose] outbound reply drafted — awaiting operator confirm [operator] approved [deterministic] output written · zod-validated run ok · inference billed per token, itemized # route inference to your own GPU instead — one config edit, zero SF margin $ apg config set inference.tier sovereign
Why it is called a proving ground
An agent earns its production tag before a client meets it.
The name is the process. Every agent that ends up in front of a customer started as an unproven entry in the registry and had to earn its way out.
Registry-bound
An agent exists because it is declared in the registry, with its inputs, outputs, tools and cost ceiling 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 is a failure, not a retry.
Tagged for production
Only then does it get the tag that lets it touch live data, and 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 over: at the database, where each tenant's data sits in its own schema; in the service layer, where a query without a tenant scope will not execute; and at the runtime boundary, where an agent is handed only the context of the tenant it was invoked for.
One layer would be a policy. Three is a design where crossing tenants requires defeating the database, the service layer and the runtime in the same request.
Model choice is a configuration line
The model a given agent uses is a field in its registry entry, not a dependency compiled into it. Moving one agent from a hosted frontier 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 a specific day: the one when a provider changes its terms, raises a price, or has a model removed from under it. Teams whose agents were built against an SDK spend that day rewriting. Teams on APG spend it editing configuration.
Inference, your way
Three tiers. One config line between them.
Tier 1 — SF default
Inference routes through Solutions Factory's Anthropic proxy, metered per token and itemized like a utility bill. The path of least friction.
Tier 2 — BYOK
Bring your own Anthropic key and bill Anthropic directly. Solutions Factory charges software and support only.
Tier 3 — Sovereign
Self-host a local model on your own GPU. No inference cost, no SF margin. For the highest-privacy verticals.
What it costs
Software fee plus the inference you use.
The runtime is licensed for a flat software fee, self-hosted on your hardware or managed by us per workspace. Inference is separate and itemised: pay Solutions Factory per token at Tier 1, pay Anthropic directly at Tier 2, or pay nobody for inference at Tier 3 on your own GPU.
Why self-hosted, by you
The serious teams run the runtime, not a wrapper.
"AI agent" is mostly branding. The teams doing real work want the runtime underneath: model choice they control, costs they cap, health they can see, a registry that is the truth, and a gate before anything acts. Self-hosting APG means none of that depends on a vendor staying in business or holding your operating data — while inference stays a utility you can dial from metered to sovereign.
Technical fact sheet
For the operator evaluating the runtime.
- Output discipline
- Structured JSON with Zod validation at every domain boundary.
- Inference
- Anthropic via SF (Tier 1) by default; BYOK Anthropic (Tier 2); self-hosted ollama (Tier 3). Switching is a config edit.
- Reliability
- Per-agent and per-run cost ceilings, health observability, deterministic-first execution.
- Human-in-the-loop
- Operator-confirm gates on outbound actions, per ADR 0021. Read and reason freely; act on a gate.
- 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; sidebar surfaces audited; multi-agent orchestration in production.
- Anchor metric
- Successful agent runs per dollar of inference.
How it compares
Against LangGraph Cloud and LangSmith.
| Capability | APG | LangGraph Cloud | LangSmith |
|---|---|---|---|
| Hosting | Self-host or managed | Vendor cloud | Vendor cloud |
| Inference choice | Config edit (SF / BYOK / sovereign) | Code change | n/a (observability) |
| Cost ceilings | Enforced by runtime | Build it yourself | Observe after the fact |
| Operator-confirm gate | Built in (ADR 0021) | Build it yourself | No |
| Control plane | Registry-bound dashboard | Code | Dashboard |
| Lock-in | None | Vendor cloud | Vendor cloud |
Reference deployments
Honest about the stage.
APG runs the agents behind Solutions Factory CRM and DMC in production today. External operator deployments are landing; we will name them here as they go live and agree to be referenced.
Get started
Run an agent on your own runtime.
Follow the quickstart to stand up APG and your first agent. Or book a call about a managed deployment.