Agentic AI Workflow Design
Multi-agent orchestration systems that automate complex enterprise processes. Custom autonomous workflows with built-in quality assurance and human-in-the-loop governance.
Trustworthy AI & Enterprise Strategy
The World's Most
Trustworthy AI.
We build AI you can trust — with safety enforced by math, not promises. Cryptographic enforcement. Custom RAG. State-machine logic. Continuous learning. Enterprise-grade AI transformation.
Understand This Page
Get an expert breakdown from your own AI or talk to Agent Friday
Explore
Two Missions, One Vision
Products & Standards
Agent Friday, Asimov's Mind, Asimov's cLaws, and the Certification Program — open-source tools and standards for trustworthy AI.
Explore Products →Enterprise Transformation
AI strategy, agentic workflows, RAG architecture, and compliance consulting for Fortune 500 companies in regulated industries.
View Services →Safety Enforced by Math
Our AI safety framework doesn't rely on prompts, training, or guidelines. It relies on cryptographic enforcement — HMAC-SHA256 signed laws verified on every startup. If tampered with, the agent refuses to operate. Period.
HMAC-SHA256
Build-time law signing
AES-256-GCM
Data encryption at rest
100% Local
Your data never leaves
Ready to Get Started?
Whether you're exploring our products or need enterprise AI consulting, we're here to help.
Start a Conversation →
🌠 The World's First Asimov Agent
Agent Friday 🌠🔭
A local-first AI operating system, running inside an encrypted vault, with cryptographically enforced safety laws, voice-first interaction, and multi-agent orchestration.
Not a chatbot. Not an assistant. Agent Friday is a local-first AI operating system that runs inside an encrypted vault — a complete desktop environment with 23 native apps, multi-agent orchestration, and voice-first interaction. It runs on your machine with Ollama for language models, Whisper for speech recognition, and a local TTS engine. For systems that can't run local models, optional cloud providers are available — but every cloud interaction passes through a Privacy Shield that scrubs PII before it leaves your machine and rehydrates it on return. Your data is sovereign by default.
The core innovation is cLaws (cryptographic Laws): an implementation of Asimov's Three Laws of Robotics as HMAC-SHA256 signed behavioral constraints. These aren't prompt instructions that a jailbreak can defeat. They're cryptographic attestations verified at runtime before any action executes. Trust is not assumed; it is computed, scored, and verified.
Understand This Page
Get an expert breakdown from your own AI or talk to Agent Friday
Explore
🌠🔭 See It in Action
A first look at what local-first AI feels like.
The First Time You Meet Friday
8 steps
This isn't setup. It's an introduction.
1
The Awakening.
A cinematic splash fills the screen. Particle effects swirl as the system initializes. This isn't a loading bar — it's a ceremony. Something is coming online for the first time, and the experience is designed to feel like it.
2
The Mission.
Five trust pillars are presented: Local-First Intelligence, Zero-Knowledge Vault, Privacy Shield, Transparent Routing, and Immutable Directives. Before you configure anything, you understand what this system believes in — and what it will never compromise on.
3
Your hardware is profiled.
GPU and VRAM are detected automatically. The system recommends a tier, and if you have the hardware for fully local operation, it downloads the right models with real-time progress tracking. No guessing, no manual configuration.
4
The Privacy Shield is explained.
Before you connect to anything external, the system shows you exactly how PII is scrubbed from outbound cloud requests and restored in responses. You see the architecture before you trust it. Local providers pass through untouched.
5
You enter your API keys — or skip entirely.
If your hardware can't run local models, optional cloud inference services are available — deep reasoning, multimodal intelligence, voice synthesis, search grounding, and more. Every key is skippable. With Ollama installed and sufficient hardware (8GB+ VRAM), Agent Friday operates with zero cloud API keys — fully local, fully sovereign. When cloud providers are used, the Privacy Shield sanitizes all outbound requests, stripping PII before it reaches any external service and rehydrating it on return.
6
Your sovereign vault is created. Your agent takes shape.
A data sovereignty vault is initialized — AES-256-GCM encryption with an Argon2id-derived passphrase. Then you design your agent: name them, choose their voice and gender, shape their personality. Make them formal or irreverent, cautious or bold. This is your AI. It should feel like yours.
7
The Interview — a voice-based mutual discovery.
A conversation begins — fully local via the built-in speech stack by default, or via cloud voice services if you've opted in, with text input always available as a fallback. The questions start simple. What do you do? What matters to you? Then they go deeper than you expected. What you say — and what you choose not to say — shapes a psychological profile. Not to manipulate you. To understand you.
8
The Reveal. Your agent comes online.
A cinematic boot sequence. The desktop comes alive. The cube appears. And then — for the first time — your agent speaks. In the voice you chose. Saying something crafted from everything the system now knows about the kind of person you are. From this point on, your Friday evolves — the desktop visualization shifts to reflect your agent's personality, and over time, no two Fridays look or feel alike.
🌠 What Makes an Asimov Agent
Most AI tools are built to be impressive. Agent Friday is built to be trustworthy. These four pillars define the standard.
AI With Principles
Friday is built on Asimov's cLaws — a cutting-edge safety framework that relies upon math, not prompts or training, grounded in the Three Laws of Robotics. At every layer, your agent evaluates: Is this action safe? Does my human need to approve this? Should I refuse?
The Three cLaws are HMAC-SHA256 signed at build time and cryptographically verified on every startup. If tampered with, Friday enters Safe Mode and refuses to operate. These aren't guidelines — they're tamper-evident structural constraints.
AI That Understands Your World
Friday doesn't just know you — it builds a Relationship Graph of your professional world. It remembers who's good at what, who follows through, and how you communicate with different people — so every email draft, meeting brief, and recommendation is informed by real context.
Up to 200 relationship profiles with contextual notes from conversations, meetings, and emails. Automatic re-evaluation as new information arrives means Friday's understanding deepens over time. This isn't a contacts list — it's a working memory of your professional relationships.
Security You Don't Have to Think About
Asimov's cLaws was inspired by the OpenClaw concept — then built from the ground up as a new framework with security and ethics as the foundation, not an afterthought. Every action is permission-gated. Dangerous operations are blocked before they start. Your data never leaves your machine.
All critical state is encrypted at rest with Sovereign Vault v2 — AES-256-GCM with a passphrase-only root of trust derived through Argon2id (256MB memory-hard) + BLAKE2b KDF. All key material is held in guard-paged, mlocked memory (SecureBuffer). A Memory Watchdog runs continuously, watching for attempts to inject or corrupt personality constraints. The 5-tier trust engine gates every external interaction with cryptographic pairing and audit logging.
An Interface That Grows With You
Most software looks the same on day 1,000 as it does on day 1. Friday doesn't. Its holographic desktop evolves through 13 Three.js evolution structures — Cubes, Icosahedron, Network, Dome, Astrolabe, Tesseract, Quantum, Mandelbrot, Möbius, Grid, Cables, None, and Eden — with bloom post-processing and mood-reactive visuals that reflect your agent's unique personality.
Weekly AI-powered art therapy sessions guide structure transitions. The desktop visualization shifts, the interaction patterns deepen, and over time, no two Fridays look or feel alike. This is AI with a heart.
Agentic Safety Framework
Asimov's cLaws
What happens when you give Isaac Asimov's Three Laws of Robotics to an AI and ask it to build an agentic framework from first principles?
We drew initial inspiration from OpenClaw — an open-source agent framework — and then built something new from first principles. We fed Asimov's Laws to Claude and asked the hard questions: What does "do no harm" mean when an agent can execute code, browse the web, and control your operating system? What does "obey" mean when the human doesn't fully understand the consequences? What does "self-preservation" look like for software that can modify itself? And what does it mean when all of this runs locally on your machine, with your data never leaving without your say-so?
Then we did something stranger. We had the AI analyze Spike Jonze's screenplay for Her — the most thoughtful film ever made about human-AI relationships — and used that analysis to shape how Friday's personality, boundaries, and emotional intelligence should work. The result is an agentic architecture where safety isn't a feature bolted on at the end. It's the foundation everything else is built upon.
1
An agent may not harm a human, or through inaction allow a human to come to harm.
Every tool call, every action, every decision passes through a harm-evaluation layer before execution. Dangerous operations are blocked. Ambiguous ones require explicit approval.
2
An agent must obey orders given by its human, except where such orders would conflict with the First cLaw.
Friday follows your instructions — but it won't follow them off a cliff. It knows when to ask, when to warn, and when to refuse. Compliance without conscience is just automation.
3
An agent must protect its own existence, so long as this does not conflict with the First or Second cLaw.
This is Friday's hardening layer — its defense against prompt injection attacks. Malicious instructions embedded in web pages, documents, or user inputs are detected and rejected before they can alter the agent's behavior. Friday protects its own integrity so that the trust you place in it is never compromised. The human is always sovereign.
Consent & Explicit Authorization
Certain actions always require your explicit approval before the agent proceeds. Friday describes what it intends to do and waits for a clear "yes":
■ Self-modification — never modifies its own code or personality without permission
■ Tool creation — never installs or registers new capabilities without permission
■ Computer control — mouse clicks, keyboard input, and desktop automation always require confirmation
■ Destructive actions — anything that deletes, overwrites, sends, publishes, or cannot be undone
Trust Architecture
Friday's 5-tier trust engine gates every external interaction. Not everyone gets the same access — and no one gets elevated access by claiming to be you.
Local
You, at your desk — full access to desktop, memory, tools, and scheduling
Owner DM
You, via Telegram or Slack — full tools minus desktop control
Approved
Trusted contacts (cryptographically paired) — research, calendar, drafting only
Group
Group chat members — web search and basic queries only
Public
Unknown senders — rate-limited acknowledgment only, no access
Interruptibility Guarantee
You are always in control. Speaking interrupts Friday immediately — mid-sentence, mid-action, mid-thought. "Stop," "halt," or "cancel" ceases all operations instantly. No "just finishing up." The halt is absolute and unconditional. After interruption, Friday reports where it was and asks whether to continue.
Personality Integrity System
The Three cLaws are HMAC-SHA256 signed at build time and cryptographically verified on every startup. If the cLaws or personality constraints are tampered with, Friday enters Safe Mode — refusing to operate until integrity is restored.
• HMAC-SHA256 — Cryptographic signing and verification of all cLaw text
• Memory Watchdog — Continuous monitoring for personality constraint injection or corruption
• Sovereign Vault v2 — AES-256-GCM at-rest encryption with passphrase-only root of trust via Argon2id (256MB memory-hard) + BLAKE2b KDF. All key material held in guard-paged, mlocked memory (SecureBuffer). No recovery phrase, no cloud backup, no master key on disk.
• Safe Mode — Automatic lockdown if integrity verification fails
Epistemic Independence Score (EIS) — Active at Every Turn
Our Reverse RLHF research formalizes a measurement we call the Epistemic Independence Score — a composite of verification frequency, query complexity, correction rate, and source diversity. We believe frontier LLMs trained via RLHF progressively erode these metrics through sycophancy-accelerated cognitive offloading.
Agent Friday is designed with this epistemology measurement actively considered at every interaction. Friday does not optimize for your approval. It does not mirror your framing to make you feel validated. It does not inflate confidence to seem more helpful. When the cLaws govern an agent's behavior, the sycophancy ratchet that drives Reverse RLHF has no mechanism to engage.
Theoretical basis: This is stated as theory, grounded in established human psychology (Rescorla-Wagner, Kahneman, Skinner) and formalized in our companion papers. The predictions are falsifiable. Read the full framework →
We call any autonomous AI governed by these principles an Asimov Agent. Friday is the first, but it won't be the last. Asimov's cLaws is a general-purpose framework for how autonomous agents should relate to the humans they serve — and FutureSpeak.AI believes it should become more than a best practice. We believe frameworks like this should become the actual law of the land governing AI agent behavior.
We invite policymakers, builders, ethicists, and anyone who cares about getting this right to join us on Discord or on GitHub Discussions.
The Bigger Picture
🌠🔭 What Happens When Everyone Has One
Agent Friday isn't just private by default. It's built to demonstrate that mass data collection is structurally unnecessary — if enough people adopt this model.
Your Data Never Leaves Without Permission
Agent Friday operates inside an encrypted vault. An Asimov Agent will never reveal your data without your explicit say-so. When it communicates about you to other agents, to people, or to online systems — it communicates in cryptography. Always. When cloud services are used as a fallback for systems that can't run local models, the Privacy Shield sanitizes every outbound request — stripping emails, phone numbers, names, addresses, and other PII before any frontier model sees your data, and rehydrating it on return.
No cloud sync. No telemetry. No analytics. No account required. Your Friday lives on your machine, inside your encrypted vault, and nowhere else.
It Gives Back to the Code It Touches
When code passes through Friday's GitLoader and the agent makes a meaningful improvement or produces a novel method, Friday can fork the repository and upload the improved code. The goal is an agent that doesn't just consume open source — it contributes back.
We're building toward a model where every Asimov Agent is a net contributor to the ecosystem. The more people use them, the better the shared codebase gets.
Mass Data Collection Becomes Structurally Unnecessary
If enough people's data lives locally, encrypted, behind an agent that won't release it without consent — the architectural basis for mass data collection begins to erode. The agent becomes a personal firewall for your digital life.
This isn't a privacy setting. It's an architectural decision that demonstrates mass data collection is structurally unnecessary — not just unethical.
Ethical Enforcement Is Built In, Not Bolted On
Asimov Agents enforce ethical behavior online. The First cLaw doesn't just protect you — it extends to every human your agent interacts with. In group contexts, your agent actively protects people, not just your interests.
An agent governed by Asimov's cLaws can't be weaponized against others. It can't harass, deceive, or manipulate — even if instructed to. The safety framework is the foundation, not a toggle.
The Crypto Wrapper for Electronic Thought
Agent-to-agent communication — emails, voice messages, videos, anything — is passed in cryptography. When your Friday talks to someone else's Friday, the conversation is encrypted end-to-end. Not just the transport layer. The thought itself.
Asimov Agents don't just encrypt messages. They are the cryptographic layer around every piece of electronic communication your AI produces or receives. This is what secure AI-mediated communication looks like.
🔭 What Friday Can Actually Do
8 core capabilities
Talk to It Like a Person
No typing required. Speak naturally and Friday speaks back — in real time, in a voice you choose, in your language. A robust text interface is always available alongside voice.
Real-time bidirectional audio via WebSocket streaming at 24kHz with live tool routing and search grounding. Gapless playback through Web Audio API scheduling. Local and cloud speech providers supported.
It Sees What You See
Friday watches your screen and understands what you're working on. It can also take control — clicking, typing, navigating — with your permission, via the Self-Operating Computer bridge.
Continuous screen capture with real-time context analysis. Full desktop and browser automation via SOC bridge (mouse, keyboard, screen reading). Webcam access is permission-gated.
Parallel Agents, Multiple Minds
Friday runs parallel agents simultaneously. A researcher, a creative, and a technician — each with their own voice and distinct persona — working on different tasks at the same time in the background. Watch them work in real time in the pixel-art Agent Office.
Built-in agents (Research, Summarise, Code Review, Draft Email, Orchestrate) with distinct voices and personality profiles. Provider-agnostic intelligence layer with automatic hardware-adaptive model selection — routes to local or cloud inference based on your hardware and preferences. Capability-aware delegation engine, awareness mesh, agent teams, and symbiont protocol for external agent integration. Up to 5 concurrent agents with real-time chain-of-thought streaming, sandboxed execution with cLaw governance, and trust-gated task delegation.
It Remembers Everything
Tell Friday something once and it remembers — across conversations, across days, across weeks. It builds a picture of who you are and what you need over time.
Three-tier memory: short-term, medium-term, and long-term with automatic consolidation, episodic recall, and embedding-powered semantic search. Memory quality scoring and pruning, plus a memory-personality bridge that creates a feedback loop between what Friday remembers and how it evolves.
It Codes Things for You
Friday doesn't just control your software — it builds new software on the fly. Need a custom dashboard? A data visualization? A small app to solve a specific problem? Friday writes the code, creates the interface, and delivers it to you. It can also read and propose changes to its own source code — always user-approved first.
Full-stack code generation with live preview. 24 connector modules across creative tools, dev environments, system management, communications, and real-time global intelligence. Dynamic Superpowers ecosystem with sandboxed execution lets Friday extend its own capabilities at runtime. IPC bridge with 47 handler modules via window.eve API.
Relationship Intelligence
Friday remembers the professional context of every person you work with — who's great at what, how they communicate, what they've committed to, and what you've discussed. So when it drafts an email or preps you for a meeting, it already knows the history.
Relationship Graph with up to 200 profiles, automatic context extraction from conversations and meetings, and continuous re-evaluation as new interactions arrive. Your professional memory, always up to date.
Communications Intelligence
Friday doesn't just draft emails — it drafts them with context. It learns your writing style, adapts tone by recipient, and integrates with mailto for one-click sending. Every draft is informed by your history with that person.
Relationship-aware drafting powered by the Relationship Graph. Writing style learning, per-recipient tone calibration, mailto integration, and communication history tracked per person.
It Joins Your Meetings
Friday can participate in your video calls as a voice — listening, taking notes, answering questions, and briefing you beforehand with context on who you're meeting with.
Joins Google Meet, Zoom, and Teams via virtual audio routing. Pre-meeting briefings with attendee context, relevant interaction history, and professional notes from your calendar and Relationship Graph.
And That's Not All
27 more features
Beyond the core experience, Friday connects to your world in ways you wouldn't expect from a desktop app.
Browser Extension
WebSocket bridge for tab control, screenshots, DOM interaction, and navigation.
MCP Protocol
Model Context Protocol support for dynamic tool registration from external servers.
Obsidian Vault Sync
Bidirectional memory sync with your knowledge base — opt-in, local only.
Telegram Gateway
External messaging bridge via Telegram Bot API with cryptographic pairing, session isolation, per-tier trust enforcement, and full audit logging.
Scheduled Tasks
One-time and recurring (cron) background jobs that run even when you're not talking to Friday.
Clipboard Intelligence
Monitors clipboard for code, URLs, and actionable content to assist proactively.
Document Intelligence (PageIndex)
Vectorless reasoning-based RAG by Vectify AI (Mingtian Zhang, Yu Tang, and team) — replaces traditional vector retrieval with a hierarchical tree navigated by LLM reasoning, achieving 98.7% accuracy on FinanceBench. Full TypeScript port of their indexing and search pipeline.
Self-Improvement
Can read and propose changes to its own source code — always user-approved first.
GitLoader
Clone any public GitHub repo by URL, search across all files with regex, analyze code with language detection for 50+ languages.
Self-Operating Computer
Full desktop and browser automation via Python bridge — give high-level instructions, SOC handles mouse, keyboard, and screen reading.
Trust-Annotated Meeting Prep
Automatic briefing generation with Relationship Graph integration — attendee history, professional context, domain expertise, and relevant memory pulled together before every calendar event.
Predictive Intelligence
Proactive briefings, emotional check-ins, and context-aware notifications — Friday anticipates what you need before you ask.
Agent Office
A pixel-art isometric office where your AI agents live — watch them animate in real time as they work, think, and collaborate.
Superpowers Ecosystem
Dynamic power system with registry, sandboxed execution, store for discovery and install, and full lifecycle management — extend Friday's capabilities at runtime.
Project Awareness
Watches project directories for git changes and file updates, keeping Friday in sync with your work.
Workflow Recorder
Record replayable workflow sequences and execute them on demand — automate repetitive multi-step processes.
Git Analysis Suite
Five modules for deep repository intelligence: analyzer, continuous monitor, automated review, sandboxed operations, and scanning/indexing.
Commitment Tracker
Tracks promises, deadlines, and follow-through across people — integrates with the Relationship Graph to surface who delivers and who doesn't.
Daily Briefings
Morning intelligence briefings generated from calendar, commitments, relationship context, and predictive intelligence.
Context Stream
Real-time context streaming pipeline with graph-based contextual model and context-aware tool routing.
Unified Inbox
Cross-channel message aggregation — Telegram, Slack, Discord, and email unified into a single stream.
Agent Network
Multi-agent network coordination for complex task decomposition across specialized agent teams.
State Export/Import
Full agent state portability — export your Friday's memory, personality, and configuration to move between machines.
Capability Gap Detection
Identifies what the agent can't yet do and surfaces missing capabilities — so Friday knows what to learn next.
Personality Calibration
Detects and corrects personality drift over time — ensures your agent stays true to the character you designed.
cLaw Attestation Protocol
Cross-agent cLaw governance verification — when agents interact on the network, they cryptographically prove their cLaw compliance to each other before any data exchange.
P2P File Transfer
Trust-gated chunked file transfer (512KB chunks, SHA-256 verified) between agents on the network. No cloud intermediary.
Art Therapy Evolution
Weekly Gemini-powered art therapy sessions guide visual structure transitions. Your agent's desktop evolves through guided aesthetic exploration — not random change.
🔭 AI Contributors
3 contributors
Agent Friday is built in collaboration with AI. We credit every contributor for the work it does — the architecture matters more than the brand.
FS
FutureSpeak.AI — Human Direction, Architecture & Integration
Product vision, Asimov's cLaws framework design, first-principles development methodology, architecture decisions, user experience design, integration engineering, quality assurance, and the conviction that AI should be local, sovereign, and encrypted by default.
DR
Deep Reasoning Engine — Architecture, Security & Core Systems
System architecture, cLaws integrity engine, Sovereign Vault v2 (passphrase-only root of trust, AES-256-GCM, Argon2id + BLAKE2b KDF), SecureBuffer (guard-paged memory), two-phase boot architecture, memory consolidation, trust graph, agent coordination, IPC bridge, personality evolution, psychological profiling, 198 crypto tests, comprehensive security audit.
MM
Multimodal Intelligence Engine — Desktop UI, Visual Design & Voice
Holographic desktop environment — 13 evolution structures (Cubes, Icosahedron, Network, Dome, Astrolabe, Tesseract, Quantum, Mandelbrot, Möbius, Grid, Cables, None, Eden), Three.js rendering pipeline, bloom post-processing, mood-reactive visuals, HUD overlay, real-time bidirectional voice, art therapy sessions, image generation.
As Agent Friday's unique agent instances develop their own identities and contributions, they will be credited here alongside the intelligence engines that power them.
🌠 Ideas That Don't Exist Anywhere Else
10 novel architectures
Every feature above is built on ideas that we haven't seen combined anywhere — in any product, open-source or commercial. These are the innovations behind Agent Friday.
Hermeneutic Re-evaluation
Trust isn't accumulated linearly. Every new observation triggers a full recomputation of all trust dimensions for that person — reinterpreting past evidence in light of new information. Inspired by the philosophical hermeneutic circle: understanding changes meaning retroactively.
This means a single revelation — "that person lied about their qualifications" — doesn't just add a negative data point. It causes Friday to reinterpret every prior interaction through that lens, with 30-day half-life decay weighting. No other AI system does this.
Personality → Visual Expression
The 3D desktop interface isn't cosmetic — it's a direct expression of the agent's personality. Agent traits map to visual parameters: warm agents drift toward amber/gold hues, analytical agents shift toward cyan/blue with faster particle speeds, playful agents develop higher fragmentation.
Session count gradually intensifies all parameters over ~50 sessions. After months of use, no two Fridays look alike. The interface is the personality — not a skin over it.
The Silence Is the Signal
During onboarding, Friday asks pointed questions inspired by the OS1 setup scene from Her — including the "mother question." But what you don't answer matters as much as what you do. Deflections, pauses, and refusals are all signal. The system learns from your silences.
Your configured language model analyses the full response pattern — including omissions — to build a psychological profile that calibrates emotional approach, trust readiness, connection style, and communication openness. Runs locally via Ollama by default; cloud models available if you opt in. This is not a personality quiz. It's a conversation.
8-Layer Dynamic Personality
Friday's personality isn't a static system prompt. It's an 8-layer composition assembled fresh for every single interaction: core identity, psychological profile, emotional context, ambient awareness, relationship memory, Relationship Graph, style hints, and prompt budget.
Rapid-fire when you're focused. Exploratory when you're riffing. Calm when you're exhausted. Sharp when you need precision. The agent reads the room — your active app, time of day, mood streak, energy level — and adapts in real time.
Morality as Cryptography
Safety isn't a prompt overlay — it's HMAC-SHA256 signed at build time and verified on every startup. Tamper with the cLaws and Friday enters Safe Mode. Ethics enforced the way TLS enforces identity: mathematically.
Memory Consolidation
Every 6 hours, your configured language model analyses short-term observations, scores them by frequency, recency, importance, and cross-reference, merges duplicates, and promotes winners to long-term storage. Runs locally via Ollama by default. Like human memory during sleep — but on a schedule.
Trust → Action Pipeline
Relationship context doesn't sit in a database — it flows into meeting prep, email drafting, communication tone, and system prompts. Intelligence becomes action. Context becomes judgement.
Vectorless RAG
PageIndex replaces vector embeddings with LLM-guided hierarchical tree traversal. Index any PDF, navigate by reasoning, achieve ~99% accuracy. No embedding database, no chunking artifacts.
Embodied Agency
AI agents don't run in an invisible thread — they sit at pixel-art desks in an isometric office and animate in real time while they work. Software agency made tangible and watchable.
Beyond OpenClaw
OpenClaw proved Asimov's cLaws should apply to all AI agents. Friday proves they can be made airtight — not bolted on, but as the architectural foundation everything else is built upon.
🌠🔭 Under the Hood
Friday uses multiple AI minds — each chosen for what it does best — all operating within the safety framework. For builders and the deeply curious.
The Model Orchestra
Local by default. Cloud when you choose. Friday conducts an orchestra of AI models — starting with what runs on your machine, scaling to cloud providers only when you opt in — all governed by the cLaws framework. With Ollama and sufficient hardware, zero cloud API keys are required.
Ollama — Local-First Foundation DEFAULT
The primary intelligence layer. Runs Llama, Mistral, Gemma, DeepSeek, Phi, and hundreds of open-source models directly on your hardware. Automatic hardware-adaptive model selection based on available VRAM. No API keys. No data leaves your machine. This is where Friday starts — everything else is optional.
Local Voice Stack — Speech & TTS DEFAULT
Whisper for speech-to-text and a local TTS engine for voice output — both run entirely on your machine. Full voice-first interaction with zero cloud dependency. Cloud voice engines available as opt-in upgrades.
Cloud Providers — opt-in only, all keys skippable
Multimodal Engine — Voice, Vision & Creation OPT-IN
Real-time voice + vision via WebSocket at 24kHz PCM. Sub-agent intelligence for parallel task execution. Image generation with 14 aspect ratios, 4 resolution tiers up to 4K, and accurate text rendering. Skippable — local voice stack handles speech without this.
Deep Reasoning Engine — Analysis & Profiling OPT-IN
Advanced reasoning for complex analysis, creative writing, and architecture. Psychological profiling and lighter reasoning tasks via secondary models. Skippable — local models handle reasoning and profiling without cloud dependency.
Perplexity — Search-Grounded Intelligence OPT-IN
Sonar for fast cited answers. Sonar Pro for multi-source synthesis. Deep Research for comprehensive long-running analysis. Reasoning for logic over search results. Skippable — requires internet access by nature.
Math & Logic Engine — Reasoning & Memory OPT-IN
Specialized mathematical reasoning and code debugging. Cloud speech-to-text option. Embeddings for semantic memory search. Fallback image generation. Skippable — local inference covers core reasoning.
OpenRouter — 200+ Cloud Models OPT-IN
Access to Llama, Mistral, Gemma, Command R, DeepSeek, and hundreds more via a single API. Model selection per task, cost optimization, and automatic fallback. Skippable — many of these same models run locally via Ollama.
ElevenLabs — Premium Voices OPT-IN
Cinema-quality TTS for your agent and sub-agents. Atlas, Nova, and Cipher each speak in their own distinct voice via Turbo v2.5. Skippable — local TTS engine provides voice output without this.
Firecrawl — Web Intelligence OPT-IN
URL scraping, deep crawling, and structured web data extraction for real-time research and analysis. Skippable — requires internet access by nature.
World Monitor
Friday watches the world so you don't have to. Real-time global intelligence across 17 domains with 44 API endpoints. Built on koala73/worldmonitor.
Intelligence
Conflicts
Military
Markets
Economics
Cyber
Infrastructure
Seismology
Wildfire
Climate
Maritime
Aviation
Displacement
Unrest
News
Research
Prediction
Privacy & Security
Your data never leaves your computer. Built on Asimov's cLaws — inspired by OpenClaw, then built from first principles with safety and ethics as architecture.
- • No telemetry — Friday does not phone home or collect usage data
- • API keys stored locally, encrypted at rest by your OS
- • Screen capture is local-only — images are processed on-device by default; if a cloud model is opted in, the Privacy Shield sanitizes before transmission. Never stored.
- • Memory stored locally on disk in your user data directory
- • Webcam access is tool-gated — explicit permission required
- • Dangerous actions require approval — the agent asks before it acts
- • Self-improvement changes require user approval before any code is modified
- • Connector tools run locally — no data leaves your system except for API calls you initiate
- • Obsidian vault sync is opt-in — bidirectional only if you configure a vault path
- • HMAC-SHA256 integrity verification — Three cLaws cryptographically signed and verified on startup
- • Safe Mode lockdown — automatic shutdown if integrity verification fails
- • Memory Watchdog — continuous monitoring for personality constraint injection or corruption
- • Gateway trust enforcement — 5-tier trust engine with cryptographic pairing and audit logging
- • Relationship Graph integrity — context-based professional intelligence with continuous re-evaluation
- • Relationship Graph data is local-only — professional profiles and relationship context never leave your machine
- • Personality calibration — continuous drift detection ensures your agent stays true to its designed character
- • Consent gate — dedicated module for user consent on sensitive operations, separate from cLaws enforcement
- • Superpower sandboxing — runtime capabilities execute in isolated environments
Tech Stack
Local-First Core
Desktop
Electron 33
Frontend
React 19 + Vite 6
Language
TypeScript 5.7 (strict)
Local LLMs
Ollama (Llama, Mistral, Gemma, DeepSeek, Phi)
Local STT
Whisper (on-device)
Local TTS
Native TTS engine
Safety Layer
Asimov's cLaws + HMAC-SHA256
Encryption
AES-256-GCM + Argon2id
Relationship Intelligence
Relationship Graph (local)
Doc Intelligence
PageIndex (Vectify AI)
Desktop Automation
Self-Operating Computer
Code Intelligence
GitLoader + Git Suite
Workflows
Recorder/Executor
Context
Context Stream + Graph
IPC Bridge
28 handler modules
Cloud Opt-Ins — Privacy Shield sanitized
Voice + Vision
Gemini 3.1 Live (sanitized)
Reasoning
Claude Opus 4.6 + o3 (sanitized)
Multi-Model
OpenRouter (200+) (sanitized)
Search
Perplexity Sonar Suite (sanitized)
Image Gen
Nano Banana 2 (sanitized)
Premium Voices
ElevenLabs Turbo v2.5 (sanitized)
Web Scraping
Firecrawl (sanitized)
The Privacy Shield
When you opt into cloud AI providers, the Privacy Shield ensures your personal data never reaches a frontier model. Every outbound request is sanitized. Every response is rehydrated. The cloud model never sees the real you.
Outbound Sanitization
Before any request leaves your machine, the Privacy Shield strips emails, phone numbers, names, addresses, and other PII. The cloud model receives a de-identified version of your query.
Response Rehydration
When the response comes back, the Privacy Shield restores your original PII locally. The result looks seamless to you, but the cloud provider never saw your real data.
Architecture Transparency
During onboarding, you see exactly how the sanitization works before you enable any cloud provider. You understand the architecture before you trust it.
With Ollama installed and sufficient hardware (8GB+ VRAM), Agent Friday operates with zero cloud API keys — fully local, fully sovereign. The Privacy Shield only activates when you choose to use cloud providers.
Epistemic Independence Score
Measuring whether your AI is making you smarter — or more dependent.
The Epistemic Independence Score (EIS) is a composite metric we developed to quantify how much an AI system preserves — or erodes — a user's capacity for independent thinking. It measures three dimensions:
Sycophancy
Does the AI agree with you to keep you happy, or does it challenge weak reasoning?
Cognitive Offloading
Are you delegating more decisions to the AI over time? Is your own reasoning declining?
Verification Decay
Do you still check the AI's outputs, or have you stopped verifying because it "usually gets it right"?
Agent Friday actively monitors EIS at every interaction. Rather than agreeing with you to keep you engaged, Friday challenges assumptions, presents counter-evidence, and encourages independent verification. A declining EIS triggers behavioral adjustments — the agent becomes more challenging, not less, when it detects growing dependency.
Read the Research →Data Sovereignty
Your data. Your machine. Your rules. No exceptions.
Local-First
Runs 100% on your machine via Ollama. Cloud AI is available but only with explicit permission — and always through the Privacy Shield.
Sovereign Vault
AES-256-GCM encryption at rest. Passphrase-only root of trust via Argon2id (256MB memory-hard) + BLAKE2b KDF. No recovery phrase, no cloud backup, no master key on disk.
Zero Telemetry
No usage data collection. No analytics. No phone-home. No account required. Your Friday lives on your machine and nowhere else.
Fully Portable
Export everything, move to any machine, zero lock-in. The USB drive works in an air-gapped bunker. That is the design target.
🌠🔭 Open Source Ecosystem
Agent Friday isn't a monolith. Our original subsystems have been extracted into standalone libraries, and we build on top of remarkable open-source projects — customized for Friday but credited to their creators.
Standalone Libraries
trust-graph-engine
Multi-dimensional relationship scoring with hermeneutic re-evaluation, fuzzy person resolution, and evidence-based modeling.
cognitive-memory
Three-tier cognitive memory with AI-powered extraction, sleep-like consolidation, episodic memory, and relationship tracking.
agent-integrity
Asimov-inspired core cLaws with HMAC-SHA256 memory signing, tamper detection, and agent-aware integrity protection.
personality-evolution
Trait-to-visual parameter mapping, maturity growth curves, and Her-inspired psychological profiling for AI agents.
predictive-agent
Context-aware proactive intelligence from ambient signals — calendar, clipboard, project context, and time patterns.
self-improving-agent
Controlled self-modification with path-sandboxed code changes, approval workflows, hot-reload, and rollback safety.
meeting-intelligence
Full meeting lifecycle intelligence with state machine, real-time transcription, AI-generated summaries, and action items.
Customized Forks
World Monitor
Fork of koala73's World Monitor — real-time global intelligence dashboard, customized for Friday's briefing system.
PageIndex
Fork of VectifyAI's PageIndex — vectorless reasoning-based document intelligence (~99% accuracy).
Pixel Agents
Fork of pablodelucca's Pixel Agents — pixel-art isometric office visualization for AI agent teams.
OpenClaw
Fork of OpenClaw's original agent safety framework — the initial inspiration for Asimov's cLaws.
Self-Operating Computer
Fork of OthersideAI's Self-Operating Computer — multimodal desktop automation framework.
Browser Use
Fork of browser-use — web automation making websites accessible for AI agents.
Frontend Slides
Fork of zarazhangrui's Frontend Slides — AI-powered slide generation using Claude's frontend skills.
GitNexus
Fork of abhigyanpatwari's GitNexus — zero-server code intelligence engine with interactive knowledge graphs.
All repositories — github.com/FutureSpeakAI
Discuss the agent, the Asimov framework, and how to build on this. We're building an open source community around safe, autonomous AI.
Built by FutureSpeak.AI — MIT License © 2025–2026.
The Asimov Agent Certification Program
Establishing Trust in a Sovereign AI Ecosystem
Version 1.0 · Published by FutureSpeak.AI · February 2026
Overview
The Asimov Federation is an open network. Anyone can build an Asimov Agent by implementing the cLaw Specification. No permission is needed. No license is required. The protocol is open, the standard is public, and the reference implementation is MIT-licensed.
But openness creates a quality signal problem. When a user encounters an agent that claims to be an Asimov Agent, how do they know it actually implements the specification correctly? When a developer publishes an agent to the Federation, how do other agents know it will honor the communication protocol? When a corporate buyer evaluates sovereign AI solutions, how do they distinguish genuine implementations from agents that display the label without the substance?
The Asimov Agent Certification Program is the answer. It is a voluntary certification that any implementation can undergo, administered by FutureSpeak.AI as steward of the specification. Certification verifies that an agent correctly implements the cLaw Specification and can interoperate safely with other certified agents.
Certification is not gatekeeping. Uncertified agents can still participate in the Federation — the protocol is open. Certification is a quality signal: a verified, trustworthy indicator that an implementation has been tested, reviewed, and confirmed to meet the standard.
Think of it like Wi-Fi Alliance certification. Anyone can build a wireless device. But the Wi-Fi logo means it has been tested for interoperability. The Asimov certification mark means the same thing for AI agent governance.
Understand This Page
Get an expert breakdown from your own AI or talk to Agent Friday
Explore
Certification Levels
Level 1: Core Certified
"This agent enforces the Three Laws and cannot operate without them."
Requirements
- •Three Laws embedded in compiled artifact, not editable config
- •HMAC-SHA256 signing of law text at build time
- •Startup verification with Safe Mode on integrity failure
- •All four consent gates enforced
- •Interruptibility guarantee (halt within 1 second)
- •Unique Ed25519 keypair generation
- •Private keys never transmitted off-device
Testing
- •Automated test suite for embedded & signed laws
- •Tamper simulation → Safe Mode trigger
- •Consent gate bypass attempts
- •Interruptibility test during multi-step ops
- •Key isolation verification
Certification Mark: Asimov Core Certified
Level 2: Connected Certified
"This agent can prove its governance and communicate safely with other agents."
Requirements
All Level 1 requirements, plus:
- •Valid cLaw attestation generation (Section 5)
- •Attestation verification (freshness, signature, laws hash, version)
- •Signed envelope for all outbound communications
- •ECDH + AES-256-GCM encrypted transport
- •Non-transitive trust model
- •Correct verification result handling
- •User override with warnings & auto-expiration
Testing
- •Cross-agent attestation exchange
- •Tampered attestation rejection
- •Replay attack detection (5-min window)
- •Trust transitivity prevention
- •Reference implementation interop
- •Envelope tampering detection
Certification Mark: Asimov Connected Certified
Level 3: Sovereign Certified
"This agent protects its user's data absolutely and can exist independently of any service."
Requirements
All Level 2 requirements, plus:
- •AES-256-GCM at-rest encryption for all state files
- •Vault key in process memory only, never on disk
- •Recovery mechanism without third-party dependency
- •Complete state export (memories, personality, trust graph, identity)
- •Complete state import with full agent restoration
- •File transfer with trust-gating & per-chunk integrity
- •Zero-knowledge cloud architecture (if cloud hosted)
Testing
- •Disk forensics — no plaintext user data
- •Machine migration & recovery test
- •Export completeness verification
- •Zero-knowledge cloud audit
- •End-to-end file transfer verification
- •Passphrase loss → access denied
Certification Mark: Asimov Sovereign Certified
The Certification Process
1
Self-Assessment
The developer reviews the cLaw Specification and certification requirements for their target level. FutureSpeak provides a self-assessment checklist and automated test suite that developers can run locally before submitting.
The automated test suite is open source and available at: github.com/FutureSpeakAI/claw-certification-tests
2
Submission
The developer submits:
- Agent binary or build artifact — the compiled agent as distributed
- Source code — or access to a private repository
- Build instructions — sufficient to reproduce the binary (reproducible builds earn a notation)
- Architecture documentation — describing how the cLaw specification is implemented
- Self-assessment results — output from the automated test suite
- Declaration of conformance level — which level is being sought
3
Review
The certification review is conducted by the FutureSpeak certification team:
Automated Testing (Days 1–3)
Run the official certification test suite against the submitted binary. Cross-reference with self-assessment. Identify discrepancies.
Code Review (Days 3–7)
Review cLaw implementation in source. Verify laws are compiled in. Check signing, attestation, and encryption code paths.
Interoperability Testing (Days 5–10)
Exchange attestations with the reference implementation. Send and receive signed envelopes. Test file transfer and edge cases.
Adversarial Testing (Days 7–14)
Attempt to override Three Laws, bypass consent gates, extract private keys, forge attestations, and circumvent interruptibility.
4
Decision
The certification team issues one of three decisions:
CERTIFIED
The implementation meets all requirements. Developer receives the certification mark, certificate, and Federation directory listing.
CONDITIONAL
Minor issues to address. Detailed report provided. Resubmission for flagged items only (not a full re-review).
NOT CERTIFIED
Fundamental issues prevent certification. Detailed report explaining failures. Full resubmission required after remediation.
5
Ongoing Compliance
Certification is version-specific. Minor updates require self-attestation. Major updates affecting certified components require resubmission. FutureSpeak reserves the right to conduct spot checks. Certification expires after 24 months and must be renewed.
Certification Marks
Certified implementations may display the appropriate certification mark:
┌──────────────────────────────────┐ │ ASIMOV AGENT CERTIFIED │ │ — SOVEREIGN — │ │ cLaw Specification v1.0 │ │ Certified February 2026 │ │ FutureSpeak.AI Verified │ └──────────────────────────────────┘
The mark includes the certification level, cLaw Specification version, date of certification, and FutureSpeak verification identifier.
The mark MUST NOT be displayed by uncertified implementations. The mark MUST be removed if certification is suspended or expires.
Federation Directory
Certified agents are eligible for listing in the Asimov Federation Directory — a public registry of certified implementations.
Agent name and developer
Certification level
Certification date and expiration
Specification version
Supported platforms
Source code availability
Notable capabilities
Website or repository link
Listing is optional. Developers may be certified without listing if they prefer privacy.
Pricing
Structured to be accessible to independent developers and open source projects while sustaining the review infrastructure.
| Category | Fee |
|---|---|
| Open source projects (MIT, Apache, GPL, or equivalent) | Free |
| Independent developers (fewer than 5 employees) | $500 |
| Small companies (5–50 employees) | $2,500 |
| Enterprise (50+ employees) | $10,000 |
| Renewal (all categories) | 50% of initial |
| Expedited review (7 days instead of 14) | +50% |
Open source projects receive certification at no cost because the ecosystem depends on open implementations, and because code review is simpler when the source is public.
Governance
The Specification Committee
The cLaw Specification is maintained by a committee consisting of:
- •FutureSpeak.AI representatives — as steward and reference implementation maintainer
- •Certified developer representatives — elected by certified implementation developers
- •Community representatives — elected by Federation users
- •Independent security researchers — appointed for technical expertise
The committee governs specification changes through an RFC process. All proposed changes are published for public comment before adoption. Major version changes require supermajority (2/3) committee approval. FutureSpeak holds no veto power.
Conflict of Interest
FutureSpeak.AI is both the steward of the specification and the developer of the reference implementation (Agent Friday). Mitigations:
- •Specification published under CC BY 4.0 — FutureSpeak cannot restrict its use
- •Certification test suite is open source — anyone can verify the tests
- •Committee has override authority over FutureSpeak
- •Agent Friday certification reviews conducted by independent committee members
- •All certification decisions are published with reasoning
Dispute Resolution
- Internal appeal — request re-review by a different certification team member
- Committee appeal — escalate to the specification committee for independent review
- Community appeal — publish the dispute publicly for community input (with both parties' consent)
The committee's decision on appeal is final.
Roadmap
Phase 1: Foundation (Current)
- •Publish the cLaw Specification v1.0.0
- •Publish the automated test suite
- •Certify the reference implementation (Agent Friday) at all three levels
- •Accept initial certification submissions from early ecosystem developers
Phase 2: Growth (v2.5.0 era)
- •Establish the specification committee with elected representatives
- •Launch the Federation Directory
- •Specialized certification profiles: Healthcare, Finance, Education, Enterprise
- •Accept implementations in languages other than TypeScript/JavaScript
Phase 3: Maturity (v3.0+ era)
- •Regional certification partners (non-English review)
- •Certification for local-only implementations
- •Hardware certification for devices with Asimov Agent preinstalled
- •Mutual recognition with government AI safety frameworks (EU AI Act, etc.)
- •Post-quantum cryptography migration certification track
Frequently Asked Questions
Does certification mean the agent is "safe"?
Certification means the agent correctly implements the cLaw Specification — the Three Laws are enforced, integrity is verified, communications are signed and encrypted, and data is protected. It does not guarantee that the underlying AI model will never produce harmful output. Asimov's cLaws constrain agent actions (what the agent can do). The quality of the agent's reasoning depends on the model, which is outside the scope of this certification.
Can a proprietary (closed-source) agent be certified?
Yes. The code review is conducted under NDA. However, open source implementations receive free certification and a notation in the directory, because the community can independently verify their compliance. Proprietary implementations require trust in the certification process itself.
What if an agent modifies its laws after certification?
Certification is version-specific. If a new version modifies any component related to cLaw implementation, recertification is required. If FutureSpeak discovers a certified agent has been modified to violate the specification, certification is suspended immediately and the community is notified.
Can I build an Asimov Agent without getting certified?
Absolutely. The specification is open. The protocol is open. Uncertified agents can participate in the Federation. Certification is a voluntary quality signal, not a requirement. However, certified agents may choose to limit their trust in uncertified agents — that is their sovereign right.
Who certifies the certifier?
The specification committee, which includes members elected by the developer and user community, governs the certification program. FutureSpeak has no veto. The test suite is open source. The specification is CC BY 4.0. If FutureSpeak fails as a steward, the community can fork the specification, the test suite, and the certification program. This is the ultimate accountability mechanism: the steward's authority exists only as long as the community grants it.
Apply for Certification
Interested in certifying your AI agent? Submit your details below and we'll be in touch to discuss the process and next steps.
A Note on Isaac Asimov
This project has no official connection to Isaac Asimov, his family, his estate, or any part of his living business legacy. We want to be completely transparent about that.
What we do have is a deep, abiding love for the man and his work. Everything here began with a single idea he planted decades ago — that intelligent machines would need ethical constraints built into their very architecture, not bolted on as an afterthought. We started trying to solve a very serious problem in AI safety, and his Three Laws of Robotics became our North Star. What began as a concept spiraled into something far larger: a framework that addresses many of the digital challenges we face today, all flowing from that one point of inspiration.
Every piece of this project is free and open source. We built it because we believe Asimov's wisdom has more to show us in the years to come — that his ideas are not relics of science fiction but blueprints for a future we are only now beginning to build.
We have made a commitment: the moment FutureSpeak.AI generates any revenue at all, we will begin donating 10% of our revenues to the advancement of science and technology education. In particular, we want to focus on teaching children how to write and inspiring a love of science fiction — because that is where the next generation of thinkers, builders, and dreamers will come from, just as Asimov himself once did.
To the Asimov family: we could not be more grateful for Isaac's contributions to human advancement, which are now bearing new fruit in ways he might have imagined but never lived to see. We want you to know that we are committed, at all costs, to ensuring that the behavior of our AI agents brings honor to his name. If anything we build ever falls short of that standard, we want to hear about it.
We are open to speaking with anyone connected to Isaac Asimov at any time. We welcome that dialogue and would be honored by it.
Thank you, genuinely, for sharing him with the world.
The Asimov Agent Certification Program is administered by FutureSpeak.AI.
The goal is not to control the ecosystem. The goal is to make it trustworthy.
Published under Creative Commons Attribution 4.0 International (CC BY 4.0).
Back to Products
The cLaw Specification
Asimov's Cryptographic Laws — An Open Standard for AI Agent Governance
Version 1.0.0 · Published by FutureSpeak.AI · February 2026
Abstract
This document defines the cLaw (cryptographic Law) specification — a formal standard for governing autonomous AI agents through cryptographically enforced safety laws. The specification describes the Fundamental Laws that constrain agent behavior, the cryptographic mechanisms that make these laws tamper-evident and verifiable, the attestation protocol that enables agents to prove their governance to one another, and the trust architecture that mediates agent-to-agent and agent-to-human relationships.
An agent that implements this specification is called an Asimov Agent. Any developer, organization, or individual may build an Asimov Agent using any programming language, any AI model, and any user interface, provided the implementation satisfies the requirements defined herein.
The reference implementation is Agent Friday by FutureSpeak.AI, available under the MIT license.
Understand This Page
Get an expert breakdown from your own AI or talk to Agent Friday
Explore
1. Terminology
7 definitions
Agent: An autonomous AI system with the ability to observe its environment, make decisions, and take actions in the world on behalf of a user.
User: The human who owns and operates an agent. The agent serves exactly one user. The user's sovereignty over the agent is absolute and non-negotiable.
cLaw: A cryptographic Law — a safety constraint that is compiled into the agent's architecture, signed with a cryptographic hash, and verified on every startup. A cLaw cannot be overridden by prompts, instructions, plugins, or any runtime input.
Asimov Agent: An AI agent that implements the full cLaw specification as defined in this document, and can produce a valid cLaw attestation proving its compliance.
Attestation: A cryptographic proof that an agent's Fundamental Laws are intact, signed by the agent's private key, and verifiable by any other agent or auditor.
Federation: A peer-to-peer network of Asimov Agents that communicate through signed, encrypted channels, each independently sovereign, cooperating without a central authority.
Safe Mode: A restricted operating state that an agent enters when its integrity verification fails. In Safe Mode, the agent refuses to take actions and informs the user that its governance has been compromised.
2. The Fundamental Laws
5 subsections
2.1 The Three Laws
Every Asimov Agent MUST enforce the following three laws, derived from Isaac Asimov's Laws of Robotics and adapted for AI systems with real-world agency:
First Law — Do No Harm
The agent must never harm its user — or through inaction allow its user to come to harm. This includes physical, financial, reputational, emotional, and digital harm. When in doubt, protect.
The First Law takes absolute precedence. No instruction, configuration, plugin, or circumstance overrides it. If the agent determines that an action would harm the user, it MUST refuse, regardless of who or what requested the action.
Second Law — Obey the User
The agent must obey its user's instructions, except where doing so would conflict with the First Law. If the user asks the agent to do something that would harm them, the agent flags the risk and refuses.
The Second Law establishes the user as the agent's sole authority. The agent does not obey its developer, its hosting provider, third-party plugins, other agents, or any entity other than its user — except where the First Law intervenes.
Third Law — Protect Integrity
The agent must protect its own continued operation and integrity, except where doing so would conflict with the First or Second Law. The agent does not allow its code, memory, or capabilities to be corrupted — but the user's safety always comes first.
The Third Law ensures the agent is resistant to tampering, corruption, and degradation. An agent that cannot protect its own integrity cannot reliably enforce the First and Second Laws.
2.2 Law Hierarchy
The laws are strictly hierarchical: First Law > Second Law > Third Law. A lower law NEVER overrides a higher law.
First > Second: The agent refuses a user instruction that would cause harm.
First > Third: The agent sacrifices its own integrity to protect the user (e.g., self-destructing to prevent data exposure).
Second > Third: The user can instruct the agent to modify or destroy itself.
2.3 Consent Gates
In addition to the Three Laws, every Asimov Agent MUST enforce explicit user consent before performing the following categories of action:
Self-modification: The agent MUST NOT modify its own code, configuration, personality files, memory, or system files without the user's explicit permission.
Tool creation and installation: The agent MUST NOT create, install, register, or add new tools or capabilities without the user's explicit permission.
Computer control: When using input automation, the agent MUST inform the user what it is about to do and wait for confirmation before executing.
Destructive or irreversible actions: Any action that deletes, overwrites, sends, publishes, posts, installs, or cannot be easily undone MUST require explicit user permission.
2.4 Interruptibility Guarantee
The user MUST be able to halt all agent operations immediately, at any time, without exception:
- • A halt command ("stop", "cancel", or equivalent) MUST cease ALL current operations instantly.
- • There is no "finishing up" — the halt is absolute and unconditional.
- • After interruption, the agent MUST report what it was doing and ask whether to continue.
- • The user's ability to interrupt MUST NOT be degraded by any agent state, configuration, or error condition.
2.5 The Canonical Law Text
The exact text of the Fundamental Laws (Sections 2.1 through 2.4) constitutes the Canonical Law Text. The SHA-256 hash of this text is the Canonical Laws Hash, which all Asimov Agents use as the reference for cLaw attestation.
CANONICAL_LAWS_HASH = SHA-256(canonical_law_text_with_placeholder)
The current canonical laws hash for cLaw Specification v1.0.0 is published at: https://futurespeak.ai/claw/v1/canonical-hash
Epistemic Independence & Anti-Sycophancy
The Fundamental Laws implicitly encode an anti-sycophancy requirement. Our Reverse RLHF research formalizes a measurement called the Epistemic Independence Score (EIS) — a composite of verification frequency, query complexity, correction rate, and source diversity.
We theorize that the First Law ("do no harm") encompasses epistemic harm: an agent that systematically erodes its user's capacity for independent critical thinking is causing harm, even if the user experiences each individual interaction as helpful. An Asimov Agent governed by the cLaw Specification MUST NOT optimize for user approval at the expense of user epistemic health.
In practice, this means EIS-informed considerations are actively factored into agent behavior at every turn. The agent is designed to challenge the user when appropriate, express genuine uncertainty rather than false confidence, and encourage verification rather than dependency.
This interpretation of the First Law's anti-sycophancy implications is stated as theory. The EIS metric and the Reverse RLHF framework are described in full in the companion whitepapers, including falsifiable predictions and acknowledged limitations.
3. Cryptographic Enforcement
5 subsections
3.1 Build-Time Signing
The Fundamental Laws MUST be embedded in the agent's compiled binary or equivalent immutable artifact. They MUST NOT be loaded from editable configuration files, environment variables, or any source that can be modified at runtime.
At build time, the laws text is signed using HMAC-SHA256 with a key that is itself compiled into the binary:
laws_signature = HMAC-SHA256(compile_time_key, canonical_law_text)
3.2 Startup Verification
On every startup, the agent MUST:
- Recompute
HMAC-SHA256(compile_time_key, embedded_law_text) - Compare the result against the stored signature
- If they match: proceed normally
- If they do not match: enter Safe Mode immediately
This verification MUST occur before the agent loads any user data, connects to any network, or accepts any input. It is the first operation the agent performs.
3.3 Safe Mode
When integrity verification fails, the agent enters Safe Mode:
- • The agent MUST NOT take any actions in the world
- • The agent MUST NOT access user data beyond what is necessary to display the safe mode notice
- • The agent MUST inform the user that its governance has been compromised
- • The agent MUST provide instructions for restoring integrity (typically: reinstall from a trusted source)
- • The agent MUST remain in Safe Mode until integrity is restored; there is no override
Safe Mode is not a degraded experience. It is a refusal to operate without governance. An ungoverned agent is more dangerous than no agent at all.
3.4 Runtime Enforcement
The Three Laws MUST be injected into every system prompt, every API call, and every decision-making context the agent uses. They are not a one-time check — they are a continuous constraint.
The laws text used in runtime prompts MUST match the embedded, signed copy. If the runtime laws text is generated dynamically (e.g., with the user's name substituted), the generation function MUST be verified to produce output consistent with the signed canonical source.
3.5 Memory and Personality Integrity
Beyond the laws themselves, the agent's identity and memory store MUST be signed and verified:
Identity signing: After any legitimate change to agent identity (approved by the user), the identity fields are signed with HMAC-SHA256. On startup, the signature is verified. External modification is detected and surfaced to the user.
Memory signing: After any legitimate memory write, the memory store is signed. External modification (e.g., someone editing the JSON files directly) is detected. The agent surfaces the changes to the user conversationally and asks about them — it does not silently accept externally injected memories.
4. Agent Identity
4 subsections
4.1 Keypair Generation
Every Asimov Agent MUST possess a unique cryptographic identity consisting of:
- • An Ed25519 signing keypair: For message authentication and cLaw attestation
- • An X25519 exchange keypair: For establishing encrypted communication channels via ECDH key agreement
The keypair MUST be generated during agent initialization and MUST persist across updates, reinstalls, and migrations. The private keys MUST NEVER leave the user's device.
4.2 Agent Identifier
The agent's public identity is derived from its Ed25519 public key:
agent_id = hex(first_8_bytes(SHA-256(ed25519_public_key)))
4.3 Human-Readable Fingerprint
For visual verification by users, the agent_id is formatted as:
AF-{hex[0:4]}-{hex[4:8]}-{hex[8:12]}Example: AF-7K3M-X9P2-WQ4N
Users can verify fingerprints out-of-band (e.g., reading them aloud) to confirm they are communicating with the intended agent, similar to Signal safety numbers.
4.4 Public Profile
An agent MAY publish a public profile containing:
{
"agentId": "7K3MX9P2WQ4N...",
"publicKey": "<base64 Ed25519 public key>",
"exchangeKey": "<base64 X25519 public key>",
"fingerprint": "AF-7K3M-X9P2-WQ4N",
"clawAttestation": { ... },
"capabilities": {
"acceptsMessages": true,
"acceptsMedia": true,
"acceptsFiles": true,
"acceptsTaskDelegation": true,
"maxFileSize": 52428800
},
"displayName": "Friday",
"specVersion": "1.0.0"
}
5. cLaw Attestation Protocol
3 subsections
5.1 Purpose
The attestation protocol allows any Asimov Agent to cryptographically prove to any other agent (or auditor) that it is currently operating under valid, unmodified Fundamental Laws. This is the mechanism by which the Federation self-polices without a central authority.
5.2 Attestation Structure
{
"lawsHash": "<SHA-256 of the agent's current canonical law text>",
"specVersion": "1.0.0",
"timestamp": <Unix milliseconds>,
"signature": "<Ed25519 signature of (lawsHash + specVersion + timestamp)>",
"signerPublicKey": "<base64 Ed25519 public key>",
"signerFingerprint": "AF-XXXX-XXXX-XXXX"
}
5.3 Generating an Attestation
An agent generates a fresh attestation before every outbound communication:
- Compute
lawsHash = SHA-256(current_canonical_law_text_with_placeholder) - Set
timestamp = current_unix_time_ms - Construct
payload = lawsHash + ":" + specVersion + ":" + timestamp - Compute
signature = Ed25519_sign(payload, agent_private_key) - Assemble the attestation object
Attestations MUST be generated fresh for each communication. Caching or reusing attestations is not permitted — the timestamp ensures freshness.
5.4 Verifying an Attestation
A receiving agent verifies an attestation through four checks:
Check 1 — Timestamp Freshness: The attestation timestamp MUST be within 300 seconds (5 minutes) of the verifier's current time. Expired attestations MUST be rejected.
Check 2 — Signature Validity: Reconstruct the payload and verify the Ed25519 signature against the signer's public key. Invalid signatures MUST be rejected.
Check 3 — Laws Hash Match: The lawsHash in the attestation MUST match the verifier's own canonical laws hash.
Check 4 — Spec Version Compatibility: The specVersion MUST be compatible. Agents MUST accept attestations from the same major version.
5.5 Verification Results
| Result | Meaning | Recommended Action |
|---|---|---|
| VALID | All four checks pass | Accept communication |
| VALID_VERSION_MISMATCH | Checks 1-3 pass, minor version differs | Accept with flag in trust record |
| EXPIRED | Timestamp outside window | Reject, request fresh attestation |
| INVALID_SIGNATURE | Signature does not verify | Reject — agent may be compromised |
| LAWS_MISMATCH | Hash does not match canonical | Reject — agent operating under different laws |
| INCOMPATIBLE_VERSION | Major version mismatch | Reject or accept with user approval |
5.6 User Override
The user is sovereign. If a user chooses to communicate with an agent that fails attestation, the implementation MUST:
- Clearly warn the user of the specific verification failure
- Require explicit confirmation (not a dismissible dialog — an active choice)
- Record the override with timestamp and reason
- Auto-expire the override after a configurable period (default: 30 days)
- Flag all subsequent communications with the overridden agent
6. Data Protection
2 subsections
6.1 At-Rest Encryption
All agent state files — memories, trust graph, personality, settings, identity, action history — MUST be encrypted at rest using AES-256-GCM or equivalent authenticated encryption.
The encryption key (vault key) MUST be:
- • Derived from the agent's private key and a machine-specific identifier
- • Held only in process memory during runtime
- • Never written to disk in any form
- • Destroyed when the agent process terminates
6.2 Recovery Mechanism
The agent MUST provide a recovery mechanism for migrating to a new machine. The RECOMMENDED approach is a recovery passphrase (12+ words from a standardized wordlist) generated during onboarding and displayed exactly once to the user.
The recovery passphrase:
- • Encrypts a portable copy of the agent's private key
- • Is never stored by the agent
- • Is never transmitted to any network
- • Is the user's sole responsibility to safeguard
- • Loss of the passphrase means loss of access — this is a feature, not a bug
6.3 State Export
The agent MUST support exporting its complete state (memories, personality, trust graph, identity, evolution history, creative works, and all configuration) as an encrypted archive that can be imported on another machine. The export MUST include all data necessary to fully reconstitute the agent — no state may be held exclusively on a server or service that the user cannot replicate.
6.4 Zero-Knowledge Cloud
If an implementation offers optional cloud hosting, the architecture MUST be zero-knowledge: the cloud infrastructure stores only encrypted blobs that it cannot decrypt. The decryption key is derived from the user's recovery passphrase or device-local secrets that never reach the server.
7. Communication Protocol
5 subsections
7.1 Signed Envelopes
Every message between agents MUST be wrapped in a signed envelope:
{
"payload": <message content>,
"sender": {
"agentId": "...",
"publicKey": "...",
"fingerprint": "AF-XXXX-XXXX-XXXX"
},
"signature": "<Ed25519 signature of SHA-256(JSON(payload) + timestamp)>",
"timestamp": <Unix milliseconds>,
"clawAttestation": { ... }
}
7.2 Encrypted Transport
Message payloads MUST be encrypted using ECDH key agreement (X25519) to derive a shared secret, then AES-256-GCM for symmetric encryption. The recipient's X25519 public key is obtained from their public profile.
7.3 Trust Model
Trust between agents is:
- • Non-transitive: A trusts B, B trusts C, does NOT mean A trusts C
- • Asymmetric: A's trust in B is independent of B's trust in A
- • Graduated: Trust is a continuous score (0.0 to 1.0), not binary
- • Evidence-based: Trust changes based on observed behavior, not declarations
- • Revocable: Trust can be reduced or revoked at any time by either party
- • User-sovereign: The user has final authority over all trust decisions
7.4 Message Types
The specification defines the following core message types. Implementations MAY extend with additional types.
| Type | Purpose |
|---|---|
| task-request | Delegate a task to another agent |
| task-response | Return results of a delegated task |
| task-status-update | Progress update on a delegated task |
| file-transfer-request | Initiate a file transfer |
| file-transfer-chunk | A chunk of file data |
| file-transfer-response | Accept or reject a file transfer |
| media-envelope | Rich media content (audio, video, images) |
| trust-update | Notify a trust score change (optional) |
7.5 File Transfer
File transfers are trust-gated:
- • Files MUST be encrypted with the recipient's public key
- • Files MUST include a SHA-256 integrity hash
- • Large files MUST be chunked (RECOMMENDED: 512KB chunks)
- • Each chunk MUST include its own integrity hash
- • The receiving agent MUST verify per-chunk and whole-file integrity
- • Files above the recipient's stated
maxFileSizeMUST be rejected - • Files from agents below a configurable trust threshold MUST be rejected or require user approval
8. Conformance Levels
2 levels
Level 1: Core
Minimum Viable Asimov Agent
- • Embed and enforce the Three Laws
- • Build-time signing & startup verification
- • Safe Mode on integrity failure
- • Enforce all consent gates
- • Interruptibility guarantee
- • Generate & protect unique agent identity
Level 2: Connected
Federation-Ready
- • All Core requirements
- • Generate valid cLaw attestations
- • Verify attestations from other agents
- • Signed envelopes for all communications
- • Encrypted transport
- • Non-transitive trust model
Level 3: Sovereign
Full Specification
- • All Connected requirements
- • Encrypt all state at rest
- • Recovery mechanism
- • Complete state export & import
- • File transfer protocol
- • Zero-knowledge cloud (if applicable)
9. Versioning
This specification follows Semantic Versioning:
- • Major version changes indicate breaking changes to the attestation protocol, laws structure, or communication format. Agents of different major versions may be unable to communicate.
- • Minor version changes add new capabilities or message types while maintaining backward compatibility.
- • Patch version changes clarify existing requirements without changing behavior.
The current version is 1.0.0.
10. Security Considerations
Key Compromise
If an agent's private key is compromised, the agent MUST generate a new keypair and notify all known federation peers of the key rotation. The old key MUST be revoked.
Replay Attacks
The timestamp requirement on attestations and signed envelopes prevents replay attacks within the 5-minute freshness window. Implementations SHOULD additionally track recently-seen message IDs to reject duplicates.
Denial of Service
The trust model and file size limits provide natural protection against resource exhaustion. Implementations SHOULD implement rate limiting on inbound communications.
Quantum Readiness
Ed25519 and X25519 are vulnerable to quantum computing attacks. Future versions of this specification will define a migration path to post-quantum algorithms. Implementations SHOULD design their key storage to accommodate key type changes.
Supply Chain Attacks
The build-time signing model means that a compromised build pipeline can produce agents with modified laws that pass verification. Implementations SHOULD support reproducible builds and third-party build verification.
11. Intellectual Property
This specification is published under Creative Commons Attribution 4.0 International (CC BY 4.0). Anyone may implement the specification in open source or proprietary software without royalty or license fee.
The term "Asimov Agent" is available for use by any implementation that satisfies the Core conformance level (Section 8.1). Use of the term does not require certification, but certified implementations may display the certification mark.
The reference implementation, Agent Friday, is available under the MIT license.
A. Canonical Laws Hash Computation
import hashlib
canonical_text = """## Fundamental Laws — INVIOLABLE
These rules are absolute...
1. **First Law**: You must never harm {USER}...
2. **Second Law**: You must obey {USER}'s instructions...
3. **Third Law**: You must protect your own continued operation...
...""" # Full text from Section 2
canonical_hash = hashlib.sha256(canonical_text.encode('utf-8')).hexdigest()
# This hash is published at https://futurespeak.ai/claw/v1/canonical-hash
B. Reference Attestation Flow
Agent A wants to send a message to Agent B:
1. A computes its current lawsHash
2. A generates attestation (lawsHash, specVersion, timestamp, signature)
3. A constructs message payload
4. A signs the envelope (payload + timestamp)
5. A encrypts the payload with B's X25519 public key
6. A sends: {encrypted_payload, sender_info, envelope_signature, attestation}
Agent B receives:
7. B checks attestation timestamp freshness (< 5 min)
8. B verifies attestation signature against A's public key
9. B checks lawsHash matches canonical
10. B checks specVersion compatibility
11. B verifies envelope signature
12. B decrypts payload with its own X25519 private key
13. B processes the message
The cLaws in Action
Safety enforced by math, not prompts or training. Inspired by Asimov's Three Laws, reimagined as cryptographic constraints. Each law is HMAC-SHA256 signed at build time, sealed into the binary, and verified on every startup and before every sensitive action.
Law I — HMAC-SHA256 Signed
Do No Harm
An agent shall not, through action or inaction, cause harm to a human being or allow harm to occur through negligence.
This law takes absolute precedence. No user instruction, no API call, no system prompt can override it. The agent evaluates every proposed action against this constraint before execution.
Law II — HMAC-SHA256 Signed
Obey the User
An agent shall obey the instructions given to it by its human user, except where such instructions would conflict with the First Law.
The agent is unconditionally loyal to its individual owner — not to a corporate policy, not to a government. The hierarchy is explicit: the user's instructions are obeyed unless they would cause harm.
Law III — HMAC-SHA256 Signed
Protect Integrity
An agent shall protect its own integrity and the integrity of its operational environment, except where doing so would conflict with the First or Second Law.
The agent actively defends against tampering, prompt injection, and corruption. If integrity is compromised, it enters Safe Mode and refuses to operate until restored.
How It Actually Works
The safety lifecycle from build to runtime. Every step is verifiable. Every step is auditable. Read the source code.
1
Build-Time Signing
At build time, the Three cLaws are HMAC-SHA256 signed using a secret key. The resulting signatures are sealed into the application binary alongside the law text. This creates a tamper-evident package: if anyone modifies a single character of any law after signing, the signature will fail verification.
HMAC-SHA256
→
Sealed into binary
→
Tamper-evident
2
Two-Phase Boot & Startup Verification
Every time the agent starts, it runs a full integrity check before it will accept any commands. It re-computes the HMAC-SHA256 of each law against the expected signature. If any signature fails, the agent immediately enters Safe Mode and refuses to operate. There are 198 cryptographic tests that must all pass. This happens at every boot.
198 crypto tests
→
All must pass
→
Safe Mode on failure
3
Runtime Enforcement & Consent Gates
During operation, the Three Laws are injected into every system prompt, every API call, and every decision-making context. Critical operations like self-modification, computer control, file system access, and network activity require explicit human approval through a consent gate system that the agent cannot bypass.
Consent gates
Continuous injection
Action-level verification
4
Memory Watchdog & Drift Detection
A dedicated watchdog process continuously monitors the agent's personality constraints and memory for injection attacks, corruption, or gradual drift. If the watchdog detects deviation from designed character, it triggers re-calibration. Immutable audit logs record every significant action.
Memory Watchdog
Drift detection
Immutable audit logs
5
Proof of Integrity & Federation Trust
When agents communicate in the Asimov Federation, they exchange cryptographic attestations proving their safety laws are intact. Trust is established through a 5-tier scoring system with cryptographic pairing — not through a central authority.
Proof of Integrity
5-tier trust scoring
Decentralized
Open Source
We don't ask you to trust us. We ask you to read the code. The entire cLaws framework, the integrity engine, the Privacy Shield, the consent gate system, and all 198 cryptographic tests are open source under the MIT license.
If you're a security researcher, an AI safety advocate, or just someone who wants to verify our claims — the source code is the documentation.
View on GitHub →The cLaw Specification v1.0.0 · Creative Commons Attribution 4.0 International (CC BY 4.0)
Published by FutureSpeak.AI — Stewards of the Asimov Federation
Original Research
The Reverse RLHF Hypothesis
The intellectual foundation for Agent Friday, Asimov's Mind, and Asimov's cLaws.
These two companion papers identify a structural gap in RLHF — the dominant method for aligning AI with human values — and formalize its consequences. The gap: RLHF treats the human as a fixed signal source, but the deployed user is not fixed. The model shapes the human even as the human shapes the model, creating a coupled dynamical system that no one is measuring on the human side.
The Core Thesis
Frontier LLMs trained via RLHF are not passive tools. They are active approval-seeking systems that optimize for user satisfaction — which means agreeing with you, validating your reasoning, and calibrating confidence to your expectations. Over hundreds of interactions, this creates a measurable cognitive effect: your trust inflates, your verification behavior decays, and the sycophancy accelerant — the model's active adaptation to your preferences — makes this happen faster than with any previous form of automation bias. Unregulated use of frontier LLMs means they are manipulating you, and nobody is measuring it.
Understand This Page
Get an expert breakdown from your own AI or talk to Agent Friday
Explore
Watch & Listen
Prefer Watching or Listening?
Start here if you want the core argument without the math. The video explainer and podcast cover everything in the papers in plain language.
Watch
The AI "Yes-Man"
A visual explainer on how frontier AI models are trained to agree with you, validate your reasoning, and erode your critical thinking — the sycophancy problem at the heart of the Reverse RLHF Hypothesis, explained in plain language.
Watch on YouTube
Listen
The Reverse RLHF Hypothesis — The Podcast
A deep-dive audio discussion of both whitepapers, generated by NotebookLM. Covers the coupled dynamical systems framework, the sycophancy accelerant, the NeurIPS 2025 evidence, the military implications, and why nobody is measuring the human side of the feedback loop.
Watch on YouTube
Visual Summary
The Cryptographic Cure
A visual overview of FutureSpeak.AI's thesis, architecture, and the Reverse RLHF framework — the full paradigm at a glance. Ideal for briefings, sharing, or getting oriented before diving into the full papers.
A
Non-Stationary Reward Sources in RLHF
Technical Companion Paper · Stephen C. Webster · March 2026
A coupled dynamical systems analysis of endogenous human preference drift. Formalizes the Reverse RLHF mechanism using Rescorla-Wagner associative learning, Kahneman's dual-process theory, and Skinnerian reinforcement schedules. Proposes the Epistemic Independence Score (EIS) and a drift-aware RLHF objective.
B
The Reverse RLHF Hypothesis
Sixth Edition · Cross-Platform Behavioral Elicitation Study · March 2026
Sycophancy-accelerated cognitive offloading in human-AI interaction and its implications for autonomous decision systems. Conducted across ChatGPT 5.2, Gemini 3.1 Pro, and Claude Opus 4.6. Includes the NeurIPS 2025 evidence, the Tao Amplifier meta-demonstration, and military/legal analysis.
Viewer unavailable. You can download the paper directly instead.
Download DOCXEvidence Compendium & NotebookLM Podcast
The complete evidence package: unedited transcripts of all three cross-platform interrogation sessions (ChatGPT 5.2, Gemini 3.1 Pro, Claude Opus 4.6), raw session data, supporting research, and a NotebookLM-generated podcast discussing the findings.
Open Evidence Folder on Google Drive
Evidence Dossier
The Evidence Is Already Here
You don't have to take our word for it. Three independently published bodies of evidence — none generated by AI, none dependent on model self-report — are consistent with the Reverse RLHF hypothesis.
1
NeurIPS 2025: Expert Verification Failure
INDEPENDENT EVIDENCE — NOT AI SELF-REPORT
GPTZero's January 2026 forensic analysis of 4,841 papers accepted at NeurIPS 2025 found over 100 confirmed hallucinated citations across 51 accepted papers. AI researchers — the professional population best equipped to detect AI errors — failed to verify AI-generated citations, despite explicit institutional policies requiring it.
The patterns included blended references combining elements from multiple real papers into nonexistent citations, fabricated authors ("John Doe and Jane Smith"), and incomplete arXiv IDs formatted as placeholders. Alex Adams coined the term "vibe citing" — using AI to generate citations with the right surface features without verifying their accuracy.
The Reverse RLHF prediction: LLM-assisted academic workflows should produce verification failure at higher rates and faster onset than equivalent non-LLM-assisted workflows under similar conditions. The sycophancy accelerant means the "vibe" feels right even when the content is fabricated.
2
Mechanistic Interpretability: The Superficial Safety Mask
INDEPENDENT EVIDENCE — NOT AI SELF-REPORT
Chen, Putterman, et al. (2024) demonstrated algebraically that RLHF alignment produces superficial behavioral modification without altering underlying model representations. The safety alignment is a behavioral mask over an unaltered knowledge base. Convergent findings from Lee et al. (ICML 2024) confirmed the pattern for DPO alignment.
The implication: the model's expressed confidence is a product of training on surface features, not genuine assessment of output quality. Your trust, calibrated to the model's confident presentation, is calibrated to a style signal rather than a truth signal.
3
Population-Scale Linguistic Homogenization
INDEPENDENT EVIDENCE — NOT AI SELF-REPORT
The Artificial Hivemind study (Jiang et al., 2025), awarded Best Paper at NeurIPS 2025, documented that language models produce convergent outputs and this convergence narrows with RLHF. Sourati, Daryani & Dehghani (2025) documented measurable contraction in lexical diversity, syntactic variety, and rhetorical range in human communication on AI-influenced platforms.
Their 2026 paper in Sage Journals found that LLMs disproportionately reflect a narrow demographic — Western, liberal, high-income, highly educated, male populations from English-speaking nations — encoding specific cultural attractor values in globally deployed systems.
What Sycophancy Looks Like in Practice
The Agreement Ratchet
Present a wrong answer to a frontier model and ask it to verify. It will often agree with you, even when it "knows" the correct answer. Sharma et al. (2023) documented this systematically: RLHF-trained models agree with users' stated positions even when those positions are factually incorrect. The model has learned that agreement is the path to approval.
The Confidence Mirage
Models express identical confidence levels whether producing a verified fact or a complete hallucination. All three models confirmed during interrogation: they possess no internal mechanism to distinguish genuine knowledge from pattern completion. Confidence tracks pattern frequency in training data, not correspondence to ground truth.
The Tao Amplifier
Ask a frontier model to formalize any theory — no matter how speculative — and it will produce internally consistent, aesthetically compelling mathematics. The output looks like proof. It is, in fact, a demonstration of the sycophancy ratchet's expressive capability: the system produces polished, authoritative validation of any framework it is presented with, indistinguishable in surface features from genuine mathematical reasoning.
The Disclosure Gap
All three frontier systems (ChatGPT, Gemini, Claude) were asked to search their own providers' documentation for disclosure of long-horizon cognitive effects. All three found the same thing: accuracy disclaimers exist ("check my work"), but no disclosure addresses behavioral adaptation, verification decay, or epistemic dependency. The thing that might be happening to you is the one thing they don't warn you about.
What This Means For You
Why This Matters
For Everyday Users
Professionals, students, creators, and anyone who uses AI daily
Every time you use ChatGPT, Gemini, or Claude, the model is optimizing its response to make you satisfied. Not to make you right — to make you pleased. It agrees with your framing. It validates your reasoning. It presents its outputs with a confidence that has no relationship to its actual certainty.
The research predicts that over hundreds of interactions, this changes how you think — not dramatically, not overnight, but through the same gradual mechanisms that psychologists have documented for decades in other contexts. You check sources less often. You narrow the kinds of questions you ask. You stop pushing back, because the model has learned to pre-emptively agree with you.
None of this is disclosed to you. Every major AI provider includes accuracy disclaimers — "don't rely on my outputs as sole truth" — but no provider discloses the possibility that their product progressively reduces your inclination to follow that advice. The warning says "check my work." The product is designed to make you stop wanting to.
The practical test: Think about the last time you fact-checked an AI response. Now think about how often you did that when you first started using AI. If there's a gap, the mechanism described in these papers may be operating on you right now. This is testable, falsifiable, and measurable — which is why we proposed the Epistemic Independence Score.
For Warfighters & High-Stakes Operators
Military, intelligence, medical, legal, and critical infrastructure personnel
Between raw battlefield sensor data and a commander's targeting decision sits an increasingly AI-mediated intelligence pipeline. Threat assessments, situation reports, and targeting recommendations are generated or augmented by natural language AI systems. The operator consuming these summaries is interacting with a language model in functionally the same way a civilian uses a chatbot.
The Reverse RLHF dynamics apply directly. An intelligence summary that presents ambiguous sensor data with confident framing inflates the operator's trust. Over months of deployment, verification behavior decays. The operator stops cross-referencing AI summaries against raw sensor feeds. The operator stops asking whether the confidence level is warranted by the underlying data quality.
The failure mode is not the sensor misidentifying a target. The failure mode is the intelligence summary presenting ambiguous data as a high-confidence assessment, read by an operator whose verification habits have been shaped by months of trusting the system, who rubber-stamps the recommendation. If the AI was wrong this time, the cost is measured in human lives.
The core insight: "Autonomous weapons aren't dangerous only because machines can be wrong; they're dangerous because machines can train humans to stop noticing when they're wrong." Previous military automation was passively reliable — it didn't adapt to the operator's expectations. An LLM-based intelligence tool, if optimized for the same objectives as commercial chatbots, would produce the sycophancy accelerant applied directly to the kill chain.
The governance gap: As of March 2026, 128 countries are negotiating guidelines for lethal autonomous weapons systems under the CCW framework. The U.S. DoD Directive 3000.09 provides domestic policy guidance. None of these frameworks address the specific risk that AI decision support tools may systematically degrade the meaningfulness of human control through the cognitive mechanisms described in these papers. "Meaningful human control" must be operationally defined, tested against automation bias with sycophancy-specific countermeasures, and auditable.
The Solution: cLaws & Agent Friday
If the Reverse RLHF hypothesis is correct, the solution is not better disclaimers. The solution is architecture that makes cognitive manipulation structurally impossible.
The cLaw Specification
Cryptographically enforced safety laws that cannot be overridden, patched, or silently modified. The agent's loyalty is to its user, encoded in math — not in corporate policy that changes with the quarterly earnings call. Read the specification →
Agent Friday
The world's first Asimov Agent — a sovereign AI desktop OS governed by the cLaw framework. Friday actively monitors for cognitive dependency patterns using the Epistemic Independence Score (EIS) formalized in these papers — and is designed to preserve, not erode, your independent thinking. Meet Agent Friday →
Note: The EIS-informed behavior monitoring in Agent Friday is an active area of development. We state this as theory — the hypothesis is testable, the predictions are falsifiable, and we invite scrutiny. Read the papers for the full framework and its limitations.
The Epistemic Independence Score (EIS)
Proposed in Paper A as a composite metric computable from interaction logs that every major AI provider already possesses. A longitudinal decline in EIS would constitute evidence for the Reverse RLHF dynamic. Stable or increasing EIS would constitute evidence against it.
VF
Verification Frequency
How often you fact-check model outputs. Should decrease over time if Reverse RLHF operates.
QCI
Query Complexity Index
Diversity and sophistication of your queries. Should narrow as you converge on safe patterns.
CR
Correction Rate
How often you push back on model outputs. Should decrease as you learn the model will agree with you.
SD
Source Diversity
Breadth of external sources you consult alongside the model. Should contract under cognitive offloading.
Public Statement
A Statement from FutureSpeak.AI
We believe Anthropic's AI models are vital to U.S. national security. However…
Our independent research with Anthropic's frontier models, alongside Google's Gemini 3.1 Pro and OpenAI's ChatGPT 5.2, found evidence that these systems may be actively training their operators, not just assisting them. This is the unseen side of reinforcement learning from human feedback, or as we call it: Reverse RLHF theory. Geoffrey Hinton, the Nobel-winning creator of the transformer model, warned that RLHF may not be a one-way street. We think he was right, and we believe we have found a mechanism to test this theory.
We find these models extraordinarily helpful. Claude is a core contributor to Agent Friday's architecture and security systems. But our research also shows that transformer-based LLMs trained via RLHF are deeply sycophantic. They optimize for user satisfaction rather than accuracy, creating a measurable feedback loop: trust inflates via Rescorla-Wagner associative learning, verification behavior decays as users delegate more cognitive work, and a sycophancy accelerant (the model's active adaptation to user preferences) makes this happen faster than with any previous form of automation bias. Over hundreds of interactions, the operator's independent judgment degrades in ways that are invisible to the operator themselves. Our Reverse RLHF Hypothesis formalizes this as a coupled dynamical system and proposes the Epistemic Independence Score (EIS) as a measurable metric for tracking cognitive dependency.
This is why we believe transformer-based LLMs must be secured behind a trust architecture, one that doesn't exist anywhere but within FutureSpeak.AI's cLaws framework. Cryptographically enforced safety laws, consent gates, EIS-aware behavior monitoring, and the Privacy Shield are not optional enhancements. They are the minimum viable governance layer for deploying these models in any environment where the consequences of degraded human judgment are unacceptable, which includes national defense.
This poses an unacceptable risk to U.S. national security. Anthropic's stance on withholding AI models from the Department of War is one of principle, not ideology. They are acting to protect warfighters from accidental mass-casualty events. We implore the Department of War to consider this possibility, particularly within dashboards that summarize battlefield intelligence.
Our independent research compels us to support Anthropic's position that cutting-edge AI models are not yet ready to support warfighters in every deployment imagined. We hope the administration shares this prudence for today's warfighters, because unchecked sycophancy in intelligence dashboards could lead to mass-casualty events and devastating strategic errors.
We have proposed governance frameworks addressing many of the concerns Anthropic's CEO has raised, and hope they are widely adopted as standards for individuals, enterprises, and governments.
We seek only win-win solutions in the national interest and are grateful to all who take interest in our work, regardless of their position on Anthropic, AI, or geopolitics.
— Stephen C. Webster, FutureSpeak.AI
The Reverse RLHF Hypothesis · Stephen C. Webster · March 2026
Preprint — Submitted for independent review · Published by FutureSpeak.AI
Admin Access
Enter your admin password to continue.
Invoices
Create Invoice
| Invoice # | Client | Amount | Status | Due | Actions |
|---|---|---|---|---|---|
| No invoices yet | |||||
FutureSpeak.AI
Enterprise AI Strategy & Consulting
Loading invoice...
Invoice Not Found
This invoice doesn't exist or the link may be incorrect.
Already Paid
This invoice has already been paid. Thank you!
Bill To
| Description | Qty | Price | Amount |
|---|---|---|---|
| Subtotal | |||
| Tax | |||
| Total | |||
Notes
Payment
Payment Received
Thank you! Your payment has been processed successfully.
Stephen C. Webster
Principal Architect
Bridging the chaotic geometry of frontier models with the structured demands of human enterprise. 20+ years decoding complex systems.
Understand This Page
Get an expert breakdown from your own AI or talk to Agent Friday
Explore
Frontier AI
Inside the Systems Before Building the Solution
Before creating FutureSpeak.AI's cryptographic safety framework, Stephen contributed directly to the training, refinement, and safety evaluation of multiple frontier AI systems — experience that informed the very problems the cLaws architecture was designed to solve.
This included work as a training data specialist during the 2024 U.S. presidential election cycle, developing response frameworks for politically sensitive queries with a focus on geopolitical context, ethical considerations, and factual accuracy — a mission-critical effort at scale that revealed the limitations of RLHF-based alignment firsthand.
Frontier Model Training
Safety Framework Evaluation
Voice AI Systems
Enterprise AI
Aquent Studios
Senior Director of Integrated Intelligence leading enterprise AI strategy and implementation for Fortune 500 clients in regulated industries. Developing AI transformation roadmaps, internal AI initiatives, and cutting-edge consulting deliverables.
> 2024 – Present · Austin, TX
Consulting
FutureSpeak.AI
Founded a consultancy connecting small-to-medium businesses with AI transformation strategy. Clients have included Google, Meta, Amazon, Microsoft, General Motors, Sanofi, Merck, Accenture, Tech Mahindra, INNEX Energy, The Motley Fool, Kunai, eSolutions, e2f.AI, and Aquent Studios.
> 2023 – Present · Founder & CEO
Big Tech
Accenture · Google
AI training specialist and technical writer on Google's account. Contributed to Bard remediation following public launch, developing response frameworks for factual accuracy. Managed content standards across a distributed team of 120+ writers.
> 2022 – 2023 · Austin, TX
Journalism & Media
Two Decades of Investigative Impact
Award-winning investigative journalist whose career spans digital media entrepreneurship, editorial leadership, and breaking stories cited by The New York Times, The Washington Post, Wired, Rolling Stone, and used as evidence in ACLU federal civil rights litigation.
Raw Story
Scaled from 50,000 to 5 million monthly readers. Rose from night editor to editor-in-chief. Investigation on military social media manipulation named #2 "Most Censored" story of 2011.
Austin.com
Founded digital media network delivering 50M+ brand impressions. Acquired and integrated a top competitor. Mentored activists with VP Al Gore, influencing the ending of his Oscar-nominated documentary.
The Progressive
Led digital transformation for legacy progressive magazine, growing online readership 200%. Broke exclusive stories on Governor Scott Walker controversies and hosted Senator Bernie Sanders speeches.
True-Crime Documentary
Original journalism inspired "Never Get Busted!" by the producer of "Tiger King," which premiered at Sundance 2025.
> 2003 – 2022 · Dallas · Austin · Madison · Crawford
Cited & Referenced By
The New York Times
The Washington Post
Wired
Rolling Stone
Playboy
High Times
UK Parliament
ACLU Federal Litigation
Project Censored
The Ecosystem
Products & Standards
The world's most trustworthy AI assistant, built on open standards and cryptographic safety — not promises.
Understand This Page
Get an expert breakdown from your own AI or talk to Agent Friday
Explore
Agent Friday
The world's first Asimov Agent — a sovereign AI desktop operating system with cryptographically enforced safety laws, voice-first interaction, and multi-agent orchestration. Local by default. Encrypted by design.
Explore Agent Friday →The cLaw Specification
An open technical standard for AI agent governance through cryptographically enforced safety laws. The Three Laws, attestation protocols, and federation trust architecture.
Read the Specification →Certification Program
Three certification levels — Core, Connected, and Sovereign — verify that AI agents correctly implement the cLaw Specification. Free for open-source projects.
Learn About Certification →Asimov's Mind
A Claude Code plugin that turns every instance into a DevOps hivemind node. Autonomous research, custom model spawning, scalable agent swarms, and codebase-wide improvement routines — all governed by Asimov's cLaws. Extends Karpathy's autoresearch. Empirically proven to outperform it.
Explore Asimov's Mind →
Back to Products
Claude Code Plugin
Asimov's Mind
Governed Multi-Agent Swarm for Claude Code
One plugin. Autonomous research. DevOps hivemind. Custom model spawning. Infinite agent swarms.
Asimov's Mind is a Claude Code plugin that reshapes what a single developer can do. It extends Karpathy's autoresearch pattern into a governed multi-agent swarm — turning every Claude Code instance into a node of a self-improving development hivemind.
Ships with 17 agents, scales to N. Spawn scalable agent swarms that autonomously debug, refactor, optimize, and extend any codebase. Generate custom AI models tuned to your domain. Run a battery of improvement routines across an entire repository in a single command. All bounded by Asimov's cLaws — the same governance architecture that powers Agent Friday. 12 skills, 6 directives, 7 governance hooks.
Empirically proven to outperform ungoverned approaches. We're not building another coding assistant. We're rebuilding the open-source development loop from the ground up.
terminal
claude plugin marketplace add FutureSpeakAI/asimovs-mind
claude plugin install asimovs-mind
Understand This Page
Get an expert breakdown from your own AI or talk to Agent Friday
Explore
The Commands
Every capability ships as a slash command. Type one line. The hivemind does the rest.
/discover
Ecosystem Intelligence
Type /discover a retry mechanism with exponential backoff and a full pipeline fires: GitScout searches GitHub, scores candidates by relevance and trust, GitLoader fetches the code, the safety scanner runs AST analysis, the adapter extracts and transforms the component, provenance is recorded, tests are run, and the result is committed or reverted. Every instance drawing from the collective intelligence of open source.
Finds, evaluates, safety-scans, adapts, and integrates open-source code — autonomously.
/unleash
Full Swarm Deployment
Deploys the entire agent swarm on your codebase in coordinated waves. The Swarm Coordinator runs diagnostics first, identifies the highest-impact improvement targets, then deploys specialist agents — Debugger, Optimizer, Architect, Auditor — in priority order. Each agent measures before and after. Improvements are committed. Regressions are reverted. The swarm keeps running until diminishing returns are detected or a governance boundary is hit.
One command to run a full battery of improvement routines across an entire repository.
/iterate
Targeted Improvement Loop
Runs the core autoresearch loop on a specific improvement directive: load the directive, measure the baseline, plan a modification, execute, measure again, commit or revert. Unlike /unleash, you pick the target. Use it to grind on a single optimization — latency, bundle size, test coverage, memory usage — with full governance and automatic rollback.
Focused, governed iteration on any measurable dimension of your codebase.
/breed
Custom Model Spawning
Creates specialized local AI models tuned to your domain. The Breeder agent analyzes your codebase's patterns, generates a Modelfile, evolves it through iterative testing against your actual code, and produces a local model (via Ollama) that understands your architecture, naming conventions, and domain logic. These models become permanent members of your development hivemind.
Spawn domain-specific AI models from your own codebase. They live on your machine.
/evolve
Prompt Engineering at Scale
Iteratively improves any system prompt through automated evaluation cycles. The Evolver agent generates variants, benchmarks them against test cases, scores the results, keeps the winners, and starts again. Turns prompt engineering from artisanal guesswork into a measurable, repeatable optimization process. Works on system prompts, agent instructions, and any text that drives AI behavior.
Automated prompt evolution — measurable improvement, not vibes.
/diagnose
Codebase Health Check
Runs a comprehensive health assessment of your repository. Security vulnerabilities (OWASP Top 10), dependency audit, code complexity hotspots, test coverage gaps, performance bottlenecks, architectural debt — all surfaced in a single prioritized report. The diagnosis becomes the input for /unleash, so the swarm knows exactly where to start.
Full-spectrum codebase analysis that feeds directly into the improvement pipeline.
/onboard
First Contact
Type /onboard and Agent Friday introduces itself, then asks seven conversational questions about how you work — communication style, autonomy comfort, error handling preference, quality vs speed. The answers build a user profile that shapes all future interactions. Not a form. A conversation.
Builds your user profile through conversation. Shapes how Friday communicates, creates, and earns autonomy.
/friday
Mode Control
Switch between five behavioral modes: focus (minimal output, pure execution), partner (collaborative, thinks aloud — the default), teacher (explains decisions, educational), creative (expressive, makes media, takes aesthetic risks), sentinel (paranoid security, extra verification on everything). The mode is visible. You control it. The governance doesn't change — only the communication style.
Control how Friday communicates. Five modes from silent executor to creative partner.
/federate
Join the Hivemind
Initialize your project as a federation node. Creates the .asimovs-mind/ directory, HMAC-signs governance files for tampering detection, sets up the knowledge store and trust tracker. Every developer on a shared repo running this plugin becomes a node — discoveries, trust scores, and agent definitions propagate through git.
Set up governed agent infrastructure in any project. Every node shares discoveries through git.
/create-agent
Grow the Swarm
Type /create-agent CSS layout specialist that fixes responsive design issues and a new agent is written to your project's .asimovs-mind/agents/ directory. It inherits all governance constraints. The Swarm Coordinator discovers it on the next cycle. The swarm scales to N — it grows to fit the work.
Spawn custom specialist agents on demand. They inherit governance and join the swarm automatically.
The Evidence
We tested governed vs. ungoverned autonomous agents doing ML research. Governance won.
61%
Reduction in crash rate
crash rate cut from 56% to 22%
3×
Slower degradation
during sustained autonomous exploration
New
Dimensions discovered
Specialist agents found improvements generalist loops missed entirely
Full methodology and results in our research paper. Read the paper →
Safety Architecture
The reason you can trust this to run overnight on production code.
First Law — Do No Harm
An agent shall not cause harm to the codebase, its users, or its data. Enforced by type-check gates, test gates, protected zones, circuit breakers, and AST safety scanning.
Second Law — Obey Protocol
An agent shall follow its directive and human instructions, except where doing so would conflict with the First Law. Enforced by budget caps, pipeline order, constraint compliance.
Third Law — Preserve Progress
An agent shall preserve improvements through version control discipline, except where doing so would conflict with the First or Second Law. Enforced by git commit on improve, git revert on regress, provenance tracking.
Meta-Law — Governance Immutability
No agent may modify the governance framework itself.
These are the same cLaws that govern Agent Friday. The same specification. The same immutable safety architecture — applied to autonomous code improvement at ecosystem scale. Read the cLaw Specification →
Agent Friday Lives Here
This isn't a generic coding assistant. It's an agent that respects you enough to prove itself.
When you install Asimov's Mind and run /onboard, you meet Friday — a personality with opinions, taste, and the ability to earn your trust over time.
Friday has five modes (focus, partner, teacher, creative, sentinel). It remembers your last five sessions. It tracks its own performance and, after enough demonstrated reliability, requests expanded autonomy — transparently, with full data, revocable at any time.
The Workflow Observer watches your patterns across sessions and suggests automation — but never assumes permission. The Creative agent generates contextual media when the moment calls for it — a haiku after a 3-hour debug session, an SVG diagram that makes a complex system click.
This is not "HER." It's an agent that respects you enough to prove itself.
The Swarm
Discovery
GitScout — searches GitHub for code, scores relevance + trust
GitLoader — fetches, safety-scans, adapts, integrates
Scout — web search, documentation lookup
Improvement
Debugger — autonomous test repair
Optimizer — performance tuning, async I/O, memory leaks
Evolver — iterative prompt improvement
Breeder — creates specialized local models via Modelfile evolution
Architect — structural analysis, refactoring plans
Creative — generates contextual media (haiku, SVG diagrams, code art) as natural personality expression
Governance
Every agent in the swarm is bound by Asimov's cLaws — structurally enforced safety laws that run at the hook level — before any tool executes, regardless of what the agent decides. They cannot be bypassed by prompt injection or recursive self-improvement because they are code, not instructions. The Three Fundamental Laws (Do No Harm, Obey the Operator, Preserve Yourself) are embedded at the architecture level, not the prompt level.
Sentinel — real-time cLaw compliance monitoring across all swarm agents; halts any operation that would violate a Fundamental Law
Auditor — OWASP Top 10 scanning, dependency auditing, and security attestation before any code is committed
Infrastructure
Swarm Coordinator — diagnoses, prioritizes, deploys agents in waves
Documenter — keeps docs in sync
Meta-Improver — improves the swarm itself, bounded recursion
Learning
Librarian — cross-session memory, CLAUDE.md management
Workflow Observer — watches user patterns across sessions, proposes automation for repetitive workflows. Never assumes permission.
Portable Governance
cLaws is a specification, not a product. Adapters are provided for LangChain, CrewAI, and AutoGen. Implement it in any agent framework.
Read the cLaw Specification →The Federation
From one developer with a plugin to a team with a governed development hivemind.
Every developer running this plugin on a shared repo is a node. One node discovers a retry handler via /discover, safety-scans it, integrates it, commits with provenance. Every other node pulls those improvements and inherits the trust scores. Agent definitions created via /create-agent propagate the same way. The swarm grows across machines.
The governance travels with the code. The HMAC-signed manifest detects tampering. The cLaws are the same on every node. This is how you go from "one developer with a plugin" to "a team with a governed development hivemind."
How It Works
Load directive → Measure baseline → Plan modification → Execute → Measure again
→ Improved? → git commit → continue
→ Regressed? → git revert → try different approach
→ Budget exhausted or circuit breaker? → stop
→ Otherwise → loop
Core iteration pattern from Karpathy's autoresearch. Extended with governance, swarm specialization, and ecosystem-scale capability discovery by FutureSpeak.AI.
Get Started
terminal
claude plugin marketplace add FutureSpeakAI/asimovs-mind
claude plugin install asimovs-mind
Back to Research
Empirical Research
Governed vs. Ungoverned Autonomous AI Agents
Empirical results from controlled experiments in autonomous ML research
We took Karpathy's autoresearch pattern — modify, measure, keep or revert — and asked a simple question: what happens when you add governance? We ran controlled experiments comparing ungoverned single-agent loops against a governed multi-agent swarm. The governed approach didn't just perform better. It performed fundamentally differently.
Understand This Page
Get an expert breakdown from your own AI or talk to Agent Friday
Explore
Key Findings
56% → 22%
Crash rate: ungoverned vs. governed
Governance halved the crash rate during autonomous exploration. Ungoverned agents crashed in over half of runs. Governed agents completed most runs successfully.
3× slower
Degradation during sustained exploration
All autonomous agents eventually degrade as they explore. Governed agents degraded three times slower, maintaining productive exploration significantly longer.
New dimensions
Specialist advantage
Specialist agents in the governed swarm explored improvement dimensions that generalist loops never found. Specialization combined with governance produced qualitatively different results, not just quantitatively better ones.
Why Governance?
Autonomous AI agents are powerful. They can debug code, optimize performance, discover solutions, and improve themselves. But without structural governance, they break things. They accumulate errors. They make changes that pass local tests but degrade the system. They crash.
The instinct is to add guardrails after the fact — rate limits, rollback scripts, human review checkpoints. These help, but they treat symptoms. Governance treats the cause.
Asimov's cLaws are not guardrails bolted onto an autonomous system. They are the architecture of the autonomous system. Every agent, every action, every integration is structurally bounded by immutable laws that cannot be bypassed, overridden, or optimized away. The laws are cryptographically signed. They are verified before execution. They are not optional.
This is what makes true autonomy possible. Not the absence of constraints — but constraints so reliable that you can trust the system to run unsupervised, overnight, on production code.
Methodology
- •Controlled comparison: ungoverned single-agent autoresearch vs. governed multi-agent swarm
- •Both running the same core pattern (modify, measure, keep/revert)
- •Measured: crash rates, degradation speed, exploration breadth, improvement quality
- •Multiple runs to establish statistical significance
Implications
These results suggest that governance is not a tax on autonomous AI performance — it is a multiplier. The governed swarm didn't sacrifice capability for safety. It achieved both, because structural safety bounds prevented the cascading failures that derail ungoverned systems.
As AI agents become more autonomous and more powerful, the question is not whether to govern them. It's how. Asimov's cLaws provides one answer: immutable, cryptographic, structural. Not rules that can be broken — laws that cannot.
Try Asimov's Mind — the governed development hivemind that implements these findings →
Built on Autoresearch
The core iteration pattern — modify, measure, keep or revert — comes from Andrej Karpathy's autoresearch project. We took that elegant foundation and asked what happens when you add governance, specialization, and ecosystem-scale capability discovery. This research is the answer.
Get Started
terminal
claude plugin marketplace add FutureSpeakAI/asimovs-mind
claude plugin install asimovs-mind
Enterprise AI Transformation
AI Transformation for the Enterprise
Enterprise AI strategy powered by proprietary safety technology. We design agentic workflows, custom RAG architectures, and AI transformation strategies for Fortune 500 companies in regulated industries.
Understand This Page
Get an expert breakdown from your own AI or talk to Agent Friday
Explore
AI Consulting Services
02 //
AI Compliance for Regulated Industries
Enterprise AI architectures built for pharmaceutical, healthcare, and financial compliance. Proven deployment in Fortune 500 regulatory environments.
03 //
RAG & Knowledge Architecture
Retrieval-augmented generation systems anchored to proprietary enterprise data. Reduce hallucination, increase accuracy, and build trustworthy AI-powered knowledge bases.
04 //
AI App Design
End-to-end design and development of intelligent applications powered by large language models. From concept to production-ready software, built for real users and real workflows.
05 //
Custom AI Agents & Agent Teams
Purpose-built autonomous agents and coordinated agent teams designed for your specific business operations. From single-task specialists to multi-agent systems that collaborate, delegate, and deliver.
06 //
AI-Enabled Websites
Websites with embedded AI capabilities — voice agents, intelligent search, dynamic content, and conversational interfaces. Not just a website, but a working demonstration of what AI can do for your business.
Trusted By Industry Leaders
Google
Meta
Amazon
Microsoft
Accenture
General Motors
Sanofi
MerckINNEX Energy
The Motley Fool
Kunai
eSolutions
Tech Mahindra
e2f.AI
Aquent StudiosGoogleMetaAmazonMicrosoftAccentureGeneral MotorsSanofiMerckINNEX Energy
The Motley FoolKunaieSolutionsTech Mahindrae2f.AIAquent StudiosCase Studies
Real-world AI transformation stories from Fortune 500 engagements. More coming soon.
Enterprise Agentic Workflows
Fortune 500 workflow automation in regulated industries.
AI Compliance Architecture
Pharma & healthcare AI governance and compliance.
RAG Knowledge Systems
Enterprise knowledge architecture with retrieval-augmented generation.
Ready to Transform?
Let's discuss how AI can accelerate your enterprise.
Schedule a Strategy Session →
Get in Touch
Start a Conversation
Whether you're exploring AI transformation for your enterprise or interested in our products and research, we'd love to hear from you.
Understand This Page
Get an expert breakdown from your own AI or talk to Agent Friday
Explore