{"slug": "start-an-ai-agent-project-not-just-an-agent", "title": "Start an AI Agent Project, Not Just an Agent", "summary": "Blazity released Atlas Eve Starter, a public GitHub template that provides a project structure for building durable AI agents with Eve, Vercel's open-source framework. The starter includes a pnpm monorepo, formatting, linting, tests, dependency maintenance, and Atlas AI context, separating model-guided behavior from deterministic code to simplify debugging and iteration.", "body_md": "Starting an AI agent is easy. The hard part is what comes after: iterating on it in production without the whole thing turning into a mess.\n\nRequirements that belong in code leak into prompts. Shared types get copied between files. And when something breaks, debugging is rough, because nothing separates what the model decided from what your code actually did.\n\n[Atlas Eve Starter](https://github.com/Blazity/atlas-eve-starter) is a public GitHub template that hands you a project shape before any of that sets in. The short version: the default Eve scaffold helps you start an *agent*; this starter helps you start an agent *project*.\n\nIt keeps the Eve app small and replaceable, then wraps it in the engineering defaults you would add yourself a week later anyway: a pnpm monorepo, formatting and linting, tests, dependency maintenance, and Atlas AI context for the people and coding agents working in the repo.\n\n[Eve](https://eve.dev/docs) is Vercel's open-source, filesystem-first framework for durable backend AI agents. Instead of one large configuration object, you describe an agent as a directory of files: instructions in Markdown, deterministic behavior in typed tools, ingress surfaces in channels, and evals next to the code they check. Eve discovers those files and compiles them into an app.\n\nThat layout is the point. Real agents have to be inspected, reviewed, tested, and changed over time, and a folder of small files is much easier to reason about than a monolithic config.\n\nWhat you get from Eve is more than a chat loop:\n\nIn practice, that means ops bots that live in Slack, GitHub and Linear automations, and webhook-driven backend agents: long-running work where \"it crashed halfway through\" is not an acceptable outcome.\n\nThe default scaffold is deliberately minimal: an agent file, a channel, instructions, and TypeScript setup. That's the right way to learn the framework. Atlas Eve Starter picks up at the next step, when you already suspect the agent will end up inside a real product.\n\nHere is the shape the starter gives you:\n\n```\natlas-eve-starter/\n├─ apps/\n│  └─ example-agent/\n│     ├─ agent/\n│     │  ├─ agent.ts            # root agent config\n│     │  ├─ instructions.md     # system prompt\n│     │  ├─ tools/echo.ts       # typed tool\n│     │  └─ channels/http.ts    # custom HTTP ingress with input validation\n│     ├─ evals/example.eval.ts  # opt-in smoke eval\n│     └─ tests/echo.test.ts     # plain unit test for the tool\n├─ packages/\n│  └─ example/                  # shared Zod contracts (no Eve dependency)\n└─ .ai/                         # Atlas: memory, skills, decisions, plans, vocabulary\n```\n\nThe example app is intentionally domain-neutral and not meant to be a finished product.\n\nThe boundary between model-guided behavior and deterministic code is already in place. The app is a shell, but it hands you the structure and building blocks to expand into something functional.\n\nShared contracts live in their own package, with no dependency on Eve:\n\n``` js\n// packages/example/src/index.ts\nexport const exampleRequestSchema = z.object({\n  message: z.string().trim().min(1, \"Message must not be empty.\"),\n});\n\nexport type ExampleRequest = z.infer<typeof exampleRequestSchema>;\n```\n\nA tool imports that contract and stays an ordinary, testable function, with no model in the loop:\n\n```\n// apps/example-agent/agent/tools/echo.ts\nexport function createEchoResponse(request: ExampleRequest): ExampleResponse {\n  return {\n    echoedMessage: request.message,\n    messageLength: request.message.length,\n  };\n}\n\nexport default defineTool({\n  inputSchema: exampleRequestSchema,\n  execute(input) {\n    return createEchoResponse(input);\n  },\n});\n```\n\nAnd the channel validates input at the edge, before anything reaches the agent:\n\n```\n// apps/example-agent/agent/channels/http.ts\nPOST(\"/echo\", async (req, { send }) => {\n  const body = await req.json().catch(() => ({}));\n  const parsed = exampleRequestSchema.safeParse(body);\n\n  if (!parsed.success) {\n    return Response.json(\n      { error: \"Invalid example request.\", issues: parsed.error.issues },\n      { status: 400 },\n    );\n  }\n\n  // valid input → hand the message off to the agent\n});\n```\n\nThe same Zod schema backs the package, the tool, and the channel. You can unit-test the deterministic parts directly while the model handles only the model-shaped work. That is what makes the project easier to review, and to debug when something goes wrong.\n\nThe default Eve scaffold covers the essentials. Atlas Eve Starter adds what teams reach for once a project gets serious:\n\n`.ai`\n\nproject context, present from the startAtlas is Blazity's framework-agnostic AI engineering scaffold. In this starter it gives the repo a shared memory layer that people and coding agents both read from: project vocabulary, architecture and stack notes, artifact paths, and repo-local skills for creating or auditing Eve agent changes.\n\nThe practical effect is that a coding agent dropped into the project does not have to guess from filenames. It can read the rules first: what the starter is for, which files define agent behavior, where shared contracts belong, which checks are safe to run, and which model-backed checks are opt-in. If your team works with AI coding tools, that context takes a lot of ambiguity out of review.\n\nUse Atlas Eve Starter when you want to evaluate Eve with a clean project structure, keep prompt behavior separate from deterministic code, and give reviewers and coding agents clear boundaries from the start. It is more structure than a throwaway demo needs. If the agent might become part of a product, that structure pays for itself quickly.\n\nThe template is on GitHub: [github.com/Blazity/atlas-eve-starter](https://github.com/Blazity/atlas-eve-starter). Create a repo from the template, then:\n\n```\npnpm install\npnpm --filter @repo/example-agent dev\npnpm check && pnpm typecheck && pnpm test\n```\n\nFrom there, replace the example app with your own behavior and keep the boundaries explicit from the first commit. That's how we build Eve agents at Blazity: clear structure, typed contracts, reviewable behavior, and AI context that helps the next contributor, human or otherwise, get up to speed faster.", "url": "https://wpnews.pro/news/start-an-ai-agent-project-not-just-an-agent", "canonical_source": "https://dev.to/jjablonskiit/start-an-ai-agent-project-not-just-an-agent-2gpo", "published_at": "2026-06-24 11:34:32+00:00", "updated_at": "2026-06-24 11:39:44.572748+00:00", "lang": "en", "topics": ["ai-agents", "developer-tools", "ai-infrastructure"], "entities": ["Blazity", "Atlas Eve Starter", "Eve", "Vercel", "GitHub"], "alternates": {"html": "https://wpnews.pro/news/start-an-ai-agent-project-not-just-an-agent", "markdown": "https://wpnews.pro/news/start-an-ai-agent-project-not-just-an-agent.md", "text": "https://wpnews.pro/news/start-an-ai-agent-project-not-just-an-agent.txt", "jsonld": "https://wpnews.pro/news/start-an-ai-agent-project-not-just-an-agent.jsonld"}}