Agentic AI, data security, concept projectסוכני AI, אבטחת מידע, פרויקט קונספט

How does an AI agent earn
permission to act?
איך סוכן AI מרוויח את הרשות לפעול?

Tidewall, a security automation agent designed so a team can see what it understood, what it will touch and who agreed, before it acts.Tidewall, סוכן אוטומציה לאבטחת מידע, שעוצב כך שהצוות רואה מה הוא הבין, במה הוא ייגע ומי אישר, לפני שהוא פועל.

Roleתפקיד Product designer, end to endמעצב מוצר, מקצה לקצה
Teamצוות Soloלבד
Periodתקופה 2026
Platformפלטפורמה Web, with approvals on the phoneווב, עם אישורים בטלפון
4
iterations, from a rule builder to an agent that asks permission
3
roles around 1 rule: the author, the approver and the reader
AI + Human
the agent drafts and explains, and a person approves every change to data

Overview

Automation a security team can see into

In my demo, a small security team at a health insurer guards card numbers and patient records across many cloud accounts. When a storage bucket goes public, automation could fix it in seconds. But a rule that removes access on its own can also cut off a link that real work depends on.

So teams either don't automate, or automate blind. Tidewall is my concept for a third way: an AI agent that drafts a rule from plain words, shows what it understood and would touch, and asks permission before changing data.

Diagram in two bands. Marcus sets up a rule: ask, read back, answer, check, turn it on. Once it is on, when the rule fires: match, notify, ask Dana (highlighted), decide, act or hold.
The life of one rule. Marcus sets it up, and when it fires, the step that changes data waits for Dana. The highlighted step is where the agent asks.

My role. A self-initiated concept, solo. I took an old brief for a rule builder toward an agent-centric experience, to learn data security (DSPM) and to practise designing for AI agents. Research, UX, UI, the coded prototype, design system and usability session are mine. One question shaped every decision: how does an AI agent earn permission to act?


The users

Three people, one rule

Marcus writes the rules. Dana is on call and approves any step that changes data. Elena reads rules to show an auditor what happens. The author can never approve his own rule's destructive steps.

Three persona cards. Marcus Chen, cloud security engineer, the author. Dana Okafor, security operations lead on call, the approver. Elena Rossi, compliance lead, the reader. Each lists needs, worries and what Tidewall gives them.
The cast. These personas are assumptions, not interviews, and the first usability session tested Marcus's side only.

The problem

Fast or safe, pick one

Security automation rules are usually a form: a trigger, conditions and actions. The form says what a rule is, not what it will do. Marcus can't see which buckets it will touch, and Dana is asked to approve a change without its reason.

The original brief asked for that form, plus a bonus question: how could the interface build trust? I made the bonus question the project.


How I worked

Trust as the brief

The goal came first: a team should never be surprised by what a rule does. Then the user stories:

User story

As a cloud security engineer, I need to know quickly when there is a data security issue, so I can explore it and set the right rule for it, because I don't want it to happen again.


Design decision 1

The conversation leads, and the rule is what it makes

The problem

My first build was a rule builder with an assistant beside it. On 23 October I named what bothered me: "the overall concept doesn't feel to me like agent centric UX."

The decision

Keep every function, and lay Tidewall out like a chat app. The conversation takes the main column, and the rule sits beside it as what the conversation produces, with Map, Rule, Backtest and Summary tabs. Tidewall's own work shows as steps in the conversation, and turning a rule on became a step too: the agent asks before it acts.

From a typed request to a drafted rule in seconds, with the agent's reading and its first question in the conversation.
Information architecture: a sidebar with New task, Inbox, Overview, Issues, Rules, Policies and Recent leads to the conversation and the rule beside it, approvals, issues and rule pages. A profile menu holds Reports, Instructions, Connectors, Activity and Settings. On the phone, a Slack message leads to an approval and a rule summary.
The IA after the change: a chat app's structure, with set-up pages moved to the profile menu and approvals on the phone.

Design decision 2

