# Full-stack Go, with agents at the table

## Route

- **Path:** `/`
- **Type:** page
- **Description:** An early (v0.x) Go full-stack framework where AI agents are first-class authors. Declare your domain in Go; get REST, MCP tools, OpenAPI, migrations, and a typed client — to disk, in plain Go.

---

## Page Content

early · v0.10.0

# Full-stack Go, with agents at the table.

**GoFastr** is a Go full-stack framework. You wire your app in Go like you'd wire `net/http` — declare your domain and get **screens**, REST endpoints, MCP tools, an OpenAPI spec, SQL migrations, and a typed query builder, all on disk in plain Go you can read and step through.

The same surface is wired for AI agents from day one. Every entity ships with an MCP tool surface; **Kiln** (experimental) is a separate binary that lets an agent author your app in chat while you watch the code change.

[Get started](/get-started)[Read the docs](/docs/)

$ go install github.com/DonaldMurillo/gofastr/cmd/gofastr@latest

blog/main.go
30 linescopycopied

package main​import (  "github.com/DonaldMurillo/gofastr/framework"  "github.com/DonaldMurillo/gofastr/battery/auth"  f "github.com/DonaldMurillo/gofastr/framework/field")​func main() {  app := framework.New(framework.Config{    Name: "blog",    DB:   framework.SQLite("./blog.db"),  })​  app.Use(auth.Memory())  // swap for auth.Postgres() in prod​  // One call. Generates SQL, REST, MCP, OpenAPI, Go types.  app.Entity("posts", framework.Entity{    Fields: framework.Fields{      "title":  f.String().Required(),      "slug":   f.Slug().From("title"),      "body":   f.Markdown(),      "status": f.Enum("draft", "published").Default("draft"),    },    Timestamps: true,    Expose:     framework.Expose{REST: true, MCP: true},  })​  app.Serve(":8080")}

01 / one file, a real app

## One file. A whole app — screens included.

A `gofastr.yml` blueprint declares your entities **and the screens** that render them — list tables, forms, detail pages, charts, a marketing site. `gofastr generate` writes owned Go you read and edit. Not a CRUD scaffold.

gofastr.yml
29 linescopycopied

app:  name: Meridian​entities:  - name: customers    fields:      - name: name        type: string        required: true      - name: plan        type: enum        values: [free, pro, enterprise]      - name: mrr        type: decimal      - name: status        type: enum        values: [active, churned]​screens:  - name: customers    route: /customers    body:      - kind: page_header        props:          title: Customers      - kind: entity_list        entity: customers        create: true        fields: [name, plan, mrr, status]

 $ gofastr generate --from=gofastr.yml

→ wrote main.go, entities/register.go, blueprint/screens.go
→ 1 entity · 3 screens · migrations/0001_init.up.sql
→ next: go run .

`gofastr.yml` is the on-ramp, not a runtime lock-in — after generating, the Go is canonical and you can delete it. [→ See the Meridian blueprint](/examples#meridian)

meridian.local/customers

### Customers
+ New customer

| Name | Plan | MRR | Status |
| --- | --- | --- | --- |
| Acme Corp | pro | $1,240 | active |
| Globex | enterprise | $8,900 | active |
| Initech | free | $0 | churned |
| Umbrella | pro | $2,150 | active |

/customers — generated, server-rendered, owned Go you can edit.

02 / what it generates

## One entity call generates the surfaces your app and your agent both need.

Output lands on disk under `gen/` as regular Go and SQL. There is no reflection at runtime; if something the framework does feels like magic, open the generated file and read it.

01

SQL table + migration

Versioned, ordered, reversible. `up`/`down` SQL emitted as plain files.

`migrations/`

02

REST endpoints

List, get, create, update, delete, batch. Cursor + offset pagination. Filter DSL on the query string.

`GET POST /posts`

03

MCP tool surface

`posts_list`, `posts_get`, `posts_create`, `posts_update`, `posts_delete`. Same auth + access rules as REST.

`core/mcp`

04

OpenAPI 3 spec

Schema, parameters, responses. Swagger UI auto-mounted at `/api/docs`.

`/openapi.json`

05

Typed Go model + query builder

`posts.Query(ctx).Where(posts.Status.Eq("published")).List(20)`. No reflection, no `interface{}`.

`gen/entities/posts.go`

06

Lifecycle hook slots

`BeforeCreate`, `AfterUpdate`, `BeforeDelete` — your code runs in the parent transaction.

`framework/hook`

07

Admin UI (opt-in)

A listing + form per entity. Off by default. Add `Admin: true` to enable.

`/admin/posts`

03 / architecture

## Two layers. Twelve batteries. Drop down whenever.

`core/` is stdlib-only Go primitives. `framework/` is the opinionated entity layer composed on top. If the framework is in your way, you drop down to core — the imports change, your code doesn't.

#### The floor

core/

Twelve primitives. Stdlib only. Works standalone.

**router**  **handler**  **middleware**
**query**  **mcp**  **schema**  **migrate**
**render**  **stream**  **openapi**
**static**  **upload**

#### The frame

framework/

The opinionated entity system, composed on top of core. ~25 packages.

**entity**  **crud**  **filter**  **dsl**
**hook**  **migrate**  **tenant**  **access**
**file**  **cron**  **event**  **log**
**ui**  …and more

#### Pluggable

battery/

One interface per concern. In-memory dev driver, production driver behind the same shape. Swap without forking.

**auth**  **cache**  **email**  **embed**
**notify**  **queue**  **search**  **storage**
**webhook**  **log**  **admin**  **print**

#### UI runtime

core-ui/

Server-driven. Signals + HTML primitives + islands + SSE. ~10 KB gz vanilla JS. No React.

**signal**  **html**  **island**  **stream**
**accordion**  **tabs**  **modal**
**drawer**  **popover**  **toast**

04 / agents

## The agent's view of your app is the same as yours.

Same database, same routes, same files on disk. The MCP tool surface is just the REST surface in a different shape. Destructive changes require an approved plan; the agent cannot drop your tables without you clicking approve.

framework
#### Every entity is an MCP surface

For each entity you declare, the framework registers MCP tools that map 1:1 to your REST surface. An agent connects to `/mcp` and calls them with the same auth context a human would have over HTTP.

- `posts_list` — same access rules as `GET /posts`
- `posts_create` — same validators, same hooks
- `posts_update`, `posts_delete` — same audit log
- Scope per tool with `Expose.MCP.Tools: []string{"list","get"}`

kiln · experimental (separate binary)
#### An agent that authors your app

Kiln mounts a floating chat panel on the running app. The agent calls a typed tool surface (`add_entity`, `add_field`, `propose_plan`, …). Plans render as diffs you approve. The journal is committable.

 $ kiln serve --agent claude-code

→ panel floats on  http://localhost:8765
→ MCP server live  at  /mcp
→ journal           in  .kiln/journal
→ ready · waiting for the agent.

05 / examples

## Seven reference apps. Each runs in one command.

Clone the one that looks like your problem; swap the entity declarations.

[examples/meridian
#### Meridian — SaaS console

The flagship. A billing console + marketing site + auth + admin, generated from one `gofastr.yml` with writable add/edit/delete screens.
`cd examples/meridian && go run .`](/examples#meridian)[examples/blog
#### Go-declared blog

Users, posts, comments. Three entities. The smallest end-to-end example — start here.
`cd examples/blog && go run .`](/examples#blog)[examples/site
#### This site

The site you're reading — every framework/ui + core-ui primitive showcased one page each, plus the docs, SEO, wizard, and print demos.
`cd examples/site && go run .`](/examples#site)[examples/api-tour
#### API tour

Every REST endpoint as a chapter. Each chapter has a live `curl` example you run from the page.
`cd examples/api-tour && go run .`](/examples#api-tour)[examples/embed-demo
#### Local semantic search

A markdown corpus indexed locally via `battery/embed`. No external API key, ~180 LoC total.
`cd examples/embed-demo && go run .`](/examples#embed-demo)[examples/spa
#### Vue + GoFastr API

For teams who already have a client app. Shows the framework is happy to just be your typed API.
`cd examples/spa && go run .`](/examples#spa)[examples/static-site
#### Static-site mode

Same renderer, no server. `gofastr build` emits a CDN-friendly bundle.
`cd examples/static-site && gofastr build`](/examples#static-site)

06 / state of the project

early · v0.10.0
## Built in public. Use it to learn, not to ship.

APIs change between commits. `core-ui/` is the active research frontier. The journal is open; rough edges are visible by design. We say no to things — you should know what we're saying no to.

honest aboutBreaking changes between commits — see [the journal](https://github.com/DonaldMurillo/gofastr/commits/main)Half-built batteries, marked WIP in sourceNo upgrade guide between minor versions yetwill not doReflection-driven magic that hides what's runningPricing pages, logo clouds, testimonial carouselsLock-in — drop down to `core/` any timeroadmap, in orderLock `framework/entity` ABIQ3 '26Land `core-ui` 1.0Q4 '26First version we'd suggest shipping2027