Development ecosystem

An open place to build, not a locked box

Every tool, agent and screen in Smart Forge is a plain file in your own git repository. Your team builds and tests it in the browser, a reviewer approves the change like any other software, and after the merge it is there for the whole organisation.

01

Not a locked-in system

Many AI platforms keep what you build inside them. Smart Forge does the opposite. What your team builds stays yours, in formats any developer can read, and it can be used from outside Smart Forge as well.

Plain files

A tool is a short definition in JSON plus a code file in SQL, Python or the system's own proprietary language. Agents are JSON. Skills are Markdown. Nothing is stored in a hidden format.

In your own repository

The files live in a git repository you own. History, branches and access are yours, and they stay if you ever stop using Smart Forge.

Usable from other AI tools

Your tools are served outward over MCP, the open standard for AI tools, so assistants your people already use can call them. There is a plain web API as well.

02

What a tool is made of

A tool has two parts: a definition that tells the AI what the tool is for, filled in as a form, and the code that does the work. People write and review both. The AI only ever chooses which tool to call and what to pass.

  • DescriptionThe sentence the AI reads to decide when to use the tool.
  • ArgumentsEach one has a name, a type and a description. It can be required, limited to a list of allowed values, or grouped so that at least one of several is given.
  • ResponseThe columns the tool returns, so the result can be shown, saved and queried.
  • OperationRead or write. It comes from the tool's tag (List and Get read; Create, Update and Delete write) and decides which guardrails apply.
  • ActiveSwitch a tool off without deleting it.

The arguments are checked on every call: the type, the allowed values, what is required, and anything unexpected. A call that fails the check never reaches your system.

03

Three kinds of code, one shape

The code is whatever the system already speaks. That is how an old system, a modern one with no AI of its own, and a web service all end up as the same kind of tool.

Extend what you already have

A tool is not limited to passing a call through. Because the code is yours, you can put your own rules around it.

  • Add business rulesIn Python, call a web service, then filter, combine or reshape the result with your own logic before it is returned.
  • Prepare an input with another toolAn argument can be run through another tool first, for example to turn a customer name into the customer number the system expects.
  • Reuse fieldsCommon arguments and response columns are defined once per system and shared by every tool that needs them.
  • One tool across systemsAn Enterprise tool asks the same question of several systems and returns one table. Read about Enterprise queries.

04

Test in the browser before anyone sees it

A developer does not have to push anything to find out whether a tool works. Testing happens in the browser, against a real connection, before anyone else sees the change.

  • Dev ConsoleFill in the inputs, pick a connection and press Run. You see the rows, the raw output, the time it took and any error.
  • Try ItRuns your local, unpushed version with your own arguments and shows the timing and row count for each connection.
  • Live TestChat against your unpushed changes, to see how the AI uses the tool in a real conversation.
  • EvalAsks the AI a set of test questions and scores whether it picked the right tool and filled in the right arguments.
  • A built-in language referenceHelp for the scripting language sits beside the code.

05

The same life cycle as any software

Tools and agents go through the same steps as the rest of your software. Nothing reaches your people until a reviewer has approved it and it has been merged.

  1. Build in your own projectEach developer works in a private copy of the repository, in the browser. Changes save as they type.
  2. Push to a branchPick the changed files, read the difference, name the branch and write a commit message. Smart Forge checks first that each tool carries its tags and that agent and skill files are valid.
  3. Open a pull requestThe pull request is opened in your git provider, where your team already reviews code.
  4. Review and mergeA reviewer reads the change, asks for edits or approves it, and it is merged into the main branch.
  5. Available to everyoneThe organisation's shared copy picks up the main branch, and the new tool or agent can be used in chat, by agents, on screens and over MCP.

Review and merge happen in your git provider, not inside Smart Forge. The repository also carries an open schema and a validator that your own pipeline can run on every pull request.

06

Domains and connections

Two pieces of set-up sit underneath the tools. They are configured once and reused everywhere.

  • DomainThe dictionary of fields for one system: what an order number or a site is, its type, its allowed values, and how it should look on a screen (label, placeholder, validation, input mask).
  • ConnectionOne instance of a system. It has a name, an environment (Prod, Test or Dev) and the settings that system needs.
  • CredentialsEach person signs in to a connection with their own credentials, so a tool runs as them.

07

Live for the whole organisation

After the merge there is nothing more to wire up. The same tool is used in every place Smart Forge works.

Cortex chatPeople ask in plain language.
AgentsDeployed and scheduled agents call it.
ScreensForgeView builds screens from it.
Other AI toolsServed outward over MCP.

From here, see how an agent is put together from these tools: Agents are configured, not developed.