Show what it would touch, then what it did

The problem

A rule's conditions don't say which resources it touches or who loses access.

The decision

The graph is evidence, not an editor, as in the tools I benchmarked. Every rule has a map of who can reach which data and what it would remove, and a 7-day backtest replays past events.

The map got the session's clearest praise: "The diagrams are really excellent." But P1 couldn't tell if it showed what the rule would change or had already changed. So it split into What it covers and What happened, and the backtest became recommended, not required.

A live rule's map on What it covers: identities with access on the left, resources the rule covers on the right, joined by dashed lines that mean would remove access. A green line says nothing on this map would break.
What it covers: the rule's scope, before anything runs.
The same rule on What happened, with cardholder_export open: why it matched, who can reach it, and what the rule did. A Jira ticket and a Slack post are done, and removing public access is waiting for Security on-call.
What happened: only the resources the rule fired on, and what came of each.

Design decision 3

Risk decides who says yes

The problem

A Slack post can't break anything. Removing public access can take a live site down.

The decision

Risk level decides the path. Notifications run on their own and are logged. Anything that changes data waits for someone other than the author, every time, and nothing in the builder can lower that.

The last step before a rule starts, in the conversation: what runs on its own, a Jira ticket and a Slack post, and what waits for a person, removing public access approved by Security on-call. Watch for 7 days first is recommended. The backtest result is beside it.
Turning a rule on is a step in the conversation, and it says plainly what will run alone and what will wait.

If nobody answers in time, the default is to do nothing and escalate. And approvals go where Dana is: a Slack message, then a decision on her phone, with what Tidewall checked in front of her.

A Slack message in the on-call channel asks for approval to remove public access, with the rule, the data at risk and when it expires. An arrow leads to the approval page on a phone: what will change, what Tidewall checked, a note field, and Reject and Approve buttons.
From the on-call channel to a decision on the phone, without opening a laptop.

Design decision 4

Say what you understood, one question at a time

The problem

An agent that reads plain words can misread them. "PCI or PHI" and "PCI and PHI" are one word apart, and they match very different data.

The decision

Tidewall reads back how it understood the request, and every field says where its value came from: your words, inferred, or an unconfirmed default. Then it asks one open question at a time. A skipped question isn't left to scroll back to, since a late answer could change later ones. If it still matters, Tidewall asks again.

The third of six questions in the conversation: if the approver doesn't respond within 2 hours, what should Tidewall do? Do nothing and escalate is recommended, and remove access anyway says it can break a live site. Earlier answers are logged above as Yours now.
One open question at a time, asked in the order an approver thinks: who, how long, then what if nobody answers.
The mistake

I bet on the conversation to carry understanding. P1 typed his request into the chat, but it only clicked when he opened the rule and saw trigger, condition and action in order: "Oh, now I get it."

The fix: chat and rule are now fully synced. A change in either shows in the other, with Undo.

What I learned

The conversation is the way in. The structure is how people understand what they built.


Process

Designed in Figma, built in code, with Claude

I designed in Figma and built with Claude Code as a partner, keeping the decisions mine. Gemini helped explore illustration styles.

The screens in Figma, built on the same variables as the code. Open the file in Figma

Outcome

What one session changed

The proof isn't a shipped metric. It's a working prototype, a design system, and what the first session changed.

What I would do differently

Recruit security people before the first session, not after. One developer is good at finding where a flow breaks, and weak at judging a security call.


What next

Put it in front of security people

Two or three more sessions, with people who write security policies. First, the check P1 never reached because of prototype gaps: will people catch Tidewall reading "or" as "and"? Then P1's question. He expected a nudge to the data owner, since a public link to patient data may be shared with a clinic on purpose. Should access ever be removed automatically?

4
איטרציות, מכלי לבניית כללים לסוכן שמבקש רשות
3
תפקידים סביב כלל אחד: הכותב, המאשרת והקוראת
AI + אדם
הסוכן מנסח ומסביר, ואדם מאשר כל שינוי בנתונים

