Inspiration
Most AI systems are excellent at answering questions, generating plans, and producing impressive text. But real-world missions rarely end with an answer. They require research, coordination, decisions, tool use, follow-through, verification, and memory.
Atlas was already designed around knowledge, missions, decision support, and complex operational environments. We saw an opportunity to take the next step: make Atlas agentic.
The inspiration behind Atlas Agentic Operating Layer is simple:
What if Atlas didn't just tell you what needs to happen—but actually coordinated the work required to make it happen?
We wanted to create an intelligence layer where a high-level objective becomes an executable mission: goal → context → plan → tools → execution → verification → evidence → memory → continuation.
The deeper inspiration is mission continuity. Instead of an AI session ending when the conversation ends, Atlas maintains state, remembers what happened, and can resume the mission later.
What it does
Atlas Agentic Operating Layer transforms complex operational objectives into autonomous, observable missions.
A user can provide a goal such as:
“Evaluate this regeneration opportunity, determine the next actions, identify the relevant stakeholders and information, create an execution plan, initiate the appropriate workflow, and return with verified results.”
Atlas then:
- Understands the objective, constraints, context, stakeholders, and desired outcome.
- Retrieves relevant Atlas knowledge and data.
- Decomposes the objective into a structured mission and task graph.
- Selects the appropriate agents and tools.
- Executes multi-step work autonomously.
- Persists intermediate state and mission memory.
- Delegates specialized work to research, analysis, planning, verification, and reporting agents.
- Verifies results against defined success criteria.
- Produces evidence, decisions, unresolved issues, and next actions.
- Keeps the mission resumable so work can continue across sessions.
The result is not a chatbot that generates recommendations. It is an agent execution system designed to coordinate real work.
We also built an Agent Mission Control experience that makes the autonomous process visible: mission status, plan, agents, activity, memory, evidence, and outcomes.
How we built it
We extended the existing Atlas platform rather than building a separate AI application.
At the center is the Atlas Mission Agent, built around Google ADK and Gemini. It acts as the orchestrator responsible for understanding objectives, planning missions, coordinating tools and agents, executing tasks, and driving verification.
Specialized agents support the mission:
- Research Agent — finds and structures relevant information.
- Analysis Agent — evaluates information and identifies implications.
- Planning Agent — converts findings into executable plans.
- Verification Agent — checks outputs against predefined criteria.
- Reporting Agent — produces the final mission report and evidence package.
We designed the system around real tools such as knowledge retrieval, mission creation, task management, memory storage, analysis, reporting, verification, approvals, and publishing. These tools have explicit inputs, outputs, permissions, error handling, and logging.
The cloud architecture uses Google technologies for the agentic runtime and operational backbone, including Gemini / Vertex AI, Google ADK, Cloud Run, Firestore, Pub/Sub, and Cloud observability.
Persistent state is modeled around entities including Agent, Mission, Task, AgentExecution, Memory, Tool, Evidence, Approval, and AuditEvent, allowing each mission to retain its history and remain auditable.
We also introduced an Agent Gateway and safety layer for routing, permissions, policy enforcement, audit logging, prompt-injection protection, malicious tool instructions, sensitive information exposure, and unauthorized actions.
Challenges we ran into
The hardest challenge was resisting the temptation to build “just another AI interface.”
A conversational demo is easy to make look intelligent. Building a system that can actually plan, invoke tools, persist state, delegate work, recover from failures, verify outputs, and continue asynchronously is substantially harder.
We also had to balance architecture depth with hackathon scope. The system could easily become a sprawling enterprise platform, so we deliberately focused on one primary mission workflow and a small set of specialized agents rather than building ten shallow agents.
Another challenge was making autonomy trustworthy. Once an agent can take action, identity, authorization, auditability, verification, and safe tool execution stop being optional features and become core parts of the product.
Finally, we had to make invisible agent behavior visible. A judge should not have to read model logs to understand what happened. That led us to Mission Control, where the mission timeline, delegation, tool calls, memory, evidence, and outcome become part of the product itself.
Accomplishments that we're proud of
We are proud that Atlas has evolved from an intelligence and decision-support environment into an agentic execution layer without losing its original identity.
The biggest accomplishment is Mission Continuity.
A mission can be initiated, planned, executed, paused, resumed, verified, and completed while preserving its context and state. The system is designed around the lifecycle:
INITIATED → PLANNING → EXECUTING → WAITING → RESUMED → VERIFYING → COMPLETED.
We are also proud of creating an architecture where agentic behavior is observable and accountable. Every important execution can be associated with a mission, agent, task, tool invocation, timestamp, status, latency, failures, retries, outputs, and verification state.
Most importantly, Atlas demonstrates a shift in the role of AI:
Atlas does not merely tell you what to do. Atlas coordinates the work required to achieve the objective.
What we learned
We learned that becoming agentic is not primarily about adding a larger model or a smarter prompt.
The real transformation happens when intelligence is connected to:
state + tools + delegation + permissions + memory + verification + execution.
We also learned that autonomous systems need to be designed around missions rather than conversations. A conversation is ephemeral; a mission has objectives, dependencies, state, evidence, approvals, and outcomes.
Another important lesson was that proof matters as much as intelligence. An agent saying it completed something is not enough. The system needs evidence, verification, and observable execution.
And perhaps the most important lesson:
The goal isn't to make AI talk more like an autonomous system. The goal is to make AI actually behave like one.
What's next for Atlas Agentic Operating Layer
The hackathon implementation is the foundation for a broader Atlas agentic ecosystem.
Next, we plan to expand the Agent Registry, introduce richer agent lifecycle management and permissions, grow the tool ecosystem, and strengthen long-running asynchronous missions.
We also see an opportunity to evolve Atlas into a larger mission orchestration platform, where specialized agents can collaborate across research, capital intelligence, environmental projects, knowledge systems, trust systems, and other Atlas domains.
The long-term vision is not to create an AI assistant sitting beside Atlas.
It is to make Atlas itself increasingly autonomous:
Understand the objective. Plan the work. Coordinate the agents. Execute the actions. Verify the outcome. Remember what happened. Continue toward the mission.
That is the next generation of Atlas—and the beginning of an agentic operating layer for real-world work.
Built With
- agentic-ai
- ai-agents
- ai-orchestration
- autonomous-agents
- cloud-run
- firestore
- generative-ai
- google-adk
- google-cloud
- google-gemini
- llm
- multi-agent-systems
- pub/sub
- vertex-ai
Log in or sign up for Devpost to join the conversation.