Astromesh Prisma

In development — not installable yet

Prisma v0.2.1 translates and reconciles against an in-memory gateway: it provisions nothing in GCP yet. Its repository is private and the package is not on PyPI. It is on the ecosystem map because it is part of the shape of the stack. These pages describe what the code does today and say plainly what it does not.

Astromesh Prisma in development takes an agent you wrote for Astromesh and turns it into the target cloud’s own native agent, running on that cloud’s base resources. The YAML the runtime loads (kind: Agent, kind: RAGPipeline) stays the source of truth, and a reconcile loop drives the cloud toward it, the way a Kubernetes operator does.

On GCP, the native agent is an ADK agent config that Agent Engine deploys declaratively. Prisma does not generate agent code: it writes that config and wires it to Agent Engine Sessions, Memory Bank, a RAG Engine corpus and a Model Armor template.

The idea: gaps are never silent

Whatever the native agent cannot do the way Astromesh does is reported, section by section, with the reason. Three mechanisms keep that honest:

• The coverage matrix is generated from the same registry that does the translation, so it cannot drift from the code. See Coverage.
• A contract test walks every key of the core’s agent.schema.json and fails when the core adds one that Prisma has not decided on, either by mapping it or by naming the gap.
• A test runs the generated agent inside ADK with a recording model in place of Gemini and checks the request it would send.

The GCP surface was read from the aiplatform v1 discovery document (revision 20260920) and the google-adk 2.10.0 source, not from memory.

From your agent to GCP’s agent

In your YAML	On GCP	How the native agent uses it
prompts.system, model, sampling settings	The ADK config	instruction (or static_instruction), model, generate_content_config
memory.conversational	Agent Engine Sessions	Built into the engine
memory.semantic	The engine’s Memory Bank	preload_memory reads it; a callback writes every turn
knowledge.pipeline	The RAG Engine corpus of that pipeline’s manifest	A retrieval tool bound to the corpus
pii_detection guardrail	A Model Armor template	model_armor_config, on the side the rule is declared
type: client tools	—	A long-running tool: the model asks, your app answers
builtin web_search	Google Search grounding	ADK’s GoogleSearchTool
orchestration.pattern: pipeline	—	A SequentialAgent with one sub-agent per stage

Model routing and fallback, episodic memory, integration/api/mcp tools, agent tools, and the parallel_fan_out, supervisor, swarm and glyph patterns do not translate. Each appears as a gap with its reason. The full mapping is in Translation to GCP.

Prisma or Orbit?

Both put an Astromesh workload on GCP. They disagree about who runs it.

	Orbit	Prisma
What runs your agent	The Astromesh runtime, on infrastructure you own	The cloud’s own managed agent service
What it produces	Terraform you can eject to and keep	Native cloud resources, reconciled continuously
You get	The whole runtime: every pattern, every tool type	What that cloud’s primitives can express
You give up	Nothing about the runtime; you operate it	Runtime features the cloud has no home for
Status	Released (v0.4.4)	In development

Choose Orbit to run the runtime on GCP today. Prisma is for handing the workload to the cloud’s managed service, accepting a smaller surface — which is why the coverage matrix exists.

How it is put together

astromesh_prisma/
  spec/         the manifest as pydantic models (Agent, RAGPipeline)
  mapping/      HomologMappingRegistry (section → mapper), ManifestRouter (by kind),
                coverage generator
  providers/    CloudProvider protocol; gcp/ and an in-memory fake
    gcp/adk.py            Agent → ADK agent config + bindings
    gcp/runtime/          prisma_tools.py, shipped with the config to Agent Engine
  reconcile/    observe → diff → apply, per (kind, name)
  state/        submitted manifests, keyed by (kind, name)
  api/          the FastAPI surface

Identity is (kind, name), not name: an Agent and a RAGPipeline with the same name are two things, and a single-key store used to lose one of them.

What is not true yet

• Nothing is provisioned for real. Every run goes through the in-memory gateway. The real GCP gateway is designed and parked.
• Bindings are not resolved. Turning prisma:// references into real resource names, building the engine’s source archive and waiting on long-running operations are the real gateway’s job.
• Submitted manifests live in memory and are lost when the process stops.
• Marketplace distribution is a plan, not a capability.

Next steps

Run it locally and translate an agent	Quick Start
What each section becomes on GCP	Translation to GCP
Every section and its status	Coverage
The HTTP routes	API Reference
Run the runtime itself on GCP, today	Astromesh Orbit