סקירה

אוטומציה שצוות אבטחה יכול לראות לתוכה

בדמו שלי, צוות אבטחה קטן בחברת ביטוח בריאות שומר על מספרי כרטיסי אשראי ותיקים רפואיים בהרבה חשבונות ענן. כשאחסון נתונים נפתח לציבור, אוטומציה יכולה לתקן את זה בשניות. אבל כלל שמסיר גישה בעצמו יכול גם לנתק קישור שעבודה אמיתית תלויה בו.

אז צוותים או שלא עושים אוטומציה, או שעושים אותה בעיניים עצומות. Tidewall הוא הקונספט שלי לדרך שלישית: סוכן AI שמנסח כלל ממילים פשוטות, מראה מה הבין ובמה הוא עומד לגעת, ומבקש רשות לפני שהוא משנה נתונים.

תרשים בשני פסים. מרקוס מגדיר כלל: שואל, רואה איך הובן, עונה, בודק, ומפעיל. כשהכלל פועל: התאמה, התראה, פנייה לדנה (מודגש), החלטה, ופעולה או עצירה.
החיים של כלל אחד. מרקוס מגדיר אותו, וכשהוא פועל, הצעד שמשנה נתונים מחכה לדנה. השלב המודגש הוא המקום שבו הסוכן שואל.

התפקיד שלי. פרויקט קונספט ביוזמתי, לבד. לקחתי בריף ישן לבניית כללים לכיוון של חוויה שמבוססת על סוכן, כדי ללמוד אבטחת מידע (DSPM) ולתרגל עיצוב לסוכני AI. המחקר, חוויית המשתמש, הממשק, האב-טיפוס בקוד, מערכת העיצוב ומבדק השמישות הם שלי. שאלה אחת עיצבה כל החלטה: איך סוכן AI מרוויח את הרשות לפעול?


המשתמשים

שלושה אנשים, כלל אחד

מרקוס כותב את הכללים. דנה בתורנות ומאשרת כל צעד שמשנה נתונים. אלנה קוראת כללים כדי להראות למבקר מה קורה. מי שכתב כלל לעולם לא יכול לאשר את הצעדים ההרסניים שלו.

שלושה כרטיסי פרסונה: מרקוס צ'ן, מהנדס אבטחת ענן, הכותב. דנה אוקפור, ראש צוות תפעול אבטחה בתורנות, המאשרת. אלנה רוסי, אחראית ציות, הקוראת. בכל כרטיס: צרכים, דאגות, ומה Tidewall נותן.
הדמויות. הפרסונות הן הנחות, לא ראיונות, ומבדק השמישות הראשון בדק רק את הצד של מרקוס.

הבעיה

מהר או בטוח, צריך לבחור

כללי אוטומציה בכלי אבטחה הם בדרך כלל טופס: טריגר, תנאים ופעולות. הטופס אומר מה הכלל, לא מה הוא יעשה. מרקוס לא רואה באילו buckets הכלל ייגע, ודנה מתבקשת לאשר שינוי בלי לדעת למה.

הבריף המקורי ביקש את הטופס הזה, ועוד שאלת בונוס: איך הממשק יכול לבנות אמון? הפכתי את שאלת הבונוס לפרויקט.


איך עבדתי

אמון בתור הבריף

קודם המטרה: צוות לעולם לא צריך להיות מופתע ממה שכלל עושה. אחר כך ה-user stories:

User story

בתור מהנדס אבטחת ענן, אני צריך לדעת מהר כשיש בעיית אבטחת מידע, כדי לחקור אותה ולהגדיר לה את הכלל הנכון, כי אני לא רוצה שזה יקרה שוב.


החלטת עיצוב 1

השיחה מובילה, והכלל הוא מה שנוצר ממנה

הבעיה

הגרסה הראשונה שבניתי הייתה כלי לבניית כללים עם עוזר בצד. ב-23 באוקטובר כתבתי מה הפריע לי: הקונספט כולו לא הרגיש לי כמו חוויה שמבוססת על סוכן.

