AI Agents
Agents that act inside your perimeter, on a leash you hold.
An assistant answers; an agent does: files the transaction, drafts and routes the document, chases the exception across three systems. NetRay deploys agentic systems on-prem with the governance that makes them deployable: tool allowlists, approval gates, and a flight recorder for every action.
The governance-first architecture
The reason most enterprises haven't deployed agents is not capability; it is the nightmare of an ungoverned process with system access. Our architecture answers that fear structurally: agents can only invoke tools on an explicit allowlist, destructive or high-value actions pause at approval gates for a named human, and every step (every prompt, tool call, and result) lands in a flight recorder your auditors can replay.
Run on-prem, the whole loop stays inside your perimeter: the model, the tools, the data the agent touches, and the logs. That is what makes agentic automation compatible with the same compliance regimes as the rest of our on-prem practice.
Where agents earn their keep first
The high-ROI starting points are the cross-system chores your best people hate:
- ERP exception chasing: stuck orders, mismatched receipts, MRP messages triaged and resolved-or-escalated (our home turf: SyteLine, LN, M3, NetSuite)
- Document pipelines: intake, extraction, validation, and filing with human review at the gate
- Quality and maintenance workflows: from finding through disposition with the trail intact
- Integration glue: the swivel-chair work between systems that never justified a formal integration project
Eat-your-own-cooking credibility
NetRay's software factory runs on 105+ agents that assemble, test, and ship enterprise software under human review gates. The governance patterns we deploy for clients (allowlists, gates, flight recording, staged autonomy) are the ones we run our own company on. We are not selling a whitepaper architecture; we are selling our production one.
Staged autonomy, earned not assumed
Every agent starts in recommend-only mode: it proposes, humans approve, the flight recorder accumulates evidence. Autonomy expands per action type as the evidence supports it, and the gate list is always yours to tighten. Teams that follow this ladder end up trusting their agents for exactly the right reasons; teams that skip it end up in the news.
Straight answers
What can an agent actually touch in our systems?
Only what the allowlist grants: specific API endpoints, specific transactions, specific document stores, each scoped and credentialed individually. There is no general system access; capability is assembled tool by tool, and revoked the same way.
What happens when an agent gets something wrong?
The flight recorder shows exactly what it saw, decided, and did, which turns incidents into fixable engineering instead of mysteries. Approval gates keep wrong actions from becoming irreversible in the first place for anything consequential, and rollback paths are part of each tool integration.
Do agents require frontier models?
No; well-scoped agents run beautifully on mid-size open models, with the planner sometimes benefiting from a larger model. On-prem portfolios (small executors, mid planner) handle most enterprise agent workloads entirely inside the building.
How is this different from RPA?
RPA replays brittle click-scripts; agents pursue outcomes and handle variation, reading context and choosing tools. The practical difference: process changes that break RPA bots are absorbed by agents, and the flight recorder documents judgment, not just keystrokes. We integrate with existing RPA where it already works.
Pick the chore. We'll build the agent.
Bring the cross-system process your team dreads. We'll design the agent, the allowlist, and the gates, and show you the flight recorder on day one.
Scope an agent deploymentFree AI workshops available. A founder reads every message.