bitpro가 원문에서 글자만 모은 내용이에요. 표·그림·수식은 빠지거나 깨질 수 있어요. 전체 12쪽 중 3쪽
Axora is GoPlus' enterprise AI security product line. It is the Security for AI direction of the GoPlus strategy, built around one idea: **the visible boundary**. Every AI access, every agent action, and every security claim should be visible, provable, controllable, and auditable.
AI agents are no longer passive assistants. They can browse, write code, read files, call MCP tools, execute shell commands, manage credentials, deploy applications, and trigger Web3 transactions. This creates a new security challenge: the most important security decision often happens at runtime, immediately before an agent performs a high-impact action, and the information that shapes that decision flows through models, data sources, and tools that may be untrusted.
Axora addresses this through three products built around three control points:
| Product | Control point | Governs | Outcome |
| ------------------------------------------------------------------------------------- | ------------- | --------------------------------------------------------- | --------------------------------------------------------------------------- |
| [**Axora Router**](/goplus-network/ai-agent-security/agentguard/axora-router) | Access | Users, applications, models, and data flows | One controlled entry point for enterprise AI, with information-flow control |
| [**Axora AgentGuard**](/goplus-network/ai-agent-security/agentguard/axora-agentguard) | Action | Agents, tools, MCP servers, RAG, secrets, and permissions | Asset visibility, runtime defense, and governance |
| [**Axora Arena**](/goplus-network/ai-agent-security/agentguard/axora-arena) | Validation | AI systems, agents, and connected workflows | Adversarial validation, evidence, remediation, and retest |
{% hint style="info" %}
**Router manages access. AgentGuard protects action. Arena validates the boundary.**
{% endhint %}
The three products share one control plane. Policies are authored once and enforced across Router and AgentGuard. Findings from Arena tune both. Every decision, from a routed prompt to a blocked shell command to a red-team result, lands in a common evidence chain.
## Why AI Agents Need Runtime Security
Traditional AI safety focuses heavily on prompts and model outputs. Agent security requires more. Once an agent can use tools, the attack surface expands from text generation to execution.
A modern coding or operations agent can read the filesystem, run shell commands, call internal APIs, reach the public internet, touch credentials and cloud keys, and increasingly sign blockchain transactions. It does all of this at the speed of automation, with no built-in judgment about safety. A single poisoned skill, a prompt-injection payload buried in a web page, or one over-broad MCP tool is enough to leak secrets, wipe a disk, or drain a wallet.
Enterprises adopting AI face three questions at once:
* **Can you see it?** Which agents are running, who owns them, and which models, MCP servers, RAG stores, tools, secrets, and permissions they can reach.
* **Has it been validated?** Whether instruction hierarchy, tool approvals, RAG grounding, and non-deterministic behavior actually hold up under attack.
* **Can you control it?** Whether a dangerous action can be warned on, approved, or blocked, and whether there is a complete record afterward.
These are not three separate problems. They are three breaks in the same chain, and Axora is designed to close them as one loop.
## Security as Machine-Native Consumption
Autonomous systems also change the economics of security. Traditional security is applied at deployment or through periodic review, and it is purchased in fixed units such as seats or annual licenses.
Agents may require security decisions continuously. Every model call through Router, every tool invocation evaluated by AgentGuard, every skill scan, every daily patrol, and every adversarial scenario in Arena is a discrete, metered security service. Usage therefore scales with agent activity rather than with the number of human users or enterprise seats.
This is why Axora is the product line where the GoPlus security service economy is most visible. As agents take more actions, Axora evaluates more of them, and that consumption is intended to settle in $GPS.
## Architecture Principles
All three Axora products follow the same principles.
* **Local-first.** Guards and data-plane inspection run where the agent or application runs. Source code, raw prompts, and secrets can stay inside the customer's environment, and guards keep working offline.
* **Evidence minimization.** The platform records references, findings, and decisions rather than raw credentials or customer data. Raw-content logging is explicitly configurable with retention and access controls.
* **Audited end-to-end.** Scope changes, policy publication, validation runs, approvals, and exports each produce a traceable event, and every decision records the policy version that made it.
* **Deny-first for consequential actions.** High-consequence agent actions and active validation do not proceed unless authorization, isolation, rate limits, and emergency-stop conditions are satisfied.
* **Control plane separated from data plane.** Organizations, identities, policies, and dashboards are managed centrally, while runtime inspection and enforcement can run in Axora Cloud, a dedicated tenant, or the customer's own VPC or on-premise environment.
## Axora and $GPS
Axora security decisions are security services consumed from the GoPlus Security Network. GoPlus intends for $GPS to be the settlement unit for that consumption:
* **Metered agent security:** Router information-flow decisions, AgentGuard action evaluations, deep scans, and daily patrols, and Arena adversarial scenarios are metered. Individual, team, and enterprise plans are priced in security-service units that settle in $GPS.
* **Supported payment models:** Teams and enterprises may pay in fiat or stablecoins. GoPlus intends to route a defined share of that revenue into $GPS-denominated settlement on the network side, so that enterprise consumption contributes to $GPS demand regardless of the customer's payment rail.
* **Agent-originated consumption:** When Axora protects agents that also consume GoPlus Intelligence through the AI Agent Security API, both the runtime decision and the underlying intelligence call are part of the same $GPS-settled service economy.
* **Supply side:** The detectors, advisories, and threat intelligence Axora relies on are produced by data contributors and Security Compute Layer operators who stake and earn $GPS.
This is what allows $GPS utility to scale with security-service consumption rather than relying solely on secondary-market activity.
## Axora in the GoPlus Security Layer
Axora is the agent access, action, and validation layer of GoPlus.
It complements the rest of the GoPlus ecosystem:
* **SafuSkill** secures the software supply chain through which agent skills and code are distributed, before they reach the Axora-protected environment.
* **GoPlus Intelligence** provides risk models, detection capabilities, and threat intelligence, including Web3-native coverage of wallet, contract, and signing risk.
* **DeepScan** continuously assesses the smart contracts and applications agents may interact with.
* **GoPlus Security Network** enables open security data, distributed security compute, and verifiable security signals.
* **GoPlus Web3 Security** protects transactions, signatures, approvals, tokens, dApps, wallets, RPCs, and chains.
This connection is important because AI agents will increasingly operate Web3 wallets, manage on-chain assets, interact with dApps, deploy contracts, analyze tokens, and execute transactions. Axora protects access and action before they reach Web3, while GoPlus Web3 Security protects the on-chain execution path itself.
## Conclusion
Axora makes the AI security boundary visible. Router manages access, AgentGuard protects action, and Arena validates that the boundary holds. Together they give enterprises control over how AI is used and what agents can do, create an auditable foundation for safe AI automation, and turn each security decision into a metered service settled in $GPS.
# Axora Router
## Overview
Axora Router is an enterprise AI security gateway. It consolidates external AI access into one controlled entry point and enforces organization-aware identity and policy on every AI request and response.
One line: one organized entry point for enterprise AI access, governed by identity, group policy, and audit.
Router helps enterprises adopt large language models safely without slowing teams down. It centralizes AI access behind a single gateway, assigns each employee or system an identity, organizes identities into groups, and applies group-level security policies to every prompt, response, and, optionally, tool-connected data flow. Policies can allow, observe, tokenize or redact, block, route to a private model, or require approval, while generating audit evidence and compliance mapping.
## The Problem Router Solves
Employees, business systems, and AI applications inside an enterprise typically connect to different models through personal accounts, shared API keys, or independent integrations. Three problems follow directly:
* **AI access is fragmented and unowned.** It is hard to confirm who is using which model, and impossible to enforce consistent rules.
* **Sensitive data leaks are inevitable without a control point.** Once customer data, credentials, or regulated information enters a prompt, a RAG context, an attachment, or a tool output, it can be sent to an external model unless an enforcement point exists.
* **Guardrails are inconsistent across vendors and apps.** Teams rebuild the same redaction, blocklists, approvals, and logging in every application, and the result is still inconsistent and hard to audit.
A network proxy or generic API gateway does not solve this. It does not understand AI context, cannot tell a prompt from a response from a retrieved document, and provides no policy versioning, testing, or compliance evidence. Router is built specifically for AI information flows.
## How Router Works
Router sits between users or applications and model services. It establishes access relationships through four core objects:
| Object | Role |
| ---------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **User** | An identity for an employee, system, or application that accesses AI through Router, with its own token or API key |
| **Group** | An organizational unit such as a department, project, role, or system. Every user belongs to at least one group. Groups carry channel authorization and security policy |
| **Channel** | A connection between Router and a specific LLM or provider, including private and on-premise models |
| **Group Policy** | The policy bundle bound to a group and enforced on every information flow within it |
A request entering Router passes through identity recognition, channel authorization, an outbound check before the request leaves the enterprise, the model call, an inbound check when the response returns, and an audit record. Every transaction receives a risk context that includes who initiated it, which group it belongs to, whether it is input or output, the destination model and region, and the business purpose, and passes through deterministic and model-based detection before an enforcement decision.
Router reasons about content by type, including user prompts, system prompts, retrieved RAG context, model responses, and, where tool integration is enabled, tool arguments and tool results. Retrieved and tool-returned content is treated as untrusted by default.
## Gateway Actions
Router policies resolve to one of six outcomes:
| Action | Meaning |
| -------------------------- | ----------------------------------------------------------------------------------------------------------- |
| **ALLOW** | Pass through |
| **OBSERVE AND ALLOW** | Pass through while recording risk evidence or raising an alert |
| **TOKENIZE AND ALLOW** | Redact or tokenize sensitive parts before passing through, with reversible restoration on the response path |
| **BLOCK** | Stop the request or response |
| **ROUTE TO PRIVATE MODEL** | Do not send to the external model; route to an approved internal model instead |
| **REQUIRE APPROVAL** | Pause the flow for a designated approver |
This range matters for adoption. Enterprises can start with observe-first policies to generate a risk picture, then tighten enforcement only where evidence shows it is needed, and reserve approvals for genuinely consequential flows.
## Core Capabilities
### Organization-Aware Access and Quota Governance
A centralized entry point for external model access, with an identity per employee or system, group-based management, and quota allocation at team or user level. Scattered personal accounts, shared API keys, and per-application integrations are consolidated so that it is always clear who can access which models.
### Sensitive Data Definition and Detection
Built-in detection for personally identifiable information, credentials, and secrets, plus custom dictionaries, regular expressions, and document fingerprinting for customer names, project codenames, source code, internal identifiers, and other organization-defined categories. Sensitive-data definitions can be executed within the customer's environment so that raw definitions are never exported.
### Context-Aware Policy Enforcement
Policies evaluate both what was found and the context around it: who initiated the flow, which group, the destination provider and region, the content type, and the purpose. The same string can be treated differently depending on user, group, application, and destination, and separate rules can apply to input, output, RAG context, and tool-connected flows.
### PolicyOps: Versioning, Testing, and Rollback
Policies are versioned with diffs, covered by unit tests that pair content and context with an expected action, and published through a gated lifecycle from draft to test to review to publish. A policy simulator can replay sanitized historical traffic against a draft to estimate how many requests would be allowed, transformed, routed, or blocked before rollout, and any policy can be rolled back to a known-good version.
### Monitoring, Audit Evidence, and Reporting
Administrators can search and filter information flows by time, user, group, model, content type, severity, policy hit, and action. A trace shows the data flow, policy judgement, and transformation at each step, so that every security decision can be reviewed. Alerts can be delivered through email, chat, or webhook, and events can be exported to SIEM and SOC tooling.
### Compliance Mapping
Policy controls can be mapped to regulatory and industry requirements including GDPR, HIPAA, PCI DSS, SOC 2, ISO 27001, ISO 42001, and the NIST AI Risk Management Framework. Mapping is framed as control evidence, linking each requirement to a control, a policy, evidence, an owner, and a review date, rather than as automatic certification.
### Model Governance and Intelligent Routing
Security and routing share one policy engine. Router maintains an approved provider and model catalog with allow and deny policy by user, group, and application, data-residency and region restrictions, and private-model-only rules for classified data. Routing decisions can weigh data classification, provider policy, region, quality, latency, cost, and availability, with provider health monitoring, failover, circuit breakers, rate limits, and per-group budgets.
### Agent, MCP, and Tool Security
As enterprises move from chat to agents, the security boundary moves from what the model can say to what the agent can do. Router extends its policy model to agent and tool identities, with tool allowlists by group and application, function-level permissions, separation of read, write, and destructive actions, inspection of tool arguments before execution and tool results after, and human approval for consequential actions such as external messaging, file deletion, production changes, financial transactions, and high-volume data export. This is the point where Router hands off to Axora AgentGuard, which enforces the same decisions at the agent runtime.
## Four Trust Boundaries
Router protects the full AI interaction lifecycle across four boundaries:
1. **User or application to AI: input and data security.** Prevent sensitive-data and credential leakage, unauthorized model access, and unsafe requests before data is sent to a model.
2. **External content or RAG to AI: untrusted content security.** Detect indirect prompt injection, poisoned retrieved content, unsafe files, and untrusted instructions before they enter the AI context.
3. **AI to user or application: output security.** Inspect responses for sensitive disclosure, prohibited content, insecure code, malicious links or packages, and policy violations before they reach users or downstream systems.
4. **AI or agent to tool, MCP, or API: action security.** Control agent permissions, inspect tool calls and results, constrain high-risk actions, and require human approval where needed.
## Deployment
Enterprises choose where enforcement runs. Axora Cloud offers the fastest deployment. A dedicated single-tenant data plane provides stronger isolation. A customer VPC or on-premise data plane keeps raw prompts, sensitive-data dictionaries, and provider credentials inside the customer's trust boundary while policy and management remain centralized. Integration starts with an OpenAI-compatible endpoint as the lowest-friction migration path, with enterprise identity through OIDC, SAML, and SCIM.
## Router and $GPS
Router decisions are metered security services. Every information-flow scan, policy decision, and routing decision is a discrete unit of security consumption, and because applications and agents pass information through Router continuously, consumption scales with AI usage rather than with seats.
Router plans are priced in security-service units that settle in $GPS. Where customers pay in fiat or stablecoins, GoPlus intends to route a defined share of that revenue into $GPS-denominated settlement on the network side.
## Who Router Is For
* **Security, AppSec, and product security teams** that need to prevent sensitive-data egress and unsafe content ingress and to produce audit-ready controls.
* **AI and ML platform teams** standardizing access across multiple providers and reusing guardrails.
* **Enterprise IT** organizing identities, access, quotas, and vendor usage across the company.
* **Compliance and risk functions** in regulated industries aligning AI controls to regulatory requirements.
## Conclusion
Axora Router manages access. It turns fragmented, unowned AI usage into a single governed entry point where identity, group policy, sensitive-data controls, routing, and audit apply to every request and response. It is the first control point in the Axora boundary, and every decision it makes is a metered service settled in $GPS.
# Axora AgentGuard
## Overview
Axora AgentGuard is the end-to-end security platform for AI agents, from the developer laptop to production fleets. It continuously discovers agents and their dependencies, validates real attack paths, and warns on, approves, or blocks agent actions at the moment they are executed.
AgentGuard pairs offensive validation, red-teaming agents before attackers do, with runtime defense, stopping malicious actions the moment they happen, and binds the two into a single loop under one control plane with enterprise-grade governance. It is built by GoPlus, the team behind the most widely used Web3 security APIs.
## The P프로젝트로 돌아가기