Forti - The Enterprise Agent Guardian

A governed enterprise agent fleet that detects operational threats, reasons across institutional signals, and stops for human authorization before consequential action.

Comment

Inspiration

The most dangerous moment in an agentic system may be the moment when the AI is right.

Forti is built for the moment when AI moves from insight to impact.

AI is moving from answering questions to participating in real operational workflows. That creates a bigger problem than whether an AI can produce a good answer: what happens when the answer is right, the stakes are high, and the system is capable of acting on it?

Across industries, critical signals are scattered across databases, APIs, security telemetry, business systems, and operational workflows. An individual anomaly may look harmless. When an agent can continuously analyze these signals together, it can detect developing operational threats earlier, assess their potential impact, and help organizations respond before they become larger incidents.

This is not a niche problem. As organizations give AI agents access to increasingly consequential systems, the same challenge appears everywhere:

How do you gain the speed and scale of machine intelligence without giving up human accountability?

We didn't want to build another dashboard that leaves the operator to manually correlate the evidence, or another chatbot that produces an answer and stops there.

We built Forti, an agentic security and operational intelligence platform designed around one fundamental principle:

The AI detects, analyzes, and recommends. The human governs consequential action.

That principle isn't just a statement in Forti's documentation. It is built into the demonstrated workflow: Forti detects emerging threats, reasons across the available signals, assesses potential consequences, produces a recommendation, explains the trade-offs, and brings the human operator into the decision before a consequential protective action can proceed.

The result is a different model for enterprise AI:

AI does the continuous sensing and complex analysis; people retain authority where the consequences are real.

What it does

Forti combines AI-powered threat detection and operational intelligence with human-governed decision-making.

Forti is not a "stop tool." The human authorization gate is one part of a larger security architecture that continuously moves from detection to analysis to response while preserving a deliberate human decision point for consequential actions.

The core workflow is:

Detect → Analyze → Assess → Recommend → Human Decision → Protect → Verify

Forti uses Google Gemini 3.7 Flash to analyze operational signals, identify meaningful patterns, correlate evidence across domains, assess potential consequences, and generate a recommended response. The recommendation is presented to the human operator with the supporting analysis and trade-offs needed to make an informed decision.

Forti demonstrates this approach across multiple high-consequence operational domains:

  • Nonprofits & Philanthropy
  • Financial Services
  • Healthcare & Clinical Systems

Rather than simply showing an AI-generated answer, Forti lets the judge follow the complete security and operational decision path — from detection and analysis through human authorization, protected action, and verification — and then challenge it.

The Defining Moment: Human Authorization

One of the most important moments in the Forti demo occurs when the AI has reached a recommendation for a consequential action.

The agent stops.

Forti does not treat a confident AI recommendation as permission to act. The human operator reviews the recommendation and explicitly authorizes the consequential decision.

The authorization boundary is enforced by the application server rather than existing only as a visual UI state. Consequential actions require valid, session-bound authorization before the workflow can proceed.

This creates a clear boundary between:

What the AI recommends

and

What the organization authorizes.

This is a central product thesis:

AI-powered detection and action without unchecked agentic authority.

Forti's value is the balance:

Machine intelligence operates at machine speed. Human judgment remains in the loop where organizational risk, accountability, and consequence demand it.

Explore Forti

Forti is designed to be explored, not just watched. Judges can move from a guided demonstration into interactive testing and technical evidence review.

90-Second Demos

The guided walkthrough provides a fast way to experience Forti's governed agent lifecycle, from emerging signals and Gemini analysis through recommendation and the Stage 5 Human Authorization Gate.

The walkthrough is intentionally designed to make the most important behavior visible: the agent reaches the authorization boundary and waits for the human decision.

Chaos Sandbox

The Chaos Sandbox lets judges deliberately introduce operational disruptions and observe how Forti responds.

Judges can experiment with changing conditions, including adversarial scenarios, and observe how those changes affect the system's assessment and recommended response.

What-If Engine

The What-If experience lets judges explore the consequences of different decisions and compare potential outcomes before authorizing a protective action.

This makes the trade-off behind the recommendation visible rather than reducing the decision to a simple AI-generated verdict.

Forti Copilot

Forti Copilot provides an interactive way to question the system about the developing situation, its analysis, and the recommended response.

Executive Audit

