The Intuitive Agent System

IAS is a control plane for AI-assisted software development that gives engineering teams a single system to orchestrate coding agents across repositories, make decisions when agents need guidance, and maintain a complete audit trail of every change. It is built for organizations that want the productivity of AI agents without giving up control, visibility, or code security.

Instead of running agents in isolated terminal sessions and losing track of what they do, IAS coordinates the work, surfaces what needs your attention, and keeps your source code on your own infrastructure.

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.

Command Center

The Command Center is your web-based control plane at app.ias.dev. It provides visibility into what every agent is doing across all your repositories. From the Command Center you can create goals, monitor task progress, review agent output, answer decision requests, and manage workspaces and policies. It is the single pane of glass for all AI-assisted work in your organization.

Context Lake

The Context Lake is a unified knowledge layer that aggregates your project context -- documentation, tickets, conversations, code structure -- so agents have the information they need to act intelligently. Instead of re-explaining context in every session, agents read durable artifacts and pick up where others left off. The Context Lake is what makes agents reliable across sessions and across team members.

Security model

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

• Code never leaves your machine. Local workers execute against your Git checkout on your own infrastructure. Only metadata syncs to the cloud -- job status, commit SHAs, decision requests. Never source code.
• Local execution. Agents run as local processes. They read from and write to your Git checkout directly. The Command Center coordinates; execution is local.
• 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 Command Center 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 Command Center.
4. Set Up Agents -- Install and configure local workers.
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.