Sidetrade IQ is the version of our own platform that we run on ourselves. It sits on the same framework, the same models and the same policy controls as the Aimie IQ, the engagement and orchestration layer accessible in natural language, our customers get, and Sidetraders use it every day for their own work. This post covers why we built it that way, what SAFE, the framework under both, actually does, and why I think running intelligence inside first is how it scales out.
We have spent more than ten years building the Sidetrade Data Lake, our record of live B2B payment behavior across the client base since 2015. The next step is turning that record into intelligence that works alongside finance teams. Agents that chase, reconcile, brief and escalate, grounded in real Order-to-Cash (O2C) context and running on infrastructure we control.
One framework, three products
Three AI-native products sit on one foundation. Aimie Agents are ready to deploy for the repeatable work of collections, the first being the Aimie Cash Collection Agent. Customer Agents are the ones a customer or a partner builds in Agent Builder Studio, composed from skills and policies and published to the Agent Registry. Aimie IQ is the engagement and orchestration layer above both; one conversation, in natural language, that reaches skills, agents, and actions.
SAFE (the Sidetrade Agentic Framework for Enterprise) is the single runtime under all three. That is what lets a skill built for one show up in another, and it is why the controls are the same for every agent regardless of who built it.
SAFE, the framework every agent runs on
SAFE has two layers. Agent Connect handles everything that surrounds an agent. It holds an Agent Registry with a single declarative configuration model, an Event Router that dispatches O2C events to the right agents, the HTTP surface behind the Aimie IQ conversation, and a Skills Registry of reusable O2C skills that agents share and invoke.
The Agent Harness governs the agent at runtime. It assembles context from O2C data, runs the reasoning on our own models, selects the right tool among O2C actions, enforces policy with deterministic escalation, and keeps the audit trail and the memory so that each run improves the next. Pydantic AI and Temporal sit underneath.
An agent that touches receivables, disputes and customer credit has to be connected to the right data, act within policy, escalate deterministically when it should not decide alone, leave a complete audit trail, and get better from one run to the next. When I have seen agentic deployments go wrong, it was on one of those five points rather than on the quality of the model, so enterprise readiness is built into SAFE rather than added afterward. Every agent action is logged end to end. Policy controls define what an agent can execute autonomously, when a human is required, and who receives the escalation. Before an agent is published to the Agent Registry it is validated against the OWASP Agentic Top 10.
The other thing SAFE settles is where all of this runs. Every agent built on it runs on Sidetrade's own models, in our own data centers, on GPUs we own, producing our own tokens. That is what sovereign means here, and it comes down to three controls. Control of the data. No prompt, document or customer record is sent to a public model provider or a hyperscaler, because the stack has no need for it. Control of the models. Open-weight foundations fine-tuned for O2C, alongside our own predictive models for payment behavior, buyer risk and next best collection action, and as open-weight models advance we can adopt them with no change to a customer's data exposure. Control of the economics. Compute we own has a cost we know, which is why our customers have no exposure to third-party per-million-token pricing.
Not every task in O2C calls for a language model, and few call for a frontier one. Predicting a payment date or scoring buyer risk is the work of the predictive models. Routing an event or applying a policy is deterministic code. Only the tasks that need language, reasoning over a complex dispute or drafting a message in a customer's tone, reach the O2C fine-tuned LLM. Keeping simple tasks away from expensive reasoning is also what makes the cost of a task fall as the system learns, because skills and memory accumulate with every run and an agent does not rediscover the same knowledge twice.
Layers it takes to run an enterprise agent, all of them owned: private data centers, GPU compute, fine-tuned open-weight models, the agent framework, cross-network domain data.
Layers in SAFE. Agent Connect around the agent, the Agent Harness at runtime.
Prompts, documents or customer records sent to a public model provider or a hyperscaler.
Two IQs, one platform
The same platform runs in two places. Aimie IQ is the customer deployment. SAFE is already in production under the Aimie Cash Collection Agent at multinationals including Securitas, Accor and Sodexo, and Aimie IQ and Agent Builder Studio roll out to beta customers on the timetable we announced in July. Sidetrade IQ is the internal deployment, where our teams and business power users build skills and agents and use the conversation for their own work, on the same stack and under the same controls.
What running it on ourselves buys
People sometimes ask why a company would put its own teams on a product before its customers get it. My answer is that it is the most honest testing we have ever done, because the people finding the rough edges are the people who can fix them, and they sit in the same building.
Our teams build agents on SAFE every day, on the same stack, with the same policy controls and the same observability our customers get. When a control gets in the way of real work, we find out before a customer does.
A skill built for a Sidetrader's job is composed from the same O2C skills, policies and connectors as a customer's. The ones that earn their place are promoted into the product rather than rebuilt.
Business users outside R&D build in Agent Builder Studio too. What they build shows us what a customer's power user will do with it before we have to guess.
Salesforce, Marketo, Oracle and the product knowledge base are reached through connectors, so the work happens where the work already is.
Combined with AI-driven development, in my ten years at Sidetrade I have never seen a project move this fast.
Scaling intelligence from the inside out
The parts of O2C intelligence do not grow on the same clock. Skills and memory scale with the number of people using the platform. Agents scale with the product and the customers running them. Knowledge and the Sidetrade Data Lake scale as customers are onboarded. Fine-tuned models scale with R&D. Because all of them sit on one framework, growth in any one of them compounds across the others instead of forking into a second system to maintain.
Every skill we build for ourselves is one step closer to a skill for our customers.
Every agent run, every skill created in Agent Builder Studio and every piece of user feedback flows back into one shared body of O2C intelligence consisting of skills, agents, memory, and knowledge. The loop starts with Sidetraders because we are the first users, and it turns fastest where the builders and the users are the same people. It ends with customers, each of whom benefits from the intelligence of all the others while their own data stays isolated. Memory, playbooks, feedback, what worked and what did not: none of it leaves our four walls, and all of it is there for the next run.
-900x386.png)
