The AI-human engineering platform where agents and humans collaborate as teammates.
Lintel doesn't just measure software delivery — it executes it. Teams interact through Slack or the web UI while specialised AI agents plan, code, review, and ship work in isolated sandboxes. Every action is recorded in an append-only event store, giving you a complete audit trail and DORA-grade metrics — all derived from the event stream, not bolted on.
Traditional engineering intelligence platforms are mirrors — they show you what happened. Lintel is a flywheel — it measures, acts, and improves automatically.
Pipeline DAG — visual workflow execution with real-time stage progress
Left: Composable agent skills — Right: Multi-provider AI routing (Anthropic, OpenAI, Ollama, Bedrock, Azure, Google)
Built-in compliance regulation templates (FCA, PSD2, SM&CR, MiFID II, DORA, AML)
+---------+ +---------+ +--------+ +--------+ +---------+ +-------+
| DESIRE | --> | DEVELOP | --> | REVIEW | --> | DEPLOY | --> | OBSERVE | --> | LEARN |
+---------+ +---------+ +--------+ +--------+ +---------+ +-------+
^ |
+----------------------- learnings inform next desire ----------------------+
You describe what you want in a Slack thread or chat. Lintel classifies the request, builds a work plan, writes the code, runs tests, requests reviews, and waits for your approval before merging. Each phase transition is an event. Each event feeds metrics. Metrics trigger guardrails. The flywheel turns.
ingest → route → setup_workspace → research → approve_research
→ plan → approve_spec → implement → test → review → approve_merge → merge
Every stage is observable, retryable, and produces audit events. Approval gates pause the pipeline and wait for human sign-off.
| Multi-agent orchestration | Specialised agents (planner, coder, reviewer, PM, designer, summarizer) collaborate within a single workflow, each routable to different LLM providers |
| Chat-driven workflows | Describe work in natural language — Lintel classifies intent, creates work items, and dispatches the right pipeline |
| Sandboxed execution | Code runs in isolated Docker containers with --cap-drop ALL, seccomp profiles, read-only root filesystems, and no network after clone |
| PII protection | Messages are scanned with Presidio and anonymised before reaching any model |
| Event-sourced audit trail | Every decision, model call, approval, and state change is an immutable event with full correlation tracking |
| Human-in-the-loop | Agents propose; humans approve merges, deployments, and sensitive actions via configurable approval gates |
| Model-agnostic routing | Route any agent role to any provider (OpenAI, Anthropic, Bedrock, Ollama, Azure) with priority-based model assignment policies |
| MCP integration | All 170+ API endpoints are automatically exposed as MCP tools, plus a client for connecting to external MCP servers |
| Web UI | Full-featured dashboard with 27 feature modules — pipelines, chat, sandboxes, agents, models, audit logs, and more |
┌─────────────────┐
│ Slack / Chat │
└────────┬────────┘
│
┌────────▼────────┐
│ PII Pipeline │
└────────┬────────┘
│
┌────────────────────▼────────────────────┐
│ Event Store (Postgres) │
│ append-only · correlation · causation │
└────────────────────┬────────────────────┘
│
┌────────────────────▼────────────────────┐
│ LangGraph Workflow Engine │
│ │
│ ┌──────────┐ ┌────────┐ ┌──────────┐ │
│ │ Planner │ │ Coder │ │ Reviewer │ │
│ └────┬─────┘ └───┬────┘ └────┬─────┘ │
│ │ │ │ │
│ ▼ ▼ ▼ │
│ ┌─────────────────────────────────┐ │
│ │ Sandboxed Execution (Docker) │ │
│ └─────────────────────────────────┘ │
└────────────────────┬────────────────────┘
│
┌────────────────────▼────────────────────┐
│ Projections · Metrics · Audit │
└─────────────────────────────────────────┘
The system follows event sourcing with CQRS. Commands express intent and may fail. Events are past-tense facts that are never modified. Domain code depends on Protocol interfaces; infrastructure provides concrete implementations.
Domain model (click to expand)
erDiagram
Project ||--o{ Repository : "has many"
Project ||--o{ Credential : "has many"
Project ||--o{ PipelineRun : "runs"
Project ||--o{ WorkItem : "tracks"
Project ||--o{ Trigger : "started by"
Project ||--o{ NotificationRule : "notifies via"
Project ||--o{ Policy : "governed by"
WorkflowDefinition ||--o{ WorkflowStepConfig : "defines steps"
WorkflowStepConfig }o--|| AgentDefinition : "uses agent"
WorkflowStepConfig }o--|| Model : "uses model"
WorkflowStepConfig }o--|| AIProvider : "via provider"
PipelineRun }o--|| WorkflowDefinition : "instance of"
PipelineRun }o--|| WorkItem : "executes"
PipelineRun }o--|| Environment : "runs in"
PipelineRun ||--o{ Stage : "has stages"
Stage ||--o{ AgentSession : "runs agents"
Stage ||--o{ SandboxJob : "executes in"
Stage ||--o{ ApprovalRequest : "may require"
SandboxJob }o--|| Repository : "operates on"
Environment ||--o{ Variable : "has variables"
ChatSession }o--|| Project : "belongs to"
ChatSession }o--o{ MCPServer : "has access to"
ChatSession ||--o{ PipelineRun : "can trigger"
Model }o--|| AIProvider : "provided by"
AgentDefinition ||--o{ SkillDefinition : "uses skills"
Lintel is a uv workspace monorepo — each package has its own pyproject.toml, source, and colocated tests:
packages/
contracts/ lintel-contracts — types, commands, events, Protocol interfaces (no deps)
domain/ lintel-domain — business logic, skills, scheduling
agents/ lintel-agents — AI agent runtime
infrastructure/ lintel-infrastructure — postgres, slack, presidio, sandbox, vault, observability
workflows/ lintel-workflows — LangGraph workflow graphs and node implementations
app/ lintel — FastAPI API, middleware, MCP surface, composition root
Dependency flow: contracts → domain / agents → infrastructure / workflows → app
Domain code depends only on contracts/ abstractions — never on infrastructure.
- Python 3.12+
- uv package manager
- Docker (for sandboxes and local Postgres)
git clone https://github.com/bamdadd/lintel.git
cd lintel
# Install dependencies
make install
# Start dev server (in-memory stores, no external deps)
make serve
# Or with Postgres
make serve-db
# Open the UI
open http://localhost:8000Working on a feature — run tests for the package you're changing:
make test-contracts # if touching contracts
make test-domain # if touching domain
make test-agents # if touching agents
make test-infrastructure # if touching infrastructure
make test-workflows # if touching workflows
make test-app # if touching API/routes
# Or auto-detect affected packages (+ their dependents):
make test-affected BASE_REF=main
# Or use testmon for incremental testing (tracks file-to-test deps):
uv run pytest --testmon packages/domain/tests/
# Run a single test:
uv run pytest packages/contracts/tests/test_types.py -vBefore pushing:
make lint # ruff check + format
make typecheck # mypy strict modeBefore merging:
make all # lint + typecheck + all tests + integration + UI build| Trigger | Unit Tests | Integration | Lint + Typecheck |
|---|---|---|---|
| PR | Affected packages only | Skipped | Full |
| Main push | All packages | Postgres + migrations | Full |
cp .env.example .env # fill in your API keys
cd ops && docker compose up -d
curl http://localhost:8000/healthzmake install Install all deps (uv sync --all-extras --all-packages)
make serve Dev server on :8000 (in-memory)
make serve-db Dev server on :8000 (PostgreSQL)
make test Run all tests
make test-affected Run tests for changed packages only
make test-contracts Run contracts tests
make test-domain Run domain tests
make test-agents Run agents tests
make test-infrastructure Run infrastructure tests
make test-workflows Run workflows tests
make test-app Run app tests
make test-unit All unit tests (parallelised)
make test-postgres Tests against postgres backend
make test-integration Integration tests (testcontainers)
make test-e2e End-to-end tests
make lint Ruff check + format check
make typecheck mypy strict mode
make format Auto-fix formatting and lint
make migrate Run event store migrations
make all lint + typecheck + all tests + integration + UI build
make dev Launch tmux dev environment (3 windows)
| Layer | Technology |
|---|---|
| API | FastAPI, Pydantic v2, uvicorn |
| Workflows | LangGraph, LangChain |
| LLM routing | litellm (OpenAI, Anthropic, Bedrock, Ollama, Azure) |
| Database | PostgreSQL, asyncpg, SQLAlchemy async |
| Messaging | NATS |
| PII | Presidio (analyzer + anonymizer) |
| Sandbox | Docker (isolated containers) |
| Secrets | cryptography (Fernet) |
| Observability | OpenTelemetry (SDK + OTLP exporter) |
| Slack | slack-bolt, slack-sdk |
| MCP | fastapi-mcp (auto-expose), custom tool client |
| UI | React, Vite, Mantine, TanStack Query |
| Testing | pytest, pytest-asyncio, testcontainers |
| Code quality | ruff, mypy (strict mode) |
- Platform Vision — mission, principles, and differentiation
- Architecture — detailed system design
- Events — event types and the event store
- Local Development — dev environment setup
- Requirements — delivery loop, entities, guardrails, metrics, integrations