Agentic Design Principles

Overview

When building AI Agents, design is not just about code — it’s about user experience. These principles help you build agents that users trust and want to use.

Design Principles

1. Agent Space — Operating Environment

An agent operates within a defined space. How it interacts with that space determines the experience:

Connecting, not replacing:

• Agents help connect people to each other, events, and knowledge
• Agents are not designed to replace humans

Easily accessible, occasionally invisible:

• Agent mostly works in the background, only appearing when needed
• Supports multimodal: text, voice, images
• Seamlessly transitions between foreground and background

// Example: Agent knows when to proactively suggest
interface AgentBehavior {
  // Agent monitors but only suggests when appropriate
  shouldNotify(context: UserContext): boolean;
  // Intervention level depends on context
  getInterventionLevel(urgency: number): "silent" | "nudge" | "alert";
}

2. Agent Time — Interaction Over Time

Past — Reflecting:

• Agent analyzes historical data for more accurate results
• Creates connections from past events to handle current situations

Present — Nudging, not notifying:

• Instead of static notifications, agent proactively suggests based on context
• Interactions gradually evolve in complexity

Future — Adapting:

• Agent adapts to different devices and platforms
• Agent learns from continuous user interaction

3. Agent Core — Design Foundation

Embrace uncertainty, but establish trust:

// Agent is always transparent about confidence
interface AgentResponse {
  answer: string;
  confidence: number;        // 0-1
  sources: string[];         // References
  disclaimer?: string;       // When confidence is low
  canHumanOverride: boolean; // Always true
}

• Agent must acknowledge when uncertain
• Users always have control (on/off, override)
• Agent status must be clearly visible at all times

Practical Guidelines

1. Transparency

// ❌ Bad: Agent acts silently
await agent.execute(task); // User doesn't know what's happening

// ✅ Good: Agent reports each step
const steps = agent.plan(task);
for (const step of steps) {
  ui.showProgress(step.description);
  await agent.execute(step);
  ui.showResult(step.result);
}

• Let users know AI is being used
• Explain how the agent works
• Provide feedback channels

2. Control

• Allow customization and personalization
• Users can specify preferences
• Ability to forget — delete data when requested

3. Consistency

• Familiar UI/UX across all devices
• Standard icons (🎤 for voice, 📎 for file upload)
• Concise responses with visual aids

Example: Designing a Travel Agent

Principle	Application
Transparency	”Hello” message explains the agent is AI. Show prompt history. 👍👎 buttons for feedback
Control	Allow editing system prompt, writing style, banned topics. Delete conversation history
Consistency	Standard icons for share, upload, tag. 📎 = file upload, 🖼️ = image upload

Agent Design Checklist

• Does the agent explain it’s AI?
• Does the agent show progress?
• Can users override agent decisions?
• Does the agent admit when it doesn’t know?
• Is there a clear feedback channel?
• Does the agent respect privacy?
• Is the UI consistent across platforms?

Summary

• Design agents with humans at the center: connecting, transparent, controllable
• Agents operate across 3 dimensions: Space, Time, Core
• 3 mandatory guidelines: Transparency, Control, Consistency
• Always remember: a good agent is one users trust