The Intuitive Agent System

IAS is the system for turning intent into governed action: intent refinement, context assembly, policy, action adapters, approvals, evidence, recovery, and learning loops. The current public proof profile is the governed engineering harness for teams that want AI-assisted execution without giving up control, visibility, or code security.

The engineering profile's product North Star is one strong local execution runtime, reusable context that survives across sessions, explicit validators and approvals, and a thin control plane for visibility and evidence.

The current operator path is the unified local runtime, started with ias start. IAS keeps source code on your own infrastructure, makes blockers and approvals visible, and promotes reusable learnings upward through review.

Control-plane path

IAS turns agent work into a visible path from intent to review. Each stage has a clear handoff, the next surface to inspect, and evidence that stays attached to the run.

Three core components

IAS is built around three components that work together as one system.

Agent Framework

The Agent Framework deploys AI agents into your codebase. It scaffolds a docs/ias/ directory into your repository containing context packs, a world model snapshot, decision policies, and run artifacts. Agents work in Git branches, submit pull requests, and follow your existing code review process. Everything is version-controlled and auditable from day one.

Console

The IAS Hub is the web-based control plane at app.ias.dev. It provides visibility into what agents are doing across repositories, surfaces blockers and approvals, and lets teams monitor governed work without becoming the place where code execution happens. The Console is intentionally thin: it coordinates, validates, and shows evidence.

Context Lake

The Context Lake is the reusable context layer that aggregates project knowledge -- documentation, tickets, conversations, code structure, and curated artifacts -- so agents do not need to be re-briefed from scratch in every session. It is what makes IAS durable across sessions, repos, and team members.

Security model

IAS is designed for teams that care deeply about where their code lives.

• Code never leaves your machine. Local execution runs against your Git checkout on your own infrastructure. Only metadata syncs to the cloud -- status, commit SHAs, decision requests, and evidence pointers. Never source code.
• Local execution. Agents run locally and read from and write to your Git checkout directly. The Console coordinates; execution stays close to the repository.
• Full audit trail. Every action produces a Git commit with a real SHA. You can trace any change back to the goal, task, and decision that produced it.
• Explicit opt-in. IAS does not make changes to your repositories without your knowledge. You control which repos are connected, which agents are running, and what policies govern their behavior.

How it works

The Inbox: human-in-the-loop decisions

When an agent encounters an ambiguity or needs a judgment call, it creates a structured Decision Request rather than blocking or guessing. Decision requests appear in your Inbox with structured options, context about why the decision matters, and a recommended path. You answer when you are ready, and the agent resumes automatically. Every decision is recorded and auditable.

From intent to shipped code

IAS follows an intent engineering flow that takes work from idea to committed code:

1. Intake -- You describe what you want in plain language. IAS captures the raw intent and shapes it into a structured goal proposal.
2. Proposal -- Cloud AI refines your intent into a goal with scope, constraints, and a readiness scorecard. You review and approve.
3. Run -- The goal decomposes into concrete tasks. Agents claim jobs from the queue, execute against your local codebase, run quality passes, and commit results. Every change traces back to the original intent.

Execution modes

IAS supports different levels of automation depending on your comfort and workflow. You can work interactively in a terminal, let the Console manage work queues, or run agents fully automated. See Execution Modes for a detailed breakdown of each mode and when to use it.

A typical day with IAS

1. Check your Inbox. Open the Console and review any decision requests that agents created overnight. Answer the ones that matter.
2. Review completed work. Look at tasks that agents finished -- commits, pull requests, and evidence. Merge what looks good.
3. Queue new work. Create a new goal for the next feature or fix. IAS decomposes it into tasks and agents start working.
4. Monitor progress. Glance at the Workboard throughout the day. Agents surface blockers as decision requests instead of silently stalling.

Where to start

Different roles benefit from different entry points into the documentation.

Engineers

Get hands-on quickly:

1. Quick Start -- Set up IAS and run your first agent in about 15 minutes.
2. Create a Workspace -- Configure your workspace and team settings.
3. Add a Repository -- Connect your codebase to the Console.
4. Set Up Agents -- Install and configure local execution.
5. Execution Modes -- Choose how automated you want agents to be.

PMs and Leadership

Understand what IAS provides and how to steer the work:

1. Core Concepts -- Workspaces, goals, decision requests, and the building blocks of IAS.
2. Inbox -- How to review and respond to agent decision requests.
3. Briefings -- Get a daily summary of progress and opportunities.
4. Workboard -- Monitor active tasks and agent status.

Evaluators

Assessing whether IAS fits your team:

1. Start here -- Read this page to understand the architecture and security model.
2. Quick Start -- Walk through the setup to see how it feels.
3. Architecture -- Dive into the technical design.
4. Core Concepts -- Understand the abstractions IAS introduces.