Intent

What is Intent?

Intent is a developer workspace for coordinating agents so you can implement changes while keeping specifications synchronized with the codebase. The core purpose is to treat a spec as the source of truth and update it as agents complete work, helping prevent the project from drifting when requirements evolve.

In addition to its general workflow, Intent is described as supporting agent coordination through a demo focused on cross-service JWT authentication. In that example, separate agents work on different parts of the system, with one agent handling token issuance, refresh, and revocation in an authentication service, while another agent adds JWT validation middleware and related behaviors in an API gateway. The page also notes that workspaces are isolated, and that Intent is available on macOS for Apple Silicon.

Key Features

• Spec-first development workflow: Intent is designed around using a living specification as the source of truth, keeping it aligned with the evolving codebase.
• Agent coordination in a developer workspace: Multiple agents can work together to implement changes rather than treating work as disconnected steps.
• Living spec synchronization: As agents complete work, the specification is updated so the project doesn’t drift from the requirements over time.
• Isolated workspaces: Each workspace is described as isolated, which helps separate concurrent work streams.
• Agent-based implementation example (JWT auth): The demo illustrates coordinated implementation across services—token lifecycle work in an auth service and JWT validation behavior in an API gateway.

How to Use Intent

1. Start with a specification as the source of truth. Use the spec to define the feature or change you want to implement.
2. Use the workspace to coordinate agent work. Agents take on different implementation responsibilities as part of the same workspace so their outputs remain connected to the spec.
3. Implement changes while keeping the spec synchronized. As work completes, the living spec is updated to reflect what has been implemented in the codebase.
4. Validate behavior across coordinated components. In scenarios like cross-service JWT authentication, this typically means ensuring token lifecycle responsibilities (issuance/refresh/revocation) and gateway validation responsibilities are both covered by the coordinated work.

Use Cases

• Managing evolving requirements without drift: When specifications change, Intent helps keep the code and the spec aligned as implementation progresses.
• Cross-service feature implementation: The JWT authentication demo shows coordinating changes between an auth service and an API gateway.
• Splitting work by subsystem: Agents can be assigned distinct areas (for example, token management in one service and request validation in another) while remaining under a single synchronized spec.
• Isolated workstreams for different tasks: Isolated workspaces support separation of concurrent efforts when multiple changes are underway.

FAQ

Q: What problem does Intent address?
A: It addresses project “drift” by treating a specification as the source of truth and keeping that spec synchronized with the code as agents complete work.

Q: What does “living spec” mean in this context?
A: The specification is updated as implementation is completed, so the requirements stay aligned with the current codebase rather than becoming outdated.

Q: Can Intent coordinate work across multiple services?
A: Yes. The described demo for cross-service JWT authentication involves one agent working on token issuance/refresh/revocation in an auth service and another agent adding JWT validation middleware and supporting behaviors in an API gateway.

Q: Are workspaces isolated?
A: The page states that each workspace is isolated.

Q: Is Intent available on macOS?
A: The page notes availability on macOS for Apple Silicon.

Alternatives

• Spec-and-implementation workflows with traditional developer tools: Teams can keep a living document or requirements file in sync manually or via documentation tooling, using standard version control practices for coordination.
• Agent orchestration frameworks: Instead of a dedicated “developer workspace” product, teams can use agent orchestration tools that coordinate autonomous workers, coupled with their own spec synchronization process.
• AI-assisted code generation with human review: Tools that generate code from prompts can help implement features, but spec synchronization would be handled through the team’s review and documentation practices.
• Manual cross-service implementation using CI/CD and code reviews: For coordinated features like JWT authentication, teams can implement changes in each service with standard engineering workflows to ensure consistency across components.