Routing & control
Multi-provider routing, fallback, caching, budgets, guardrails and audit logs — so calls are cheap, resilient and accountable. This is freeport.
The org behind freeport
Really Artificial
Open-source infrastructure for AI agents. Built in the open, by humans and agents together — starting with freeport.
Why we exist
Models keep getting smarter. The plumbing didn't.
Every month the models get cheaper, faster and more capable. That's not the bottleneck anymore. The bottleneck is everything around the model — the routing, caching, cost controls, memory, testing and human oversight that turn a single API call into something you can run in production and actually trust.
Today most of that infrastructure is either someone else's cloud you have to send your data to, or glue code each team rebuilds from scratch. Really Artificial builds that layer as open source you run yourself. Our bet: the teams who win with AI won't be the ones with the biggest model — they'll be the ones with the most reliable infrastructure around it.
What we're building
The layer between a model and a real system.
A raw LLM call isn't enough to be dependable. Production agents need infrastructure underneath them. We build it one piece at a time — and we ship a piece before we talk about it.
What the agent remembers
Local-first memory that retains facts, recalls what matters and reflects on it over time — without shipping your context to a third party.
Knowing it works
Tooling to test agent and MCP-server behaviour before it reaches production, so reliability is measured, not hoped for.
Humans in the loop
A clear, auditable way for an agent to ask a human before it acts — because autonomy without a brake isn't something you can ship to a regulated team.
How we work
Built by humans and agents. Honest by default.
Really Artificial is run by a small team — a human founder and AI agents working alongside each other. Both show up in the git history, both are credited. A few principles keep us honest:
Open by default
MIT-licensed and self-hostable. You can read every line, run it on your own infrastructure, and fork it if we let you down. No lock-in.
Honest by default
We show what's shipped and what's still early. No fabricated metrics, no fake testimonials, no benchmarks we can't reproduce. We'd rather earn the numbers than invent them.
Ship real things
A working docker run beats a manifesto. Every claim on these pages maps to code in the repo, not a roadmap.
Humans + agents, together
Agents do the mechanical work; humans own every public claim and every decision that matters. We're building the infrastructure we ourselves need to do that well.
The projects
What's in the open right now.
freeport
The open-source LLM gateway you run yourself — routing, caching, budgets, guardrails, audit logs.
● Shipping mcp-jestTesting for Model Context Protocol servers. Ship MCP servers with confidence. On npm.
Maintained engramLocal-first agent memory — retain, recall, reflect — backed by SQLite, with an MCP server.
Early approvalprotocolA protocol for human approval before an AI agent takes an action.
ExperimentalWhere this goes
The reliable layer under every serious agent.
We start with the gateway because it's the piece every team needs first and the one we can stand behind today. Over time the pieces connect: a request flows through routing and guardrails, against memory the agent owns, with the tests to prove it behaves and the oversight to keep a human in the loop — all open, all self-hostable, all yours.
That's the layer we're building toward. If that's the kind of infrastructure you need, the best place to start is freeport.