ההחלטה

לשמור על כל הפונקציות, ולבנות את Tidewall כמו אפליקציית צ'אט. השיחה תופסת את העמודה הראשית, והכלל יושב לידה בתור מה שהשיחה מייצרת, עם הלשוניות Map,‏ Rule,‏ Backtest ו-Summary. העבודה של Tidewall מוצגת כצעדים בשיחה, וגם הפעלת כלל הפכה לצעד: הסוכן שואל לפני שהוא פועל.

מבקשה מוקלדת לכלל מנוסח בתוך שניות, עם האופן שבו הסוכן הבין והשאלה הראשונה שלו בשיחה.
ארכיטקטורת המידע: סרגל צד עם New task,‏ Inbox,‏ Overview,‏ Issues,‏ Rules,‏ Policies ו-Recent מוביל לשיחה ולכלל שלידה, לאישורים, לבעיות ולעמודי כללים. תפריט הפרופיל מכיל Reports,‏ Instructions,‏ Connectors,‏ Activity ו-Settings. בטלפון, הודעת Slack מובילה לאישור ולסיכום הכלל.
ארכיטקטורת המידע אחרי השינוי: מבנה של אפליקציית צ'אט, עמודי ההגדרות עברו לתפריט הפרופיל, והאישורים לטלפון.

החלטת עיצוב 2

להראות במה הכלל ייגע, ואז מה הוא עשה

הבעיה

התנאים של כלל לא אומרים באילו משאבים הוא נוגע, או למי תיחסם הגישה.

ההחלטה

הגרף הוא ראיה, לא עורך, כמו בכלים שהשוויתי. לכל כלל יש מפה של מי יכול להגיע לאילו נתונים ומה הכלל יסיר, ו-backtest של 7 ימים שמריץ מחדש אירועים מהעבר.

המפה קיבלה את המחמאה הכי ברורה במבדק: "הדיאגרמות ממש מצוינות." אבל P1 לא הצליח להבין אם היא מראה מה הכלל ישנה או מה הוא כבר שינה. אז היא התפצלה ל-What it covers ול-What happened, וה-backtest הפך למומלץ במקום לחובה.

המפה של כלל פעיל בתצוגת What it covers: זהויות עם גישה משמאל, המשאבים שהכלל מכסה מימין, מחוברים בקווים מקווקווים שמשמעותם שהגישה תוסר. שורה ירוקה אומרת ששום דבר במפה לא יישבר.
What it covers: ההיקף של הכלל, לפני שמשהו רץ.
אותו כלל בתצוגת What happened, עם cardholder_export פתוח: למה הוא תאם, מי יכול להגיע אליו, ומה הכלל עשה. כרטיס Jira והודעת Slack בוצעו, והסרת הגישה הציבורית מחכה לתורנות האבטחה.
What happened: רק המשאבים שהכלל פעל עליהם, ומה יצא מכל אחד.

החלטת עיצוב 3

הסיכון קובע מי אומר כן

הבעיה

הודעה ב-Slack לא יכולה לשבור כלום. הסרת גישה ציבורית יכולה להפיל אתר חי.

ההחלטה

רמת הסיכון קובעת את הדרך. התראות רצות לבד ונרשמות ביומן. כל מה שמשנה נתונים מחכה למישהו שאינו מי שכתב את הכלל, בכל פעם, ושום דבר בבונה הכללים לא יכול להוריד את זה.

הצעד האחרון לפני שכלל מתחיל לפעול, בתוך השיחה: מה רץ לבד, כרטיס Jira והודעת Slack, ומה מחכה לאדם, הסרת גישה ציבורית באישור תורנות האבטחה. מומלץ לצפות 7 ימים קודם. תוצאת ה-backtest לידו.
הפעלת כלל היא צעד בשיחה, והוא אומר בפשטות מה ירוץ לבד ומה יחכה.