After the decision workflow, the Executive Audit provides a structured view of the demonstrated operational decision chain — from the signals Forti observed through analysis, recommendation, human decision, and recorded outcome.

Together, these experiences let judges inspect Forti from multiple perspectives:

Watch it. Stress it. Question it. Audit it.

How we built it

Forti separates AI reasoning from decision authority.

Google Gemini provides the intelligence. Forti's application enforces the decision boundary.

The architecture was designed around the same requirements that emerge when AI agents become part of enterprise infrastructure: discovery, execution, persistent context, identity, policy enforcement, security controls, observability, and auditability.

1. Discovery & Lifecycle — Enterprise Agent Registry

Forti models institutional agents as a cataloged enterprise agent fleet rather than a single generic assistant.

The Agent Architecture Hub organizes approved agents across multiple operational domains and exposes their capabilities, version information, risk classifications, and scope boundaries.

This provides a central discovery model for enterprise-approved agents that can be understood, governed, and reused across departments and operational contexts.

2. Core Execution & State — Asynchronous Runtime & Secure Memory Bank

Forti uses a server-backed asynchronous lifecycle to move scenarios through the demonstrated operational stages:

Detect → Analyze → Explain → Recommend → Human Gate → Protect → Verify

Scenario state is retained through a session-scoped context model so the system can maintain operational state, signal history, and incident lineage associated with an active scenario.

Context is isolated by scenario session identifiers, preventing one scenario's operational context from being treated as another scenario's memory.

This provides the foundation for long-running asynchronous agent operations and secure persistent context rather than treating every interaction as an isolated chat request.

3. Security & Governance — Zero-Trust Identity, Agent Gateway & Model Armor

Forti treats consequential agent actions as security-sensitive operations.

Agent Identity / Zero Trust

Consequential authorization is bound to the active scenario session and validated server-side using an HMAC-SHA256 authorization signature. Forged, missing, altered, or incorrectly scoped authorization information is rejected.

Agent Gateway / Policy Enforcement

The Stage 5 Human Authorization Gate is enforced at the server boundary. A recommendation cannot simply transition into consequential execution because the client displays an approval button. The server validates the authorization context before allowing the protected action to proceed.

Model Armor / Inline Guardrails

Forti incorporates layered defenses for adversarial and unsafe inputs, including prompt-injection testing, strict validation of tool/action parameters, and redaction controls for sensitive simulated enterprise data before model processing.

Data Sovereignty & Compliance

The architecture separates cognitive reasoning from execution authority. Gemini provides analysis; the application server remains the enforcement boundary for consequential actions. Demonstrated enterprise scenarios use controlled/synthetic operational data rather than requiring access to a judge's production systems.

4. Telemetry & Observability — OpenTelemetry-Compatible Spans & Verifiable Hash Chains

Forti exposes an end-to-end agent execution and decision trace rather than claiming access to private model chain-of-thought.

Structured event spans capture operational information such as trace identifiers, timestamps, actor/agent role, event type, status, and latency.

Forti's audit layer also maintains a cryptographically chained audit record. Each record incorporates the previous hash together with the event and authorization context:

SHA256(previousHash + step + title + description + sessionId + authSignature)

The backend can independently verify the chain from root to tip, and the Security experience provides a tamper-detection demonstration.

The result is a traceable path from:

Signal → Analysis → Recommendation → Human Authorization → Execution → Verification

with model provenance and an auditable record of the demonstrated decision lifecycle.

Google Technologies

Forti uses the required Google technologies as functional parts of the system:

  • Google Gemini 3.7 Flash — AI reasoning, signal analysis, risk assessment, and recommendation generation
  • Google AI ecosystem / @google/genai TypeScript SDK — Gemini integration
  • Google Cloud Run — backend execution environment and application hosting

These technologies are not decorative integrations. Gemini performs the cognitive work; Google Cloud Run hosts the application boundary that governs how that intelligence participates in the operational workflow.

Challenges we ran into

The hardest part of building an agentic system wasn't getting an AI model to produce an intelligent answer.

It was deciding what should happen after the AI produces that answer.

As agents move closer to consequential enterprise systems, the challenge isn't simply making them more capable. It is creating an architecture where their capabilities can be used at scale without turning an AI recommendation into uncontrolled authority.

That led us to focus our engineering effort on the boundary between:

