01
Coding agent
An open-source agent for real engineering work: reading, planning, editing, testing, and keeping the builder in command.
buildatlas.io / open developer infrastructure
Atlas
Build world-class open developer infrastructure that gives builders more capability, ownership, and freedom.
Expand what's possible. Earn the world's attention.
atlas/initopen runtime
$atlas agent start --repo ./infra
→context loaded: repo, issues, memory, policy
→planning changes across runtime, tests, docs
✓builder remains in control
01 / Mission
Open infrastructure for builders who intend to own their tools.
Atlas is a long-term project to make developer capability portable, inspectable, and worthy of the people building the future with it.
The first product is an open-source coding agent. The ambition is larger: an ecosystem for runtime, memory, context, models, and infrastructure that builders can study, extend, and trust.
We are not here to wrap closed systems in a friendlier interface. Atlas is for teams that want leverage without surrendering ownership of the stack that creates it.
Manifesto lineCapability should compound in the open.
02 / What Atlas is building
A complete developer infrastructure layer, starting with the agent.
Atlas is designed as a system, not a feature launch. Each layer earns its place by making builders more capable and less dependent on opaque defaults.
02
Runtime
A durable execution layer for agents, tools, tasks, permissions, state, and reproducible work across environments.
03
Memory
Project-aware memory that captures durable context without turning private engineering knowledge into platform lock-in.
04
Context engine
Infrastructure for mapping repositories, issues, docs, decisions, dependencies, and organizational intent into usable context.
05
Models
Model interfaces and evaluation paths that let builders choose the right intelligence for the work instead of inheriting one default.
06
Infrastructure
The shared substrate for open developer tools: observable, composable, and strong enough for serious production teams.
03 / Phase One
The open-source coding agent is the first proof.
Phase One focuses the mission into a tool developers can run, inspect, improve, and use on real repositories.
Atlas Agent
Serious automation. Explicit control.
The agent should feel like infrastructure: predictable permissions, visible planning, strong context handling, and clean handoff between human judgment and machine execution.
- ReadUnderstands code, docs, tasks, and project conventions before changing files.
- PlanTurns ambiguous work into a visible sequence that can be reviewed early.
- ActEdits, tests, and reports with enough precision for maintainers to trust the work.
mission: expand_builder_capability repo: context: source + issues + docs + memory permissions: explicit output: reviewable_diff agent: default_mode: plan_then_act state: visible ownership: builder principle: - open_by_default - world_class_or_not_at_all - earn_attention_through_excellence
04 / Principles
The operating system for the company is the design system for the product.
Atlas should feel inevitable because the work is disciplined. These principles keep the project from drifting into spectacle.
P01
Think bigger.
Build for the ecosystem that should exist, not only the feature that can be shipped this month.
P02
Build world-class.
Taste, reliability, documentation, and architecture are part of the same standard.
P03
Own critical technology.
The most important developer capabilities should not depend on invisible, unchangeable systems.
P04
Open by default.
Openness is not a marketing label. It is how trust compounds across builders and maintainers.
P05
Earn attention through excellence.
No theatrics. Let the product, the code, and the clarity of the mission carry the signal.
P06
Long-term over short-term.
Prefer decisions that make Atlas stronger in five years over decisions that make it louder this week.
05 / Roadmap
A phased path from agent to platform.
The roadmap is intentionally sequential. Each phase creates leverage for the next without pretending the whole ecosystem exists on day one.
Phase 1
Atlas Agent
Open-source coding agent for controlled, inspectable engineering work.
Phase 2
Atlas Core
Shared runtime primitives for tools, permissions, state, and agent execution.
Phase 3
Atlas Open
Contribution model, public specifications, and a broader maintainer surface.
Phase 4
Atlas Intelligence
Context, memory, model routing, and evaluation for serious developer workflows.
Phase 5
Atlas Platform
Hosted and self-managed infrastructure for teams building with Atlas primitives.
Phase 6
Atlas Labs
Research and frontier experiments that expand what open developer infrastructure can become.
06 / Build in public
Make the work visible enough to trust.
Atlas should earn contributors through substance: public code, public reasoning, clear standards, and a roadmap that serious builders can interrogate.
Public repoSource and issues
Open RFCsArchitecture in daylight
Maintainer-gradeDocs, tests, review
Plant the flag. Build the stack.
Atlas is for builders who believe the next era of developer infrastructure should be open, excellent, and owned by the people advancing it.