An open-source runtime for structured AI-agent execution through explicit capabilities, bounded authority and controlled interaction with enterprise systems.
Lattice is a capability runtime for outcome-based execution. It sits between an AI agent and the systems it acts on, so that sequencing, state, credentials, failure policy and audit live in reviewed code rather than inside the model's context window.
Instead of exposing an open-ended tool surface, Lattice exposes typed capabilities with explicit inputs, outputs, permission boundaries and execution tracing. The agent expresses what it wants to achieve; the runtime executes deterministically and returns a compact projection the model can reason over.
This keeps the agent in the role of interpreting intent and applying policy, while the runtime remains accountable for how work is actually performed against enterprise systems.
The agent submits an objective and reasons over projections; Lattice governs execution — capabilities, authority, state and audit — before touching enterprise systems.
Operations are declared with explicit schemas, side-effect classification and required authority, replacing an unbounded tool surface with a reviewed set of actions.
Each capability runs within a scoped permission envelope, so an agent cannot exceed the authority granted for the task at hand.
Intermediate state is held by the runtime rather than reconstructed from context, keeping long or resumable tasks consistent and inspectable.
Every capability invocation is recorded with inputs, outputs and outcomes, providing an audit and replay trail for what the agent caused.
The runtime returns a structured, minimal view of results for the model to reason over, limiting context bloat and tool-space interference.
The agent submits an objective and the capabilities it intends to use.
The runtime checks requested capabilities against the task's bounded authority.
Capabilities run deterministically inside the runtime, holding state and credentials.
Inputs, outputs and outcomes are traced for audit and replay.
A structured result is returned to the agent to inform its next decision.
Sequencing, credentials and failure handling live in code that can be reviewed, tested and versioned.
Capabilities carry only the permissions they need, scoped per task rather than granted globally.
Capabilities declare whether they read, write or cause external effects, enabling policy before execution.
A compromised or misaligned model cannot exceed the capability boundary or fabricate execution.
csehammad/Lattice
The implementation is developed openly on GitHub — Python. The repository is the source of truth for code, examples and documentation.