AI intelligence

and

human authority.

We challenged Forti's workflow with adversarial conditions including:

  • Unattended execution and autoplay edge cases
  • Protected-stage navigation attempts
  • Authorization information replay across sessions
  • Missing, malformed, or altered authorization signatures
  • Out-of-order stage transitions
  • Direct unauthorized API invocation
  • Cryptographic audit-chain mutation and tampering
  • Adversarial prompt-injection scenarios

We also wanted judges to be able to see this principle for themselves, which is why the Chaos Sandbox, What-If Engine, Security controls, and Executive Audit became part of the experience rather than remaining theoretical testing tools.

Another challenge was maintaining transparency around AI provenance. Forti distinguishes live Gemini-generated analysis from deterministic fallback behavior where applicable, so the system does not obscure which execution path produced an observed result.

Accomplishments that we're proud of

  • AI-powered detection and analysis. Forti uses Gemini 3.7 Flash to analyze operational signals, identify emerging threats, assess consequences, and formulate recommended responses.
  • A real human governance boundary. Forti visibly reaches a human authorization stage instead of silently continuing toward a consequential action.
  • Server-authoritative security. Consequential authorization is validated by the backend rather than relying only on frontend state.
  • An enterprise agent fleet model. Agents are cataloged across operational domains with defined capabilities, versions, risk classifications, and scope boundaries.
  • Asynchronous execution and persistent context. Forti maintains scenario state and isolated operational context across the agent lifecycle.
  • Zero-trust authorization. HMAC-SHA256 session-bound authorization protects consequential actions against forged, altered, or replayed authorization information.
  • Inline security controls. Prompt-injection defenses, structured action validation, and sensitive-data redaction address adversarial and unsafe agent inputs.
  • Observable agent execution. Structured, OpenTelemetry-compatible event spans expose the operational lifecycle without exposing private model chain-of-thought.
  • Verifiable auditability. A SHA-256 hash chain makes the demonstrated decision record tamper-evident and testable.
  • Interactive adversarial testing. Judges can inject faults, manipulate conditions, test authorization boundaries, and deliberately test audit integrity.
  • Cross-domain applicability. The same governed agentic architecture can be demonstrated across nonprofit, financial, and healthcare operational scenarios.

Most importantly, these are not separate mockups.

They form one security and operational intelligence experience:

Discover the agent. Detect the threat. Analyze the evidence. Assess the impact. Recommend a response. Bring the human into the decision. Execute under policy. Verify the outcome. Preserve the evidence.

That combination is what makes Forti an enterprise security system rather than simply an AI assistant:

continuous detection and reasoning paired with governed, accountable action.

What we learned

Building an agentic system is fundamentally different from building a chatbot.

A chatbot generates an answer. An agent participates in a workflow — and that means the question of authority becomes just as important as the question of intelligence.

We learned that human-in-the-loop design isn't necessarily a limitation.

When AI handles the difficult work of synthesizing signals, identifying patterns, and reasoning through potential responses, the human can focus on the decision that actually requires human judgment.

The goal isn't to make the agent act as autonomously as possible.

It is to make the agent capable enough to operate at machine speed while preserving the right boundary around consequential decisions.

That balance may become increasingly important as organizations move from experimenting with AI assistants to deploying agents that can interact with real enterprise systems.

The strongest enterprise agent isn't the one that acts most autonomously. It's the one that can detect and reason at machine speed while preserving human authority when the consequences matter.

What's next for Forti

Future development could extend Forti's human-governed approach with more granular organizational policies, allowing organizations to define which actions can be automated and which require different levels of human authorization.

Forti could also expand its long-horizon operational memory and adversarial testing capabilities, allowing organizations to continuously evaluate how their AI agents behave under changing conditions.

Additional development could connect the demonstrated architecture to broader enterprise identity, policy, observability, and compliance infrastructure.

The larger vision is an enterprise environment where organizations don't have to choose between the speed of autonomous AI and the accountability of human oversight.

They can design systems that use both deliberately.

The AI recommends. The human decides.

Built With

  • agentic-ai
  • ai-agents
  • css
  • cybersecurity
  • gemini
  • generative-ai
  • google-ai-studio
  • google-gemini-api
  • html
  • human-in-the-loop-ai
  • javascript
  • synthetic-data
Share this project:

Updates

Submission history