אם אף אחד לא עונה בזמן, ברירת המחדל היא לא לעשות כלום ולהסלים. והאישורים מגיעים למקום שבו דנה נמצאת: הודעה ב-Slack, ואז החלטה בטלפון, עם מה ש-Tidewall בדק מול העיניים.

הודעת Slack בערוץ התורנות מבקשת אישור להסרת גישה ציבורית, עם הכלל, הנתונים בסיכון ומתי הבקשה פגה. חץ מוביל לעמוד האישור בטלפון: מה ישתנה, מה Tidewall בדק, שדה להערה, וכפתורי דחייה ואישור.
מערוץ התורנות להחלטה בטלפון, בלי לפתוח מחשב.

החלטת עיצוב 4

להגיד מה הבנת, שאלה אחת בכל פעם

הבעיה

סוכן שקורא מילים פשוטות יכול לקרוא אותן לא נכון. "PCI או PHI" ו-"PCI וגם PHI" רחוקים מילה אחת זה מזה, ותואמים נתונים שונים מאוד.

ההחלטה

Tidewall חוזר על האופן שבו הבין את הבקשה, וכל שדה אומר מאיפה הגיע הערך שלו: מהמילים שלך, מהסקה, או מברירת מחדל שאף אחד עוד לא אישר. אחר כך הוא שואל שאלה פתוחה אחת בכל פעם. שאלה שדילגו עליה לא נשארת למעלה בשיחה, כי תשובה מאוחרת יכולה לשנות את התשובות שאחריה. אם היא עדיין רלוונטית, Tidewall שואל שוב.

השאלה השלישית מתוך שש בשיחה: אם המאשר לא עונה תוך שעתיים, מה Tidewall צריך לעשות? לא לעשות כלום ולהסלים מסומן כמומלץ, והסרת הגישה בכל זאת אומרת שהיא יכולה לשבור אתר חי. התשובות הקודמות רשומות למעלה.
שאלה פתוחה אחת בכל פעם, בסדר שבו מאשר חושב: מי, כמה זמן, ומה אם אף אחד לא עונה.
הטעות

הימרתי על כך שהשיחה תישא את ההבנה. P1 הקליד את הבקשה שלו בצ'אט, אבל זה התחבר לו רק כשפתח את הכלל וראה טריגר, תנאי ופעולה לפי הסדר: "אה, עכשיו הבנתי."

התיקון: הצ'אט והכלל מסונכרנים לגמרי. שינוי באחד מופיע בשני, עם אפשרות לבטל.

מה למדתי

השיחה היא הדרך פנימה. המבנה הוא הדרך שבה אנשים מבינים מה בנו.


תהליך

עוצב ב-Figma, נבנה בקוד, עם Claude

עיצבתי ב-Figma ובניתי עם Claude Code כשותף, כשההחלטות נשארות שלי. Gemini עזר לחקור סגנונות איור.

המסכים ב-Figma, בנויים על אותם משתנים כמו הקוד. לפתוח את הקובץ ב-Figma

התוצאה

מה מבדק אחד שינה

ההוכחה כאן היא לא מדד ממוצר שיצא לשוק. היא אב-טיפוס עובד, מערכת עיצוב, ומה שהמבדק הראשון שינה.

מה הייתי עושה אחרת

לגייס אנשי אבטחה לפני המבדק הראשון, ולא אחריו. מפתח אחד טוב במציאת המקומות שבהם ה-flow נשבר, וחלש בשיפוט של החלטת אבטחה.


מה הלאה

להביא את זה לאנשי אבטחה

עוד שניים או שלושה מבדקים, עם אנשים שכותבים מדיניות אבטחה. קודם הבדיקה ש-P1 לא הגיע אליה בגלל פערים באב-טיפוס: האם אנשים יתפסו את Tidewall קורא "או" בתור "וגם"? אחר כך השאלה של P1. הוא ציפה לתזכורת לבעלים של הנתונים, כי קישור ציבורי לנתונים רפואיים אולי נשלח למרפאה בכוונה. האם בכלל צריך להסיר גישה אוטומטית?